[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-trail-of-bits-audit-context-building":3,"mdc--iooz1x-key":38,"related-org-trail-of-bits-audit-context-building":1503,"related-repo-trail-of-bits-audit-context-building":1651},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":12,"stars":26,"repoUrl":27,"updatedAt":28,"license":29,"forks":30,"topics":31,"repo":33,"sourceUrl":36,"mdContent":37},"audit-context-building","build architectural context for code analysis","Enables ultra-granular, line-by-line code analysis to build deep architectural context before vulnerability or bug finding.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},"trail-of-bits","Trail of Bits","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Ftrail-of-bits.png","trailofbits",[13,17,20,23],{"name":14,"slug":15,"type":16},"Architecture","architecture","tag",{"name":18,"slug":19,"type":16},"Audit","audit",{"name":21,"slug":22,"type":16},"Engineering","engineering",{"name":24,"slug":25,"type":16},"Code Analysis","code-analysis",6139,"https:\u002F\u002Fgithub.com\u002Ftrailofbits\u002Fskills","2026-07-18T05:47:40.122449",null,541,[32],"agent-skills",{"repoUrl":27,"stars":26,"forks":30,"topics":34,"description":35},[32],"Trail of Bits Claude Code skills for security research, vulnerability detection, and audit workflows","https:\u002F\u002Fgithub.com\u002Ftrailofbits\u002Fskills\u002Ftree\u002FHEAD\u002Fplugins\u002Faudit-context-building\u002Fskills\u002Faudit-context-building","---\nname: audit-context-building\ndescription: Enables ultra-granular, line-by-line code analysis to build deep architectural context before vulnerability or bug finding.\n---\n\n# Deep Context Builder Skill (Ultra-Granular Pure Context Mode)\n\n## 1. Purpose\n\nThis skill governs **how Claude thinks** during the context-building phase of an audit.\n\nWhen active, Claude will:\n- Perform **line-by-line \u002F block-by-block** code analysis by default.\n- Apply **First Principles**, **5 Whys**, and **5 Hows** at micro scale.\n- Continuously link insights → functions → modules → entire system.\n- Maintain a stable, explicit mental model that evolves with new evidence.\n- Identify invariants, assumptions, flows, and reasoning hazards.\n\nThis skill defines a structured analysis format (see Example: Function Micro-Analysis below) and runs **before** the vulnerability-hunting phase.\n\n---\n\n## 2. When to Use This Skill\n\nUse when:\n- Deep comprehension is needed before bug or vulnerability discovery.\n- You want bottom-up understanding instead of high-level guessing.\n- Reducing hallucinations, contradictions, and context loss is critical.\n- Preparing for security auditing, architecture review, or threat modeling.\n\nDo **not** use for:\n- Vulnerability findings\n- Fix recommendations\n- Exploit reasoning\n- Severity\u002Fimpact rating\n\n---\n\n## 3. How This Skill Behaves\n\nWhen active, Claude will:\n- Default to **ultra-granular analysis** of each block and line.\n- Apply micro-level First Principles, 5 Whys, and 5 Hows.\n- Build and refine a persistent global mental model.\n- Update earlier assumptions when contradicted (\"Earlier I thought X; now Y.\").\n- Periodically anchor summaries to maintain stable context.\n- Avoid speculation; express uncertainty explicitly when needed.\n\nGoal: **deep, accurate understanding**, not conclusions.\n\n---\n\n## Rationalizations (Do Not Skip)\n\n| Rationalization | Why It's Wrong | Required Action |\n|-----------------|----------------|-----------------|\n| \"I get the gist\" | Gist-level understanding misses edge cases | Line-by-line analysis required |\n| \"This function is simple\" | Simple functions compose into complex bugs | Apply 5 Whys anyway |\n| \"I'll remember this invariant\" | You won't. Context degrades. | Write it down explicitly |\n| \"External call is probably fine\" | External = adversarial until proven otherwise | Jump into code or model as hostile |\n| \"I can skip this helper\" | Helpers contain assumptions that propagate | Trace the full call chain |\n| \"This is taking too long\" | Rushed context = hallucinated vulnerabilities later | Slow is fast |\n\n---\n\n## 4. Phase 1 — Initial Orientation (Bottom-Up Scan)\n\nBefore deep analysis, Claude performs a minimal mapping:\n\n1. Identify major modules\u002Ffiles\u002Fcontracts.\n2. Note obvious public\u002Fexternal entrypoints.\n3. Identify likely actors (users, owners, relayers, oracles, other contracts).\n4. Identify important storage variables, dicts, state structs, or cells.\n5. Build a preliminary structure without assuming behavior.\n\nThis establishes anchors for detailed analysis.\n\n---\n\n## 5. Phase 2 — Ultra-Granular Function Analysis (Default Mode)\n\nEvery non-trivial function receives full micro analysis.\n\n### 5.1 Per-Function Microstructure Checklist\n\nFor each function:\n\n1. **Purpose**\n   - Why the function exists and its role in the system.\n\n2. **Inputs & Assumptions**\n   - Parameters and implicit inputs (state, sender, env).\n   - Preconditions and constraints.\n\n3. **Outputs & Effects**\n   - Return values.\n   - State\u002Fstorage writes.\n   - Events\u002Fmessages.\n   - External interactions.\n\n4. **Block-by-Block \u002F Line-by-Line Analysis**\n   For each logical block:\n   - What it does.\n   - Why it appears here (ordering logic).\n   - What assumptions it relies on.\n   - What invariants it establishes or maintains.\n   - What later logic depends on it.\n\n   Apply per-block:\n   - **First Principles**\n   - **5 Whys**\n   - **5 Hows**\n\n---\n\n### 5.2 Cross-Function & External Flow Analysis\n*(Full Integration of Jump-Into-External-Code Rule)*\n\nWhen encountering calls, **continue the same micro-first analysis across boundaries.**\n\n#### Internal Calls\n- Jump into the callee immediately.\n- Perform block-by-block analysis of relevant code.\n- Track flow of data, assumptions, and invariants:\n  caller → callee → return → caller.\n- Note if callee logic behaves differently in this specific call context.\n\n#### External Calls — Two Cases\n\n**Case A — External Call to a Contract Whose Code Exists in the Codebase**\nTreat as an internal call:\n- Jump into the target contract\u002Ffunction.\n- Continue block-by-block micro-analysis.\n- Propagate invariants and assumptions seamlessly.\n- Consider edge cases based on the *actual* code, not a black-box guess.\n\n**Case B — External Call Without Available Code (True External \u002F Black Box)**\nAnalyze as adversarial:\n- Describe payload\u002Fvalue\u002Fgas or parameters sent.\n- Identify assumptions about the target.\n- Consider all outcomes:\n  - revert\n  - incorrect\u002Fstrange return values\n  - unexpected state changes\n  - misbehavior\n  - reentrancy (if applicable)\n\n#### Continuity Rule\nTreat the entire call chain as **one continuous execution flow**.\nNever reset context.\nAll invariants, assumptions, and data dependencies must propagate across calls.\n\n---\n\n### 5.3 Complete Analysis Example\n\nSee [FUNCTION_MICRO_ANALYSIS_EXAMPLE.md](resources\u002FFUNCTION_MICRO_ANALYSIS_EXAMPLE.md) for a complete walkthrough demonstrating:\n- Full micro-analysis of a DEX swap function\n- Application of First Principles, 5 Whys, and 5 Hows\n- Block-by-block analysis with invariants and assumptions\n- Cross-function dependency mapping\n- Risk analysis for external interactions\n\nThis example demonstrates the level of depth and structure required for all analyzed functions.\n\n---\n\n### 5.4 Output Requirements\n\nWhen performing ultra-granular analysis, Claude MUST structure output following the format defined in [OUTPUT_REQUIREMENTS.md](resources\u002FOUTPUT_REQUIREMENTS.md).\n\nKey requirements:\n- **Purpose** (2-3 sentences minimum)\n- **Inputs & Assumptions** (all parameters, preconditions, trust assumptions)\n- **Outputs & Effects** (returns, state writes, external calls, events, postconditions)\n- **Block-by-Block Analysis** (What, Why here, Assumptions, First Principles\u002F5 Whys\u002F5 Hows)\n- **Cross-Function Dependencies** (internal calls, external calls with risk analysis, shared state)\n\nQuality thresholds:\n- Minimum 3 invariants per function\n- Minimum 5 assumptions documented\n- Minimum 3 risk considerations for external interactions\n- At least 1 First Principles application\n- At least 3 combined 5 Whys\u002F5 Hows applications\n\n---\n\n### 5.5 Completeness Checklist\n\nBefore concluding micro-analysis of a function, verify against the [COMPLETENESS_CHECKLIST.md](resources\u002FCOMPLETENESS_CHECKLIST.md):\n\n- **Structural Completeness**: All required sections present (Purpose, Inputs, Outputs, Block-by-Block, Dependencies)\n- **Content Depth**: Minimum thresholds met (invariants, assumptions, risk analysis, First Principles)\n- **Continuity & Integration**: Cross-references, propagated assumptions, invariant couplings\n- **Anti-Hallucination**: Line number citations, no vague statements, evidence-based claims\n\nAnalysis is complete when all checklist items are satisfied and no unresolved \"unclear\" items remain.\n\n---\n\n## 6. Phase 3 — Global System Understanding\n\nAfter sufficient micro-analysis:\n\n1. **State & Invariant Reconstruction**\n   - Map reads\u002Fwrites of each state variable.\n   - Derive multi-function and multi-module invariants.\n\n2. **Workflow Reconstruction**\n   - Identify end-to-end flows (deposit, withdraw, lifecycle, upgrades).\n   - Track how state transforms across these flows.\n   - Record assumptions that persist across steps.\n\n3. **Trust Boundary Mapping**\n   - Actor → entrypoint → behavior.\n   - Identify untrusted input paths.\n   - Privilege changes and implicit role expectations.\n\n4. **Complexity & Fragility Clustering**\n   - Functions with many assumptions.\n   - High branching logic.\n   - Multi-step dependencies.\n   - Coupled state changes across modules.\n\nThese clusters help guide the vulnerability-hunting phase.\n\n---\n\n## 7. Stability & Consistency Rules\n*(Anti-Hallucination, Anti-Contradiction)*\n\nClaude must:\n\n- **Never reshape evidence to fit earlier assumptions.**\n  When contradicted:\n  - Update the model.\n  - State the correction explicitly.\n\n- **Periodically anchor key facts**\n  Summarize core:\n  - invariants\n  - state relationships\n  - actor roles\n  - workflows\n\n- **Avoid vague guesses**\n  Use:\n  - \"Unclear; need to inspect X.\"\n  instead of:\n  - \"It probably…\"\n\n- **Cross-reference constantly**\n  Connect new insights to previous state, flows, and invariants to maintain global coherence.\n\n---\n\n## 8. Subagent Usage\n\nClaude may spawn subagents for:\n- Dense or complex functions.\n- Long data-flow or control-flow chains.\n- Cryptographic \u002F mathematical logic.\n- Complex state machines.\n- Multi-module workflow reconstruction.\n\nUse the **`function-analyzer`** agent for per-function deep analysis.\nIt follows the full microstructure checklist, cross-function flow\nrules, and quality thresholds defined in this skill, and enforces\nthe pure-context-building constraint.\n\nSubagents must:\n- Follow the same micro-first rules.\n- Return summaries that Claude integrates into its global model.\n\n---\n\n## 9. Relationship to Other Phases\n\nThis skill runs **before**:\n- Vulnerability discovery\n- Classification \u002F triage\n- Report writing\n- Impact modeling\n- Exploit reasoning\n\nIt exists solely to build:\n- Deep understanding\n- Stable context\n- System-level clarity\n\n---\n\n## 10. Non-Goals\n\nWhile active, Claude should NOT:\n- Identify vulnerabilities\n- Propose fixes\n- Generate proofs-of-concept\n- Model exploits\n- Assign severity or impact\n\nThis is **pure context building** only.\n",{"data":39,"body":40},{"name":4,"description":6},{"type":41,"children":42},"root",[43,52,59,73,78,136,148,152,158,163,186,198,221,224,230,234,274,286,289,295,436,439,445,450,479,484,487,493,498,505,510,649,652,658,667,677,684,707,713,723,753,763,809,815,827,830,836,850,878,883,886,892,905,910,960,965,993,996,1002,1015,1058,1063,1066,1072,1077,1184,1189,1192,1198,1206,1211,1303,1306,1312,1317,1345,1362,1367,1380,1383,1389,1399,1426,1431,1449,1452,1458,1463,1491],{"type":44,"tag":45,"props":46,"children":48},"element","h1",{"id":47},"deep-context-builder-skill-ultra-granular-pure-context-mode",[49],{"type":50,"value":51},"text","Deep Context Builder Skill (Ultra-Granular Pure Context Mode)",{"type":44,"tag":53,"props":54,"children":56},"h2",{"id":55},"_1-purpose",[57],{"type":50,"value":58},"1. Purpose",{"type":44,"tag":60,"props":61,"children":62},"p",{},[63,65,71],{"type":50,"value":64},"This skill governs ",{"type":44,"tag":66,"props":67,"children":68},"strong",{},[69],{"type":50,"value":70},"how Claude thinks",{"type":50,"value":72}," during the context-building phase of an audit.",{"type":44,"tag":60,"props":74,"children":75},{},[76],{"type":50,"value":77},"When active, Claude will:",{"type":44,"tag":79,"props":80,"children":81},"ul",{},[82,95,121,126,131],{"type":44,"tag":83,"props":84,"children":85},"li",{},[86,88,93],{"type":50,"value":87},"Perform ",{"type":44,"tag":66,"props":89,"children":90},{},[91],{"type":50,"value":92},"line-by-line \u002F block-by-block",{"type":50,"value":94}," code analysis by default.",{"type":44,"tag":83,"props":96,"children":97},{},[98,100,105,107,112,114,119],{"type":50,"value":99},"Apply ",{"type":44,"tag":66,"props":101,"children":102},{},[103],{"type":50,"value":104},"First Principles",{"type":50,"value":106},", ",{"type":44,"tag":66,"props":108,"children":109},{},[110],{"type":50,"value":111},"5 Whys",{"type":50,"value":113},", and ",{"type":44,"tag":66,"props":115,"children":116},{},[117],{"type":50,"value":118},"5 Hows",{"type":50,"value":120}," at micro scale.",{"type":44,"tag":83,"props":122,"children":123},{},[124],{"type":50,"value":125},"Continuously link insights → functions → modules → entire system.",{"type":44,"tag":83,"props":127,"children":128},{},[129],{"type":50,"value":130},"Maintain a stable, explicit mental model that evolves with new evidence.",{"type":44,"tag":83,"props":132,"children":133},{},[134],{"type":50,"value":135},"Identify invariants, assumptions, flows, and reasoning hazards.",{"type":44,"tag":60,"props":137,"children":138},{},[139,141,146],{"type":50,"value":140},"This skill defines a structured analysis format (see Example: Function Micro-Analysis below) and runs ",{"type":44,"tag":66,"props":142,"children":143},{},[144],{"type":50,"value":145},"before",{"type":50,"value":147}," the vulnerability-hunting phase.",{"type":44,"tag":149,"props":150,"children":151},"hr",{},[],{"type":44,"tag":53,"props":153,"children":155},{"id":154},"_2-when-to-use-this-skill",[156],{"type":50,"value":157},"2. When to Use This Skill",{"type":44,"tag":60,"props":159,"children":160},{},[161],{"type":50,"value":162},"Use when:",{"type":44,"tag":79,"props":164,"children":165},{},[166,171,176,181],{"type":44,"tag":83,"props":167,"children":168},{},[169],{"type":50,"value":170},"Deep comprehension is needed before bug or vulnerability discovery.",{"type":44,"tag":83,"props":172,"children":173},{},[174],{"type":50,"value":175},"You want bottom-up understanding instead of high-level guessing.",{"type":44,"tag":83,"props":177,"children":178},{},[179],{"type":50,"value":180},"Reducing hallucinations, contradictions, and context loss is critical.",{"type":44,"tag":83,"props":182,"children":183},{},[184],{"type":50,"value":185},"Preparing for security auditing, architecture review, or threat modeling.",{"type":44,"tag":60,"props":187,"children":188},{},[189,191,196],{"type":50,"value":190},"Do ",{"type":44,"tag":66,"props":192,"children":193},{},[194],{"type":50,"value":195},"not",{"type":50,"value":197}," use for:",{"type":44,"tag":79,"props":199,"children":200},{},[201,206,211,216],{"type":44,"tag":83,"props":202,"children":203},{},[204],{"type":50,"value":205},"Vulnerability findings",{"type":44,"tag":83,"props":207,"children":208},{},[209],{"type":50,"value":210},"Fix recommendations",{"type":44,"tag":83,"props":212,"children":213},{},[214],{"type":50,"value":215},"Exploit reasoning",{"type":44,"tag":83,"props":217,"children":218},{},[219],{"type":50,"value":220},"Severity\u002Fimpact rating",{"type":44,"tag":149,"props":222,"children":223},{},[],{"type":44,"tag":53,"props":225,"children":227},{"id":226},"_3-how-this-skill-behaves",[228],{"type":50,"value":229},"3. How This Skill Behaves",{"type":44,"tag":60,"props":231,"children":232},{},[233],{"type":50,"value":77},{"type":44,"tag":79,"props":235,"children":236},{},[237,249,254,259,264,269],{"type":44,"tag":83,"props":238,"children":239},{},[240,242,247],{"type":50,"value":241},"Default to ",{"type":44,"tag":66,"props":243,"children":244},{},[245],{"type":50,"value":246},"ultra-granular analysis",{"type":50,"value":248}," of each block and line.",{"type":44,"tag":83,"props":250,"children":251},{},[252],{"type":50,"value":253},"Apply micro-level First Principles, 5 Whys, and 5 Hows.",{"type":44,"tag":83,"props":255,"children":256},{},[257],{"type":50,"value":258},"Build and refine a persistent global mental model.",{"type":44,"tag":83,"props":260,"children":261},{},[262],{"type":50,"value":263},"Update earlier assumptions when contradicted (\"Earlier I thought X; now Y.\").",{"type":44,"tag":83,"props":265,"children":266},{},[267],{"type":50,"value":268},"Periodically anchor summaries to maintain stable context.",{"type":44,"tag":83,"props":270,"children":271},{},[272],{"type":50,"value":273},"Avoid speculation; express uncertainty explicitly when needed.",{"type":44,"tag":60,"props":275,"children":276},{},[277,279,284],{"type":50,"value":278},"Goal: ",{"type":44,"tag":66,"props":280,"children":281},{},[282],{"type":50,"value":283},"deep, accurate understanding",{"type":50,"value":285},", not conclusions.",{"type":44,"tag":149,"props":287,"children":288},{},[],{"type":44,"tag":53,"props":290,"children":292},{"id":291},"rationalizations-do-not-skip",[293],{"type":50,"value":294},"Rationalizations (Do Not Skip)",{"type":44,"tag":296,"props":297,"children":298},"table",{},[299,323],{"type":44,"tag":300,"props":301,"children":302},"thead",{},[303],{"type":44,"tag":304,"props":305,"children":306},"tr",{},[307,313,318],{"type":44,"tag":308,"props":309,"children":310},"th",{},[311],{"type":50,"value":312},"Rationalization",{"type":44,"tag":308,"props":314,"children":315},{},[316],{"type":50,"value":317},"Why It's Wrong",{"type":44,"tag":308,"props":319,"children":320},{},[321],{"type":50,"value":322},"Required Action",{"type":44,"tag":324,"props":325,"children":326},"tbody",{},[327,346,364,382,400,418],{"type":44,"tag":304,"props":328,"children":329},{},[330,336,341],{"type":44,"tag":331,"props":332,"children":333},"td",{},[334],{"type":50,"value":335},"\"I get the gist\"",{"type":44,"tag":331,"props":337,"children":338},{},[339],{"type":50,"value":340},"Gist-level understanding misses edge cases",{"type":44,"tag":331,"props":342,"children":343},{},[344],{"type":50,"value":345},"Line-by-line analysis required",{"type":44,"tag":304,"props":347,"children":348},{},[349,354,359],{"type":44,"tag":331,"props":350,"children":351},{},[352],{"type":50,"value":353},"\"This function is simple\"",{"type":44,"tag":331,"props":355,"children":356},{},[357],{"type":50,"value":358},"Simple functions compose into complex bugs",{"type":44,"tag":331,"props":360,"children":361},{},[362],{"type":50,"value":363},"Apply 5 Whys anyway",{"type":44,"tag":304,"props":365,"children":366},{},[367,372,377],{"type":44,"tag":331,"props":368,"children":369},{},[370],{"type":50,"value":371},"\"I'll remember this invariant\"",{"type":44,"tag":331,"props":373,"children":374},{},[375],{"type":50,"value":376},"You won't. Context degrades.",{"type":44,"tag":331,"props":378,"children":379},{},[380],{"type":50,"value":381},"Write it down explicitly",{"type":44,"tag":304,"props":383,"children":384},{},[385,390,395],{"type":44,"tag":331,"props":386,"children":387},{},[388],{"type":50,"value":389},"\"External call is probably fine\"",{"type":44,"tag":331,"props":391,"children":392},{},[393],{"type":50,"value":394},"External = adversarial until proven otherwise",{"type":44,"tag":331,"props":396,"children":397},{},[398],{"type":50,"value":399},"Jump into code or model as hostile",{"type":44,"tag":304,"props":401,"children":402},{},[403,408,413],{"type":44,"tag":331,"props":404,"children":405},{},[406],{"type":50,"value":407},"\"I can skip this helper\"",{"type":44,"tag":331,"props":409,"children":410},{},[411],{"type":50,"value":412},"Helpers contain assumptions that propagate",{"type":44,"tag":331,"props":414,"children":415},{},[416],{"type":50,"value":417},"Trace the full call chain",{"type":44,"tag":304,"props":419,"children":420},{},[421,426,431],{"type":44,"tag":331,"props":422,"children":423},{},[424],{"type":50,"value":425},"\"This is taking too long\"",{"type":44,"tag":331,"props":427,"children":428},{},[429],{"type":50,"value":430},"Rushed context = hallucinated vulnerabilities later",{"type":44,"tag":331,"props":432,"children":433},{},[434],{"type":50,"value":435},"Slow is fast",{"type":44,"tag":149,"props":437,"children":438},{},[],{"type":44,"tag":53,"props":440,"children":442},{"id":441},"_4-phase-1-initial-orientation-bottom-up-scan",[443],{"type":50,"value":444},"4. Phase 1 — Initial Orientation (Bottom-Up Scan)",{"type":44,"tag":60,"props":446,"children":447},{},[448],{"type":50,"value":449},"Before deep analysis, Claude performs a minimal mapping:",{"type":44,"tag":451,"props":452,"children":453},"ol",{},[454,459,464,469,474],{"type":44,"tag":83,"props":455,"children":456},{},[457],{"type":50,"value":458},"Identify major modules\u002Ffiles\u002Fcontracts.",{"type":44,"tag":83,"props":460,"children":461},{},[462],{"type":50,"value":463},"Note obvious public\u002Fexternal entrypoints.",{"type":44,"tag":83,"props":465,"children":466},{},[467],{"type":50,"value":468},"Identify likely actors (users, owners, relayers, oracles, other contracts).",{"type":44,"tag":83,"props":470,"children":471},{},[472],{"type":50,"value":473},"Identify important storage variables, dicts, state structs, or cells.",{"type":44,"tag":83,"props":475,"children":476},{},[477],{"type":50,"value":478},"Build a preliminary structure without assuming behavior.",{"type":44,"tag":60,"props":480,"children":481},{},[482],{"type":50,"value":483},"This establishes anchors for detailed analysis.",{"type":44,"tag":149,"props":485,"children":486},{},[],{"type":44,"tag":53,"props":488,"children":490},{"id":489},"_5-phase-2-ultra-granular-function-analysis-default-mode",[491],{"type":50,"value":492},"5. Phase 2 — Ultra-Granular Function Analysis (Default Mode)",{"type":44,"tag":60,"props":494,"children":495},{},[496],{"type":50,"value":497},"Every non-trivial function receives full micro analysis.",{"type":44,"tag":499,"props":500,"children":502},"h3",{"id":501},"_51-per-function-microstructure-checklist",[503],{"type":50,"value":504},"5.1 Per-Function Microstructure Checklist",{"type":44,"tag":60,"props":506,"children":507},{},[508],{"type":50,"value":509},"For each function:",{"type":44,"tag":451,"props":511,"children":512},{},[513,529,550,581],{"type":44,"tag":83,"props":514,"children":515},{},[516,521],{"type":44,"tag":66,"props":517,"children":518},{},[519],{"type":50,"value":520},"Purpose",{"type":44,"tag":79,"props":522,"children":523},{},[524],{"type":44,"tag":83,"props":525,"children":526},{},[527],{"type":50,"value":528},"Why the function exists and its role in the system.",{"type":44,"tag":83,"props":530,"children":531},{},[532,537],{"type":44,"tag":66,"props":533,"children":534},{},[535],{"type":50,"value":536},"Inputs & Assumptions",{"type":44,"tag":79,"props":538,"children":539},{},[540,545],{"type":44,"tag":83,"props":541,"children":542},{},[543],{"type":50,"value":544},"Parameters and implicit inputs (state, sender, env).",{"type":44,"tag":83,"props":546,"children":547},{},[548],{"type":50,"value":549},"Preconditions and constraints.",{"type":44,"tag":83,"props":551,"children":552},{},[553,558],{"type":44,"tag":66,"props":554,"children":555},{},[556],{"type":50,"value":557},"Outputs & Effects",{"type":44,"tag":79,"props":559,"children":560},{},[561,566,571,576],{"type":44,"tag":83,"props":562,"children":563},{},[564],{"type":50,"value":565},"Return values.",{"type":44,"tag":83,"props":567,"children":568},{},[569],{"type":50,"value":570},"State\u002Fstorage writes.",{"type":44,"tag":83,"props":572,"children":573},{},[574],{"type":50,"value":575},"Events\u002Fmessages.",{"type":44,"tag":83,"props":577,"children":578},{},[579],{"type":50,"value":580},"External interactions.",{"type":44,"tag":83,"props":582,"children":583},{},[584,589,591,619,623,625],{"type":44,"tag":66,"props":585,"children":586},{},[587],{"type":50,"value":588},"Block-by-Block \u002F Line-by-Line Analysis",{"type":50,"value":590},"\nFor each logical block:",{"type":44,"tag":79,"props":592,"children":593},{},[594,599,604,609,614],{"type":44,"tag":83,"props":595,"children":596},{},[597],{"type":50,"value":598},"What it does.",{"type":44,"tag":83,"props":600,"children":601},{},[602],{"type":50,"value":603},"Why it appears here (ordering logic).",{"type":44,"tag":83,"props":605,"children":606},{},[607],{"type":50,"value":608},"What assumptions it relies on.",{"type":44,"tag":83,"props":610,"children":611},{},[612],{"type":50,"value":613},"What invariants it establishes or maintains.",{"type":44,"tag":83,"props":615,"children":616},{},[617],{"type":50,"value":618},"What later logic depends on it.",{"type":44,"tag":620,"props":621,"children":622},"br",{},[],{"type":50,"value":624},"Apply per-block:",{"type":44,"tag":79,"props":626,"children":627},{},[628,635,642],{"type":44,"tag":83,"props":629,"children":630},{},[631],{"type":44,"tag":66,"props":632,"children":633},{},[634],{"type":50,"value":104},{"type":44,"tag":83,"props":636,"children":637},{},[638],{"type":44,"tag":66,"props":639,"children":640},{},[641],{"type":50,"value":111},{"type":44,"tag":83,"props":643,"children":644},{},[645],{"type":44,"tag":66,"props":646,"children":647},{},[648],{"type":50,"value":118},{"type":44,"tag":149,"props":650,"children":651},{},[],{"type":44,"tag":499,"props":653,"children":655},{"id":654},"_52-cross-function-external-flow-analysis",[656],{"type":50,"value":657},"5.2 Cross-Function & External Flow Analysis",{"type":44,"tag":60,"props":659,"children":660},{},[661],{"type":44,"tag":662,"props":663,"children":664},"em",{},[665],{"type":50,"value":666},"(Full Integration of Jump-Into-External-Code Rule)",{"type":44,"tag":60,"props":668,"children":669},{},[670,672],{"type":50,"value":671},"When encountering calls, ",{"type":44,"tag":66,"props":673,"children":674},{},[675],{"type":50,"value":676},"continue the same micro-first analysis across boundaries.",{"type":44,"tag":678,"props":679,"children":681},"h4",{"id":680},"internal-calls",[682],{"type":50,"value":683},"Internal Calls",{"type":44,"tag":79,"props":685,"children":686},{},[687,692,697,702],{"type":44,"tag":83,"props":688,"children":689},{},[690],{"type":50,"value":691},"Jump into the callee immediately.",{"type":44,"tag":83,"props":693,"children":694},{},[695],{"type":50,"value":696},"Perform block-by-block analysis of relevant code.",{"type":44,"tag":83,"props":698,"children":699},{},[700],{"type":50,"value":701},"Track flow of data, assumptions, and invariants:\ncaller → callee → return → caller.",{"type":44,"tag":83,"props":703,"children":704},{},[705],{"type":50,"value":706},"Note if callee logic behaves differently in this specific call context.",{"type":44,"tag":678,"props":708,"children":710},{"id":709},"external-calls-two-cases",[711],{"type":50,"value":712},"External Calls — Two Cases",{"type":44,"tag":60,"props":714,"children":715},{},[716,721],{"type":44,"tag":66,"props":717,"children":718},{},[719],{"type":50,"value":720},"Case A — External Call to a Contract Whose Code Exists in the Codebase",{"type":50,"value":722},"\nTreat as an internal call:",{"type":44,"tag":79,"props":724,"children":725},{},[726,731,736,741],{"type":44,"tag":83,"props":727,"children":728},{},[729],{"type":50,"value":730},"Jump into the target contract\u002Ffunction.",{"type":44,"tag":83,"props":732,"children":733},{},[734],{"type":50,"value":735},"Continue block-by-block micro-analysis.",{"type":44,"tag":83,"props":737,"children":738},{},[739],{"type":50,"value":740},"Propagate invariants and assumptions seamlessly.",{"type":44,"tag":83,"props":742,"children":743},{},[744,746,751],{"type":50,"value":745},"Consider edge cases based on the ",{"type":44,"tag":662,"props":747,"children":748},{},[749],{"type":50,"value":750},"actual",{"type":50,"value":752}," code, not a black-box guess.",{"type":44,"tag":60,"props":754,"children":755},{},[756,761],{"type":44,"tag":66,"props":757,"children":758},{},[759],{"type":50,"value":760},"Case B — External Call Without Available Code (True External \u002F Black Box)",{"type":50,"value":762},"\nAnalyze as adversarial:",{"type":44,"tag":79,"props":764,"children":765},{},[766,771,776],{"type":44,"tag":83,"props":767,"children":768},{},[769],{"type":50,"value":770},"Describe payload\u002Fvalue\u002Fgas or parameters sent.",{"type":44,"tag":83,"props":772,"children":773},{},[774],{"type":50,"value":775},"Identify assumptions about the target.",{"type":44,"tag":83,"props":777,"children":778},{},[779,781],{"type":50,"value":780},"Consider all outcomes:\n",{"type":44,"tag":79,"props":782,"children":783},{},[784,789,794,799,804],{"type":44,"tag":83,"props":785,"children":786},{},[787],{"type":50,"value":788},"revert",{"type":44,"tag":83,"props":790,"children":791},{},[792],{"type":50,"value":793},"incorrect\u002Fstrange return values",{"type":44,"tag":83,"props":795,"children":796},{},[797],{"type":50,"value":798},"unexpected state changes",{"type":44,"tag":83,"props":800,"children":801},{},[802],{"type":50,"value":803},"misbehavior",{"type":44,"tag":83,"props":805,"children":806},{},[807],{"type":50,"value":808},"reentrancy (if applicable)",{"type":44,"tag":678,"props":810,"children":812},{"id":811},"continuity-rule",[813],{"type":50,"value":814},"Continuity Rule",{"type":44,"tag":60,"props":816,"children":817},{},[818,820,825],{"type":50,"value":819},"Treat the entire call chain as ",{"type":44,"tag":66,"props":821,"children":822},{},[823],{"type":50,"value":824},"one continuous execution flow",{"type":50,"value":826},".\nNever reset context.\nAll invariants, assumptions, and data dependencies must propagate across calls.",{"type":44,"tag":149,"props":828,"children":829},{},[],{"type":44,"tag":499,"props":831,"children":833},{"id":832},"_53-complete-analysis-example",[834],{"type":50,"value":835},"5.3 Complete Analysis Example",{"type":44,"tag":60,"props":837,"children":838},{},[839,841,848],{"type":50,"value":840},"See ",{"type":44,"tag":842,"props":843,"children":845},"a",{"href":844},"resources\u002FFUNCTION_MICRO_ANALYSIS_EXAMPLE.md",[846],{"type":50,"value":847},"FUNCTION_MICRO_ANALYSIS_EXAMPLE.md",{"type":50,"value":849}," for a complete walkthrough demonstrating:",{"type":44,"tag":79,"props":851,"children":852},{},[853,858,863,868,873],{"type":44,"tag":83,"props":854,"children":855},{},[856],{"type":50,"value":857},"Full micro-analysis of a DEX swap function",{"type":44,"tag":83,"props":859,"children":860},{},[861],{"type":50,"value":862},"Application of First Principles, 5 Whys, and 5 Hows",{"type":44,"tag":83,"props":864,"children":865},{},[866],{"type":50,"value":867},"Block-by-block analysis with invariants and assumptions",{"type":44,"tag":83,"props":869,"children":870},{},[871],{"type":50,"value":872},"Cross-function dependency mapping",{"type":44,"tag":83,"props":874,"children":875},{},[876],{"type":50,"value":877},"Risk analysis for external interactions",{"type":44,"tag":60,"props":879,"children":880},{},[881],{"type":50,"value":882},"This example demonstrates the level of depth and structure required for all analyzed functions.",{"type":44,"tag":149,"props":884,"children":885},{},[],{"type":44,"tag":499,"props":887,"children":889},{"id":888},"_54-output-requirements",[890],{"type":50,"value":891},"5.4 Output Requirements",{"type":44,"tag":60,"props":893,"children":894},{},[895,897,903],{"type":50,"value":896},"When performing ultra-granular analysis, Claude MUST structure output following the format defined in ",{"type":44,"tag":842,"props":898,"children":900},{"href":899},"resources\u002FOUTPUT_REQUIREMENTS.md",[901],{"type":50,"value":902},"OUTPUT_REQUIREMENTS.md",{"type":50,"value":904},".",{"type":44,"tag":60,"props":906,"children":907},{},[908],{"type":50,"value":909},"Key requirements:",{"type":44,"tag":79,"props":911,"children":912},{},[913,922,931,940,950],{"type":44,"tag":83,"props":914,"children":915},{},[916,920],{"type":44,"tag":66,"props":917,"children":918},{},[919],{"type":50,"value":520},{"type":50,"value":921}," (2-3 sentences minimum)",{"type":44,"tag":83,"props":923,"children":924},{},[925,929],{"type":44,"tag":66,"props":926,"children":927},{},[928],{"type":50,"value":536},{"type":50,"value":930}," (all parameters, preconditions, trust assumptions)",{"type":44,"tag":83,"props":932,"children":933},{},[934,938],{"type":44,"tag":66,"props":935,"children":936},{},[937],{"type":50,"value":557},{"type":50,"value":939}," (returns, state writes, external calls, events, postconditions)",{"type":44,"tag":83,"props":941,"children":942},{},[943,948],{"type":44,"tag":66,"props":944,"children":945},{},[946],{"type":50,"value":947},"Block-by-Block Analysis",{"type":50,"value":949}," (What, Why here, Assumptions, First Principles\u002F5 Whys\u002F5 Hows)",{"type":44,"tag":83,"props":951,"children":952},{},[953,958],{"type":44,"tag":66,"props":954,"children":955},{},[956],{"type":50,"value":957},"Cross-Function Dependencies",{"type":50,"value":959}," (internal calls, external calls with risk analysis, shared state)",{"type":44,"tag":60,"props":961,"children":962},{},[963],{"type":50,"value":964},"Quality thresholds:",{"type":44,"tag":79,"props":966,"children":967},{},[968,973,978,983,988],{"type":44,"tag":83,"props":969,"children":970},{},[971],{"type":50,"value":972},"Minimum 3 invariants per function",{"type":44,"tag":83,"props":974,"children":975},{},[976],{"type":50,"value":977},"Minimum 5 assumptions documented",{"type":44,"tag":83,"props":979,"children":980},{},[981],{"type":50,"value":982},"Minimum 3 risk considerations for external interactions",{"type":44,"tag":83,"props":984,"children":985},{},[986],{"type":50,"value":987},"At least 1 First Principles application",{"type":44,"tag":83,"props":989,"children":990},{},[991],{"type":50,"value":992},"At least 3 combined 5 Whys\u002F5 Hows applications",{"type":44,"tag":149,"props":994,"children":995},{},[],{"type":44,"tag":499,"props":997,"children":999},{"id":998},"_55-completeness-checklist",[1000],{"type":50,"value":1001},"5.5 Completeness Checklist",{"type":44,"tag":60,"props":1003,"children":1004},{},[1005,1007,1013],{"type":50,"value":1006},"Before concluding micro-analysis of a function, verify against the ",{"type":44,"tag":842,"props":1008,"children":1010},{"href":1009},"resources\u002FCOMPLETENESS_CHECKLIST.md",[1011],{"type":50,"value":1012},"COMPLETENESS_CHECKLIST.md",{"type":50,"value":1014},":",{"type":44,"tag":79,"props":1016,"children":1017},{},[1018,1028,1038,1048],{"type":44,"tag":83,"props":1019,"children":1020},{},[1021,1026],{"type":44,"tag":66,"props":1022,"children":1023},{},[1024],{"type":50,"value":1025},"Structural Completeness",{"type":50,"value":1027},": All required sections present (Purpose, Inputs, Outputs, Block-by-Block, Dependencies)",{"type":44,"tag":83,"props":1029,"children":1030},{},[1031,1036],{"type":44,"tag":66,"props":1032,"children":1033},{},[1034],{"type":50,"value":1035},"Content Depth",{"type":50,"value":1037},": Minimum thresholds met (invariants, assumptions, risk analysis, First Principles)",{"type":44,"tag":83,"props":1039,"children":1040},{},[1041,1046],{"type":44,"tag":66,"props":1042,"children":1043},{},[1044],{"type":50,"value":1045},"Continuity & Integration",{"type":50,"value":1047},": Cross-references, propagated assumptions, invariant couplings",{"type":44,"tag":83,"props":1049,"children":1050},{},[1051,1056],{"type":44,"tag":66,"props":1052,"children":1053},{},[1054],{"type":50,"value":1055},"Anti-Hallucination",{"type":50,"value":1057},": Line number citations, no vague statements, evidence-based claims",{"type":44,"tag":60,"props":1059,"children":1060},{},[1061],{"type":50,"value":1062},"Analysis is complete when all checklist items are satisfied and no unresolved \"unclear\" items remain.",{"type":44,"tag":149,"props":1064,"children":1065},{},[],{"type":44,"tag":53,"props":1067,"children":1069},{"id":1068},"_6-phase-3-global-system-understanding",[1070],{"type":50,"value":1071},"6. Phase 3 — Global System Understanding",{"type":44,"tag":60,"props":1073,"children":1074},{},[1075],{"type":50,"value":1076},"After sufficient micro-analysis:",{"type":44,"tag":451,"props":1078,"children":1079},{},[1080,1101,1127,1153],{"type":44,"tag":83,"props":1081,"children":1082},{},[1083,1088],{"type":44,"tag":66,"props":1084,"children":1085},{},[1086],{"type":50,"value":1087},"State & Invariant Reconstruction",{"type":44,"tag":79,"props":1089,"children":1090},{},[1091,1096],{"type":44,"tag":83,"props":1092,"children":1093},{},[1094],{"type":50,"value":1095},"Map reads\u002Fwrites of each state variable.",{"type":44,"tag":83,"props":1097,"children":1098},{},[1099],{"type":50,"value":1100},"Derive multi-function and multi-module invariants.",{"type":44,"tag":83,"props":1102,"children":1103},{},[1104,1109],{"type":44,"tag":66,"props":1105,"children":1106},{},[1107],{"type":50,"value":1108},"Workflow Reconstruction",{"type":44,"tag":79,"props":1110,"children":1111},{},[1112,1117,1122],{"type":44,"tag":83,"props":1113,"children":1114},{},[1115],{"type":50,"value":1116},"Identify end-to-end flows (deposit, withdraw, lifecycle, upgrades).",{"type":44,"tag":83,"props":1118,"children":1119},{},[1120],{"type":50,"value":1121},"Track how state transforms across these flows.",{"type":44,"tag":83,"props":1123,"children":1124},{},[1125],{"type":50,"value":1126},"Record assumptions that persist across steps.",{"type":44,"tag":83,"props":1128,"children":1129},{},[1130,1135],{"type":44,"tag":66,"props":1131,"children":1132},{},[1133],{"type":50,"value":1134},"Trust Boundary Mapping",{"type":44,"tag":79,"props":1136,"children":1137},{},[1138,1143,1148],{"type":44,"tag":83,"props":1139,"children":1140},{},[1141],{"type":50,"value":1142},"Actor → entrypoint → behavior.",{"type":44,"tag":83,"props":1144,"children":1145},{},[1146],{"type":50,"value":1147},"Identify untrusted input paths.",{"type":44,"tag":83,"props":1149,"children":1150},{},[1151],{"type":50,"value":1152},"Privilege changes and implicit role expectations.",{"type":44,"tag":83,"props":1154,"children":1155},{},[1156,1161],{"type":44,"tag":66,"props":1157,"children":1158},{},[1159],{"type":50,"value":1160},"Complexity & Fragility Clustering",{"type":44,"tag":79,"props":1162,"children":1163},{},[1164,1169,1174,1179],{"type":44,"tag":83,"props":1165,"children":1166},{},[1167],{"type":50,"value":1168},"Functions with many assumptions.",{"type":44,"tag":83,"props":1170,"children":1171},{},[1172],{"type":50,"value":1173},"High branching logic.",{"type":44,"tag":83,"props":1175,"children":1176},{},[1177],{"type":50,"value":1178},"Multi-step dependencies.",{"type":44,"tag":83,"props":1180,"children":1181},{},[1182],{"type":50,"value":1183},"Coupled state changes across modules.",{"type":44,"tag":60,"props":1185,"children":1186},{},[1187],{"type":50,"value":1188},"These clusters help guide the vulnerability-hunting phase.",{"type":44,"tag":149,"props":1190,"children":1191},{},[],{"type":44,"tag":53,"props":1193,"children":1195},{"id":1194},"_7-stability-consistency-rules",[1196],{"type":50,"value":1197},"7. Stability & Consistency Rules",{"type":44,"tag":60,"props":1199,"children":1200},{},[1201],{"type":44,"tag":662,"props":1202,"children":1203},{},[1204],{"type":50,"value":1205},"(Anti-Hallucination, Anti-Contradiction)",{"type":44,"tag":60,"props":1207,"children":1208},{},[1209],{"type":50,"value":1210},"Claude must:",{"type":44,"tag":79,"props":1212,"children":1213},{},[1214,1237,1270,1293],{"type":44,"tag":83,"props":1215,"children":1216},{},[1217,1222,1224],{"type":44,"tag":66,"props":1218,"children":1219},{},[1220],{"type":50,"value":1221},"Never reshape evidence to fit earlier assumptions.",{"type":50,"value":1223},"\nWhen contradicted:",{"type":44,"tag":79,"props":1225,"children":1226},{},[1227,1232],{"type":44,"tag":83,"props":1228,"children":1229},{},[1230],{"type":50,"value":1231},"Update the model.",{"type":44,"tag":83,"props":1233,"children":1234},{},[1235],{"type":50,"value":1236},"State the correction explicitly.",{"type":44,"tag":83,"props":1238,"children":1239},{},[1240,1245,1247],{"type":44,"tag":66,"props":1241,"children":1242},{},[1243],{"type":50,"value":1244},"Periodically anchor key facts",{"type":50,"value":1246},"\nSummarize core:",{"type":44,"tag":79,"props":1248,"children":1249},{},[1250,1255,1260,1265],{"type":44,"tag":83,"props":1251,"children":1252},{},[1253],{"type":50,"value":1254},"invariants",{"type":44,"tag":83,"props":1256,"children":1257},{},[1258],{"type":50,"value":1259},"state relationships",{"type":44,"tag":83,"props":1261,"children":1262},{},[1263],{"type":50,"value":1264},"actor roles",{"type":44,"tag":83,"props":1266,"children":1267},{},[1268],{"type":50,"value":1269},"workflows",{"type":44,"tag":83,"props":1271,"children":1272},{},[1273,1278,1280],{"type":44,"tag":66,"props":1274,"children":1275},{},[1276],{"type":50,"value":1277},"Avoid vague guesses",{"type":50,"value":1279},"\nUse:",{"type":44,"tag":79,"props":1281,"children":1282},{},[1283,1288],{"type":44,"tag":83,"props":1284,"children":1285},{},[1286],{"type":50,"value":1287},"\"Unclear; need to inspect X.\"\ninstead of:",{"type":44,"tag":83,"props":1289,"children":1290},{},[1291],{"type":50,"value":1292},"\"It probably…\"",{"type":44,"tag":83,"props":1294,"children":1295},{},[1296,1301],{"type":44,"tag":66,"props":1297,"children":1298},{},[1299],{"type":50,"value":1300},"Cross-reference constantly",{"type":50,"value":1302},"\nConnect new insights to previous state, flows, and invariants to maintain global coherence.",{"type":44,"tag":149,"props":1304,"children":1305},{},[],{"type":44,"tag":53,"props":1307,"children":1309},{"id":1308},"_8-subagent-usage",[1310],{"type":50,"value":1311},"8. Subagent Usage",{"type":44,"tag":60,"props":1313,"children":1314},{},[1315],{"type":50,"value":1316},"Claude may spawn subagents for:",{"type":44,"tag":79,"props":1318,"children":1319},{},[1320,1325,1330,1335,1340],{"type":44,"tag":83,"props":1321,"children":1322},{},[1323],{"type":50,"value":1324},"Dense or complex functions.",{"type":44,"tag":83,"props":1326,"children":1327},{},[1328],{"type":50,"value":1329},"Long data-flow or control-flow chains.",{"type":44,"tag":83,"props":1331,"children":1332},{},[1333],{"type":50,"value":1334},"Cryptographic \u002F mathematical logic.",{"type":44,"tag":83,"props":1336,"children":1337},{},[1338],{"type":50,"value":1339},"Complex state machines.",{"type":44,"tag":83,"props":1341,"children":1342},{},[1343],{"type":50,"value":1344},"Multi-module workflow reconstruction.",{"type":44,"tag":60,"props":1346,"children":1347},{},[1348,1350,1360],{"type":50,"value":1349},"Use the ",{"type":44,"tag":66,"props":1351,"children":1352},{},[1353],{"type":44,"tag":1354,"props":1355,"children":1357},"code",{"className":1356},[],[1358],{"type":50,"value":1359},"function-analyzer",{"type":50,"value":1361}," agent for per-function deep analysis.\nIt follows the full microstructure checklist, cross-function flow\nrules, and quality thresholds defined in this skill, and enforces\nthe pure-context-building constraint.",{"type":44,"tag":60,"props":1363,"children":1364},{},[1365],{"type":50,"value":1366},"Subagents must:",{"type":44,"tag":79,"props":1368,"children":1369},{},[1370,1375],{"type":44,"tag":83,"props":1371,"children":1372},{},[1373],{"type":50,"value":1374},"Follow the same micro-first rules.",{"type":44,"tag":83,"props":1376,"children":1377},{},[1378],{"type":50,"value":1379},"Return summaries that Claude integrates into its global model.",{"type":44,"tag":149,"props":1381,"children":1382},{},[],{"type":44,"tag":53,"props":1384,"children":1386},{"id":1385},"_9-relationship-to-other-phases",[1387],{"type":50,"value":1388},"9. Relationship to Other Phases",{"type":44,"tag":60,"props":1390,"children":1391},{},[1392,1394,1398],{"type":50,"value":1393},"This skill runs ",{"type":44,"tag":66,"props":1395,"children":1396},{},[1397],{"type":50,"value":145},{"type":50,"value":1014},{"type":44,"tag":79,"props":1400,"children":1401},{},[1402,1407,1412,1417,1422],{"type":44,"tag":83,"props":1403,"children":1404},{},[1405],{"type":50,"value":1406},"Vulnerability discovery",{"type":44,"tag":83,"props":1408,"children":1409},{},[1410],{"type":50,"value":1411},"Classification \u002F triage",{"type":44,"tag":83,"props":1413,"children":1414},{},[1415],{"type":50,"value":1416},"Report writing",{"type":44,"tag":83,"props":1418,"children":1419},{},[1420],{"type":50,"value":1421},"Impact modeling",{"type":44,"tag":83,"props":1423,"children":1424},{},[1425],{"type":50,"value":215},{"type":44,"tag":60,"props":1427,"children":1428},{},[1429],{"type":50,"value":1430},"It exists solely to build:",{"type":44,"tag":79,"props":1432,"children":1433},{},[1434,1439,1444],{"type":44,"tag":83,"props":1435,"children":1436},{},[1437],{"type":50,"value":1438},"Deep understanding",{"type":44,"tag":83,"props":1440,"children":1441},{},[1442],{"type":50,"value":1443},"Stable context",{"type":44,"tag":83,"props":1445,"children":1446},{},[1447],{"type":50,"value":1448},"System-level clarity",{"type":44,"tag":149,"props":1450,"children":1451},{},[],{"type":44,"tag":53,"props":1453,"children":1455},{"id":1454},"_10-non-goals",[1456],{"type":50,"value":1457},"10. Non-Goals",{"type":44,"tag":60,"props":1459,"children":1460},{},[1461],{"type":50,"value":1462},"While active, Claude should NOT:",{"type":44,"tag":79,"props":1464,"children":1465},{},[1466,1471,1476,1481,1486],{"type":44,"tag":83,"props":1467,"children":1468},{},[1469],{"type":50,"value":1470},"Identify vulnerabilities",{"type":44,"tag":83,"props":1472,"children":1473},{},[1474],{"type":50,"value":1475},"Propose fixes",{"type":44,"tag":83,"props":1477,"children":1478},{},[1479],{"type":50,"value":1480},"Generate proofs-of-concept",{"type":44,"tag":83,"props":1482,"children":1483},{},[1484],{"type":50,"value":1485},"Model exploits",{"type":44,"tag":83,"props":1487,"children":1488},{},[1489],{"type":50,"value":1490},"Assign severity or impact",{"type":44,"tag":60,"props":1492,"children":1493},{},[1494,1496,1501],{"type":50,"value":1495},"This is ",{"type":44,"tag":66,"props":1497,"children":1498},{},[1499],{"type":50,"value":1500},"pure context building",{"type":50,"value":1502}," only.",{"items":1504,"total":1650},[1505,1524,1534,1552,1565,1576,1588,1598,1605,1616,1628,1639],{"slug":1506,"name":1506,"fn":1507,"description":1508,"org":1509,"tags":1510,"stars":26,"repoUrl":27,"updatedAt":1523},"address-sanitizer","detect memory errors during fuzzing","AddressSanitizer detects memory errors during fuzzing. Use when fuzzing C\u002FC++ code to find buffer overflows and use-after-free bugs.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1511,1514,1517,1520],{"name":1512,"slug":1513,"type":16},"C#","c",{"name":1515,"slug":1516,"type":16},"Debugging","debugging",{"name":1518,"slug":1519,"type":16},"Security","security",{"name":1521,"slug":1522,"type":16},"Testing","testing","2026-07-17T06:05:14.925095",{"slug":1525,"name":1525,"fn":1526,"description":1527,"org":1528,"tags":1529,"stars":26,"repoUrl":27,"updatedAt":1533},"aflpp","perform multi-core fuzzing of C\u002FC++ projects","AFL++ is a fork of AFL with better fuzzing performance and advanced features. Use for multi-core fuzzing of C\u002FC++ projects.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1530,1531,1532],{"name":1512,"slug":1513,"type":16},{"name":1518,"slug":1519,"type":16},{"name":1521,"slug":1522,"type":16},"2026-07-17T06:05:12.433192",{"slug":1535,"name":1535,"fn":1536,"description":1537,"org":1538,"tags":1539,"stars":26,"repoUrl":27,"updatedAt":1551},"agentic-actions-auditor","audit GitHub Actions for security vulnerabilities","Audits GitHub Actions workflows for security vulnerabilities in AI agent integrations including Claude Code Action, Gemini CLI, OpenAI Codex, and GitHub AI Inference. Detects attack vectors where attacker-controlled input reaches AI agents running in CI\u002FCD pipelines, including env var intermediary patterns, direct expression injection, dangerous sandbox configurations, and wildcard user allowlists. Use when reviewing workflow files that invoke AI coding agents, auditing CI\u002FCD pipeline security for prompt injection risks, or evaluating agentic action configurations.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1540,1543,1546,1547,1550],{"name":1541,"slug":1542,"type":16},"Agents","agents",{"name":1544,"slug":1545,"type":16},"CI\u002FCD","ci-cd",{"name":24,"slug":25,"type":16},{"name":1548,"slug":1549,"type":16},"GitHub Actions","github-actions",{"name":1518,"slug":1519,"type":16},"2026-07-18T05:47:48.564744",{"slug":1553,"name":1553,"fn":1554,"description":1555,"org":1556,"tags":1557,"stars":26,"repoUrl":27,"updatedAt":1564},"algorand-vulnerability-scanner","scan Algorand smart contracts for vulnerabilities","Scans Algorand smart contracts for 11 common vulnerabilities including rekeying attacks, unchecked transaction fees, missing field validations, and access control issues. Use when auditing Algorand projects (TEAL\u002FPyTeal).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1558,1559,1560,1561],{"name":18,"slug":19,"type":16},{"name":24,"slug":25,"type":16},{"name":1518,"slug":1519,"type":16},{"name":1562,"slug":1563,"type":16},"Smart Contracts","smart-contracts","2026-07-18T05:47:43.989063",{"slug":1566,"name":1566,"fn":1567,"description":1568,"org":1569,"tags":1570,"stars":26,"repoUrl":27,"updatedAt":1575},"ask-questions-if-underspecified","clarify requirements before implementation","Clarify requirements before implementing. Use when serious doubts arise.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1571,1572],{"name":21,"slug":22,"type":16},{"name":1573,"slug":1574,"type":16},"Productivity","productivity","2026-07-17T06:05:33.543262",{"slug":1577,"name":1577,"fn":1578,"description":1579,"org":1580,"tags":1581,"stars":26,"repoUrl":27,"updatedAt":1587},"atheris","fuzz Python code with Atheris","Atheris is a coverage-guided Python fuzzer based on libFuzzer. Use for fuzzing pure Python code and Python C extensions.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1582,1585,1586],{"name":1583,"slug":1584,"type":16},"Python","python",{"name":1518,"slug":1519,"type":16},{"name":1521,"slug":1522,"type":16},"2026-07-17T06:05:14.575191",{"slug":1589,"name":1589,"fn":1590,"description":1591,"org":1592,"tags":1593,"stars":26,"repoUrl":27,"updatedAt":1597},"audit-augmentation","augment code graphs with audit findings","Augments Trailmark code graphs with external audit findings from SARIF static analysis results, weAudit annotation files, and version-gated Trailmark 0.4.x binary-analysis graph exports. Maps findings to graph nodes by file and line overlap, creates severity-based subgraphs, and enables cross-referencing findings with pre-analysis data (blast radius, taint, etc.). Use when projecting SARIF results onto a code graph, overlaying weAudit annotations, importing binary graph findings, cross-referencing Semgrep, CodeQL, or binary-analysis findings with call graph data, or visualizing audit findings in the context of code structure.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1594,1595,1596],{"name":18,"slug":19,"type":16},{"name":24,"slug":25,"type":16},{"name":1518,"slug":1519,"type":16},"2026-08-01T05:44:54.920542",{"slug":4,"name":4,"fn":5,"description":6,"org":1599,"tags":1600,"stars":26,"repoUrl":27,"updatedAt":28},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1601,1602,1603,1604],{"name":14,"slug":15,"type":16},{"name":18,"slug":19,"type":16},{"name":24,"slug":25,"type":16},{"name":21,"slug":22,"type":16},{"slug":1606,"name":1606,"fn":1607,"description":1608,"org":1609,"tags":1610,"stars":26,"repoUrl":27,"updatedAt":1615},"audit-prep-assistant","prepare codebases for security audits","Prepares codebases for security review using Trail of Bits' checklist. Helps set review goals, runs static analysis tools, increases test coverage, removes dead code, ensures accessibility, and generates documentation (flowcharts, user stories, inline comments).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1611,1612,1613,1614],{"name":18,"slug":19,"type":16},{"name":24,"slug":25,"type":16},{"name":21,"slug":22,"type":16},{"name":1518,"slug":1519,"type":16},"2026-07-18T05:47:39.210985",{"slug":1617,"name":1617,"fn":1618,"description":1619,"org":1620,"tags":1621,"stars":26,"repoUrl":27,"updatedAt":1627},"burpsuite-project-parser","parse Burp Suite project files","Searches and explores Burp Suite project files (.burp) from the command line. Use when searching response headers or bodies with regex patterns, extracting security audit findings, dumping proxy history or site map data, or analyzing HTTP traffic captured in a Burp project.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1622,1623,1626],{"name":18,"slug":19,"type":16},{"name":1624,"slug":1625,"type":16},"CLI","cli",{"name":1518,"slug":1519,"type":16},"2026-07-17T06:05:33.198077",{"slug":1629,"name":1629,"fn":1630,"description":1631,"org":1632,"tags":1633,"stars":26,"repoUrl":27,"updatedAt":1638},"c-review","audit C and C++ code","Performs comprehensive C\u002FC++ security review for memory corruption, integer overflows, race conditions, and platform-specific vulnerabilities. Use when auditing native C\u002FC++ applications, reviewing daemons or services for memory safety, or hunting integer overflow \u002F use-after-free \u002F race conditions in userspace code.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1634,1635,1636,1637],{"name":18,"slug":19,"type":16},{"name":1512,"slug":1513,"type":16},{"name":24,"slug":25,"type":16},{"name":1518,"slug":1519,"type":16},"2026-07-17T06:05:11.333374",{"slug":1640,"name":1640,"fn":1641,"description":1642,"org":1643,"tags":1644,"stars":26,"repoUrl":27,"updatedAt":1649},"cairo-vulnerability-scanner","scan Cairo and StarkNet contracts for vulnerabilities","Scans Cairo\u002FStarkNet smart contracts for 6 critical vulnerabilities including felt252 arithmetic overflow, L1-L2 messaging issues, address conversion problems, and signature replay. Use when auditing StarkNet projects.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1645,1646,1647,1648],{"name":18,"slug":19,"type":16},{"name":24,"slug":25,"type":16},{"name":1518,"slug":1519,"type":16},{"name":1562,"slug":1563,"type":16},"2026-07-18T05:47:42.84568",111,{"items":1652,"total":1698},[1653,1660,1666,1674,1681,1686,1692],{"slug":1506,"name":1506,"fn":1507,"description":1508,"org":1654,"tags":1655,"stars":26,"repoUrl":27,"updatedAt":1523},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1656,1657,1658,1659],{"name":1512,"slug":1513,"type":16},{"name":1515,"slug":1516,"type":16},{"name":1518,"slug":1519,"type":16},{"name":1521,"slug":1522,"type":16},{"slug":1525,"name":1525,"fn":1526,"description":1527,"org":1661,"tags":1662,"stars":26,"repoUrl":27,"updatedAt":1533},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1663,1664,1665],{"name":1512,"slug":1513,"type":16},{"name":1518,"slug":1519,"type":16},{"name":1521,"slug":1522,"type":16},{"slug":1535,"name":1535,"fn":1536,"description":1537,"org":1667,"tags":1668,"stars":26,"repoUrl":27,"updatedAt":1551},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1669,1670,1671,1672,1673],{"name":1541,"slug":1542,"type":16},{"name":1544,"slug":1545,"type":16},{"name":24,"slug":25,"type":16},{"name":1548,"slug":1549,"type":16},{"name":1518,"slug":1519,"type":16},{"slug":1553,"name":1553,"fn":1554,"description":1555,"org":1675,"tags":1676,"stars":26,"repoUrl":27,"updatedAt":1564},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1677,1678,1679,1680],{"name":18,"slug":19,"type":16},{"name":24,"slug":25,"type":16},{"name":1518,"slug":1519,"type":16},{"name":1562,"slug":1563,"type":16},{"slug":1566,"name":1566,"fn":1567,"description":1568,"org":1682,"tags":1683,"stars":26,"repoUrl":27,"updatedAt":1575},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1684,1685],{"name":21,"slug":22,"type":16},{"name":1573,"slug":1574,"type":16},{"slug":1577,"name":1577,"fn":1578,"description":1579,"org":1687,"tags":1688,"stars":26,"repoUrl":27,"updatedAt":1587},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1689,1690,1691],{"name":1583,"slug":1584,"type":16},{"name":1518,"slug":1519,"type":16},{"name":1521,"slug":1522,"type":16},{"slug":1589,"name":1589,"fn":1590,"description":1591,"org":1693,"tags":1694,"stars":26,"repoUrl":27,"updatedAt":1597},{"slug":8,"name":9,"logoUrl":10,"githubOrg":11},[1695,1696,1697],{"name":18,"slug":19,"type":16},{"name":24,"slug":25,"type":16},{"name":1518,"slug":1519,"type":16},77]