audit-context-building

Document architectural context through line-by-line code analysis.

77|3|Updated Mar 24, 2026
One-click install
npx skills add https://github.com/FlorianBruniaux/starmapper --skill audit-context-building-florianbruniaux
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: audit-context-building
Source: https://github.com/FlorianBruniaux/starmapper/tree/main/.claude/plugins/audit-context-building/skills/audit-context-building
Command: npx skills add https://github.com/FlorianBruniaux/starmapper --skill audit-context-building-florianbruniaux

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill enables ultra-granular, line-by-line code analysis to build deep architectural context before vulnerability or bug finding.

Core Features & Use Cases

  • Ultra-granular analysis: inspect each block and line to map invariants, assumptions, and dependencies.
  • Structured reasoning: apply First Principles, 5 Whys, and 5 Hows to deepen understanding.
  • Context preservation: maintain a persistent mental model linking functions, modules, and system goals.

Quick Start

Identify and document a deep architectural context by performing ultra-granular, line-by-line code analysis.

Frequently Asked Questions about audit-context-building

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build deep code context before a security audit?

Build deep code context for a security audit by performing ultra-granular, line-by-line analysis to map invariants, assumptions, and cross-function dependencies. This structured micro-analysis establishes a persistent architectural mental model prior to vulnerability discovery.

What is the best way to document invariants and assumptions for threat modeling?

Documenting invariants and assumptions for threat modeling requires a structured reasoning approach applying First Principles, 5 Whys, and 5 Hows. This enforces micro-analysis of external calls and dependencies to deepen bottom-up system understanding.

How do I perform line-by-line code analysis for architecture reviews?

Perform line-by-line code analysis for architecture reviews by inspecting each block to identify risk considerations for external calls and cross-function dependencies. This preserves context by linking modules, functions, and system goals in a persistent mental model.

Can I use structured reasoning techniques to map cross-function dependencies?

Yes, you can map cross-function dependencies using structured reasoning techniques like First Principles, 5 Whys, and 5 Hows. These methods enforce a bottom-up understanding that links individual code lines to broader architectural goals and external call risks.

Does bottom-up code analysis work for vulnerability discovery in complex systems?

Bottom-up code analysis works for vulnerability discovery in complex systems by enforcing context retention through ultra-granular inspection. It identifies hidden assumptions and invariants across modules, ensuring a robust architectural understanding is loaded before finding vulnerabilities.