Results for “architecture-analysis”

Analyzes codebase structure and generates token-lean architecture documentation in codemap files, with diff detection and metadata tracking.

Analyzes codebases to generate comprehensive architectural documentation, including technology stack detection, visual diagrams, and implementation patterns.

Creates and manages Architecture Decision Records using the Michael Nygard format, including new ADR creation, retrospective analysis, superseding, deprecating, and index generation.

Analyzes codebases to generate detailed technology stack blueprints with version information, licensing, usage patterns, coding conventions, and architecture diagrams.

Maps a codebase into feature-grouped flowcharts, identifies duplicated concerns across features, and proposes a unified architecture with handoff prompts for refactoring.

Analyze an unfamiliar codebase and generate a structured onboarding guide with architecture map, key entry points, conventions, and a starter CLAUDE.md.

Generates detailed, technology-agnostic implementation blueprints by analyzing project architecture, technology stacks, and data flow patterns.

Performs deep architectural analysis of a specified module, directory, or feature area by examining structural coupling, data flow, concurrency patterns, risk, and SOLID alignment. Use when the user wants to assess, evaluate, or review the architecture, design quality, dependency structure, coupling, cohesion, or technical debt of an existing part of the codebase. Not for investigating specific bugs, runtime errors, or failures — use investigate. Not for test planning — use automated-test-planning. Not for file-level code review — use code-review. Not for researching open-ended options, prior art, or how something works — use research. Not for designing a new interface or contract — use design-an-api. Not for writing documentation or architectural decision records.

Analyzes code repositories and generates hierarchical documentation structures with onboarding guides.

Structures an Architecture Decision Record (ADR) to capture context, decision, and consequences of significant architectural choices, ensuring decisions are documented with sufficient detail for future teams.

Extracts specifications from existing codebases by analyzing structure, data flows, and observable behaviors to document requirements in EARS format.

Generates Mermaid architecture diagrams from a codebase, including C4 context and container diagrams, sequence diagrams for key flows, ER diagrams from database schemas, and module dependency graphs.

Generates hand-drawn-style Excalidraw architecture diagrams from a codebase, including C4 context and container views, sequence diagrams for key flows, ER diagrams from database schemas, and module dependency graphs.

Generates a comprehensive developer onboarding guide from a codebase, covering tech stack, setup, architecture, conventions, and troubleshooting.

Analyze a codebase and generate onboarding documentation for engineers, tech leads, and contractors, with fast fact-gathering and repeatable outputs.

Analyzes code directories to create comprehensive C4 code-level documentation including function signatures, arguments, dependencies, and code structure.

Conducts multi-turn iterative deep research on specific topics within a codebase, tracing actual code paths and grounding every claim in evidence.

Generate comprehensive technical documentation for developers taking over an AEM Edge Delivery Services project, covering architecture, design system, blocks, and configuration.

Researches an open-ended question — options, possible solutions, prior art, trade-offs, or how something works — and produces a durable, evidence-backed, adversarially-validated report that recommends an option without committing the team to any artifact. Use when you want to research approaches, weigh options, survey prior art or the state of the art, or understand how something works before committing to a direction. Does not diagnose a bug, failure, or root cause — use investigate. Does not specify a feature — use plan-a-feature. Does not create or update a coding standard — use coding-standard. Does not compare two concrete artifacts for gaps — use gap-analysis. Does not assess an existing module's architecture — use architectural-analysis. Does not capture feedback on Han's own skills — use han-feedback.

Restructure existing code without changing its behavior, through a test-gated refactoring loop: a named target, a green suite over that target before any edit, a planned sequence of small named refactorings, and the full suite re-run after every step. Use when the user wants to refactor, restructure, clean up, simplify, or improve the design of existing code, or to apply refactoring recommendations from a code-review or architectural-analysis report. This skill changes code; it does not review code (use code-review), assess architecture (use architectural-analysis), or build new behavior test-first (use tdd). Do not use it on code inside an active tdd loop; the refactor step of tdd owns that cleanup. Runs its planned sequence to completion without pausing for review; to review each named refactoring as it lands, use pairing.

Produces a human-readable, progressive-disclosure overview of unfamiliar code or a pull request's changes — why it exists (the real problem it solves or goal it serves for the business or a user), and from there what it does, how it flows, and where to start — so you can get up to speed before working on or reviewing it. Use when you want to understand, get oriented in, make sense of, explain, or get up to speed on a chunk of code, a file, a directory, a symbol, or a PR's changes. Writes the overview to a scratch file and changes no code. Does not review code quality or raise findings — use code-review for auditing changes or post-code-review-to-pr for posting them. Does not produce durable feature or system documentation — use project-documentation. Does not assess architecture or structural risk — use architectural-analysis. Does not diagnose bugs or root-cause failures — use investigate. Does not pace a person through the code one step at a time in conversation — use code-walkthrough.