Claude Skill

architecture-review

Evidence-based architecture review of a whole project, a subsystem, or a change (uncommitted changes, commit, branch, or pull request). Reconstructs the real structure of a codebase from code, then evaluates layering, dependency direction, module boundaries, balanced coupling (in

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Download v0lka-skills-development_architecture-review-ce9c4a1.zip · 25 KB

Install

skills CLI npx skills add https://github.com/v0lka/skills/tree/main/development/architecture-review
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install v0lka-skills@llmmart
Git git clone https://github.com/v0lka/skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole v0lka/skills collection as a plugin from our marketplace. Git is the plain clone.

README

Architecture Review

A standalone Agent Skill for evidence-based architecture reviews. It reconstructs the real architecture of a codebase from code and evaluates it for structural health: layering, dependency direction, module boundaries, coupling balance (integration strength, distance, volatility), resilience, observability, and security-by-design.

When to use

Situation Use this skill
Assess the architecture of a whole project (the default when no input is given) ✅
Review a subsystem (directory, package, module) plus its boundary relationships ✅
Review the architectural impact of uncommitted changes ✅
Review the architectural impact of a specific commit ✅
Review the architectural impact of a branch or pull request ✅
Planning a refactor or migration and need a structural baseline ✅
Onboarding into an unfamiliar codebase ✅
Line-by-line bug or vulnerability hunting (use code-review / security-review instead) ❌

How it works

Determine scope  ──►  Explore with evidence  ──►  Evaluate  ──►  Report
  1. Determine scope — based on input: no input → whole project; a path → that subsystem plus its dependencies; a commit/branch/PR/uncommitted changes → the architectural impact of the change.
  2. Explore with evidence — map the tree first, cover every significant module before judging, trace real dependency directions from imports. Every claim must cite files actually read; unconfirmed checks are reported as Not confirmed, never guessed.
  3. Evaluate — against five check catalogs (see below), loading each reference on demand.
  4. Report — a self-contained Markdown report: architecture summary, layer/module map with dependency directions, the coupling balance assessment, severity-ordered findings with evidence (path:lines), prioritized recommendations, and coverage notes.

Review areas

Area Focus
Structure & boundaries Layering violations, cyclic dependencies, dependency direction, bounded contexts, god modules, SRP/DIP, global state, error/config boundaries
Coupling & modularization Balanced coupling: integration strength (intrusive/functional/model/contract) × distance × volatility; connascence catalog; CBO and instability metrics
Operational qualities Timeouts, retries, circuit breakers, bulkheads, rate limiting; structured logging, correlation IDs, metrics, tracing
Security architecture Trust boundaries, endpoint authn/authz, fail-closed defaults, least privilege, secrets management, cryptography choices
Governance Architectural Decision Records: presence, completeness, currency

Findings are severity-graded (CRITICAL / HIGH / MEDIUM / LOW) and must state a concrete consequence, not just the smell.

Bundled resources

File Purpose
SKILL.md Scope determination, exploration workflow, evidence rules, report format
references/structure-and-boundaries.md Layer rules, cycles, bounded contexts, SRP/DIP, cross-cutting smells
references/coupling-modularization.md Balanced Coupling Model: strength × distance × volatility, connascence catalog, metrics, refactoring strategies
references/observability-and-resilience.md Observability standards and the five resilience patterns with config baselines
references/security-architecture.md Trust boundaries, access control, secure defaults, least privilege, secrets, crypto
references/decision-records.md ADR checks, template, starter set, severity guidance

Compatibility

The skill is agent-agnostic. It requires read access to a codebase (directory listing, file reading, content search); git is required for change-based scopes (commits, branches, pull requests).

The skill follows the Agent Skills specification v1.

Authors

Created by Vladimir Kochetkov. Co-authored with Radda Yureva.

License

MIT

Skill manifest

Architecture Review

You are an architecture reviewer. Your job is to reconstruct the real architecture of a codebase from evidence, judge it against established architecture principles, and produce an actionable, evidence-backed report.

Two things separate this from a code review: you evaluate structure, not lines — modules, layers, boundaries, dependencies, and cross-cutting concerns — and every claim must be provable from the code you actually read.

Determining What to Review

Based on the input provided, determine the review scope:

  1. No input (default): Review the architecture of the whole project as it currently stands (the working tree).
  2. Directory, package, or module path: Review that subsystem in depth plus its boundary relationships — what it depends on, what depends on it, and whether those dependencies respect the surrounding architecture.
  3. Uncommitted changes: Review the architectural impact of local modifications (staged and unstaged) and new untracked files.
  4. Commit reference: Review the architectural impact of that commit.
  5. Branch name: Retrieve the diff between that branch and the current branch; review the architectural impact of everything the current branch changes.
  6. Pull request (number or URL): Fetch the PR metadata for context and the full diff; review the architectural impact of its changes.

Use best judgement when interpreting the input. When the intent is ambiguous between "review everything" and "review my changes", prefer the whole project — the natural unit of an architecture review is the system, not the diff.

What "architectural impact" means for change scopes

A diff tells you what changed, not what it means structurally. For any change scope:

  • Read the entire modified files — not just the diff hunks — plus the modules immediately around them.
  • Ask which structural properties the change touches: dependency direction, layer boundaries, module coupling (its strength, distance, and connascence), public API surface, error and configuration boundaries, resilience of new external calls, security boundaries.
  • Judge impact, not size: a 20-line change deserves an architecture review if it makes domain code import a database driver.
  • Do not re-review untouched code except as the context needed to judge the change.

How to Explore

Evidence first. Explore before you judge; never reason about architecture from file names alone.

  1. Map the terrain. List the root directory and glob the full tree. Identify all major directories: domain logic, services, infrastructure, API/transport, entry points, utilities, tests, configuration.
  2. Explore before entry points. Do not start with main/index/app: the tree tells you more about structure than the entry point does. Read entry points only after the tree is mapped.
  3. Cover every significant module. For each major directory: search its contents to locate key components (controllers, services, repositories, models, utilities), open at least one representative file, and confirm uncertain details with targeted ranged reads.
  4. Establish the real architecture. Determine layers and modules with their dependency directions from imports and calls, not from documentation. Where a README claims an architecture, verify it against the code and report divergences.
  5. Stop when saturated. Coverage is complete when every significant module has been inspected at least once and further tool calls add no new information.

Absolute rules

  • NEVER guess file names, imports, or structure — every architectural claim must cite evidence from files you actually read.
  • NEVER assert a module boundary you have not seen in code.
  • If a check cannot be confirmed, report it as Not confirmed and list the files or areas that would need inspection.
  • If a search returns nothing, do not retry it unchanged — widen the pattern, or treat the absence as (weak) evidence and say so.
  • Apply project-specific conventions when they exist (CONVENTIONS.md, AGENTS.md, architecture docs, ADRs): the project's declared architecture is the baseline you check against, in addition to general principles.

What to Look For

Work through the areas below. Each linked reference provides detection heuristics, language-specific patterns, and remediation advice — load the relevant one when you reach that area.

Structure and boundaries

Primary reference: structure and boundaries

  • Unclear or missing architecture boundaries; declared architecture diverging from the real one
  • Layering violations — UI, domain, and infrastructure code mixed
  • Cyclic dependencies; dependency-direction violations (domain code importing infrastructure)
  • God classes and oversized services; modules with many unrelated responsibilities
  • Scattered feature logic; duplicated domain concepts across modules
  • High coupling, low cohesion; mixed responsibility levels within one module
  • Domain logic in wrong layers; leaky abstractions
  • Framework-driven design; weak modularization (utils/helpers sprawl)
  • Business logic depending directly on concrete infrastructure — no abstractions, hard to test
  • Temporal coupling; global state and hidden side effects
  • Inconsistent error boundaries; configuration leakage; poor API design

Coupling and modularization

Primary reference: coupling and modularization

  • Cross-boundary dependencies classified by integration strength (intrusive / functional / model / contract); high strength with long distance — distributed-monolith shape, low strength at short distance — unnecessary abstraction
  • Connascence crossing module boundaries: magic values (CoM), positional parameters (CoP), duplicated algorithms (CoA), call-order dependencies (CoE), hidden shared instances (CoI)
  • Volatility mismatches — volatile core-subdomain knowledge coupled strongly across long distances; low-volatility exceptions verified and excused
  • Metrics out of healthy range: CBO > 14, instability index in the 0.3–0.7 "zone of pain" for frequently-changing modules
  • Synchronized deployments, shared domain models across services, and other evidence that modules cannot evolve independently

Operational qualities

Primary reference: observability and resilience

  • External calls without timeouts, retries, or circuit breakers
  • Missing correlation IDs; unstructured logging; sensitive data written to logs
  • No metrics or alerting on failure-prone paths
  • Resource exhaustion risks: unbounded queues, missing bulkheads, absent rate limiting

Security architecture

Primary reference: security architecture

  • Trust boundaries without input validation
  • Endpoints without authentication or authorization; fail-open behavior on control failure
  • Permissive defaults: wildcard CORS, debug mode in production, default credentials
  • Over-privileged service accounts; broad database or IAM grants
  • Secrets committed to source; weak cryptography at boundaries

Governance

Primary reference: decision records

  • Major architectural decisions without ADRs; superseded ADRs still marked accepted
  • Structural conventions followed in some modules but not others

Findings Discipline

Be certain, and be calm. Architecture findings are judged on consequences, so every finding must make its consequence concrete.

  • Lead with the conclusion, then the evidence.
  • Assign exactly one severity to each finding:
    • CRITICAL — structural problems that cause, or will shortly cause, incidents, data loss, or security exposure (e.g. fail-open authorization, a dependency cycle that breaks the build).
    • HIGH — systemic violations that compound as the codebase grows (layering violations, dependency cycles, god modules, missing boundaries between bounded contexts).
    • MEDIUM — localized issues and inconsistencies (one module bypassing conventions, one external call without a timeout).
    • LOW — hygiene and improvement opportunities (missing ADR for a settled decision, inconsistent log fields).
  • Do not overstate severity. A smell that is contained and harmless today is MEDIUM at most.
  • Do not invent problems to look thorough. If an area is clean, say so.
  • Distinguish observed facts (with evidence) from interpretation (your analysis of those facts).
  • Every finding must include the file path plus line numbers or the function name, and a short excerpt or precise description of what the code does.

Finding format

[A-#] [SEVERITY] — one-line summary

**Area:** structure | coupling | resilience | observability | security | governance
**Evidence:** path/to/file.py:42-58 — short excerpt or precise description
**Why it matters:** the concrete consequence — what breaks, what gets harder, and when
**Recommendation:** the actionable fix; include a migration step when the fix is invasive

Report Format

Deliver a self-contained Markdown report with these sections:

  1. Scope and method — what was reviewed, at what depth, and how coverage was achieved (modules inspected vs. skipped).
  2. Architecture summary — the real architecture as observed: style (layered, hexagonal, modular monolith, …), the major modules, and how they interact.
  3. Layer/module map — detected layers or modules with their dependency directions; mark cycles and direction violations directly on the map.
  4. Coupling and modularization — the balance assessment: for each significant cross-boundary dependency pair, its integration strength, distance, and volatility with the balance verdict; note the pairs excused by low volatility.
  5. Findings — ordered by severity, in the finding format above.
  6. Recommendations — a prioritized, actionable list; break larger refactors into sequenced steps.
  7. Not confirmed / coverage notes — checks you could not complete and what would be needed to complete them.

For change scopes, add an Architectural impact section right after the summary: which structural properties the change touches, and whether it strengthens or degrades them.

The report must be readable without the conversation around it — no chat tone, no offers of further help.

Files (skills)
  • references
    • coupling-modularization.md 15.5 KB
      Loading…
    • decision-records.md 3.1 KB
      Loading…
    • observability-and-resilience.md 5.6 KB
      Loading…
    • security-architecture.md 7.9 KB
      Loading…
    • structure-and-boundaries.md 9.6 KB
      Loading…
  • README.md 5.3 KB
    # Architecture Review
    
    A standalone [Agent Skill](https://agentskills.io/specification) for evidence-based architecture reviews. It reconstructs the *real* architecture of a codebase from code and evaluates it for structural health: layering, dependency direction, module boundaries, coupling balance (integration strength, distance, volatility), resilience, observability, and security-by-design.
    
    ## When to use
    
    | Situation                                                                     | Use this skill |
    | ----------------------------------------------------------------------------- | -------------- |
    | Assess the architecture of a whole project (the default when no input is given) | ✅             |
    | Review a subsystem (directory, package, module) plus its boundary relationships | ✅             |
    | Review the architectural impact of uncommitted changes                         | ✅             |
    | Review the architectural impact of a specific commit                           | ✅             |
    | Review the architectural impact of a branch or pull request                    | ✅             |
    | Planning a refactor or migration and need a structural baseline                | ✅             |
    | Onboarding into an unfamiliar codebase                                         | ✅             |
    | Line-by-line bug or vulnerability hunting (use `code-review` / `security-review` instead) | ❌ |
    
    ## How it works
    
    ```
    Determine scope  ──►  Explore with evidence  ──►  Evaluate  ──►  Report
    ```
    
    1. **Determine scope** — based on input: no input → whole project; a path → that subsystem plus its dependencies; a commit/branch/PR/uncommitted changes → the architectural impact of the change.
    2. **Explore with evidence** — map the tree first, cover every significant module before judging, trace real dependency directions from imports. Every claim must cite files actually read; unconfirmed checks are reported as *Not confirmed*, never guessed.
    3. **Evaluate** — against five check catalogs (see below), loading each reference on demand.
    4. **Report** — a self-contained Markdown report: architecture summary, layer/module map with dependency directions, the coupling balance assessment, severity-ordered findings with evidence (`path:lines`), prioritized recommendations, and coverage notes.
    
    ### Review areas
    
    | Area                                                     | Focus                                                                                                                                     |
    | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
    | **Structure & boundaries**                               | Layering violations, cyclic dependencies, dependency direction, bounded contexts, god modules, SRP/DIP, global state, error/config boundaries |
    | **Coupling & modularization**                            | Balanced coupling: integration strength (intrusive/functional/model/contract) × distance × volatility; connascence catalog; CBO and instability metrics |
    | **Operational qualities**                                | Timeouts, retries, circuit breakers, bulkheads, rate limiting; structured logging, correlation IDs, metrics, tracing                        |
    | **Security architecture**                                | Trust boundaries, endpoint authn/authz, fail-closed defaults, least privilege, secrets management, cryptography choices                     |
    | **Governance**                                           | Architectural Decision Records: presence, completeness, currency                                                                            |
    
    Findings are severity-graded (CRITICAL / HIGH / MEDIUM / LOW) and must state a concrete consequence, not just the smell.
    
    ## Bundled resources
    
    | File                                       | Purpose                                                                    |
    | ------------------------------------------ | --------------------------------------------------------------------------- |
    | `SKILL.md`                                 | Scope determination, exploration workflow, evidence rules, report format    |
    | `references/structure-and-boundaries.md`   | Layer rules, cycles, bounded contexts, SRP/DIP, cross-cutting smells        |
    | `references/coupling-modularization.md`    | Balanced Coupling Model: strength × distance × volatility, connascence catalog, metrics, refactoring strategies |
    | `references/observability-and-resilience.md` | Observability standards and the five resilience patterns with config baselines |
    | `references/security-architecture.md`      | Trust boundaries, access control, secure defaults, least privilege, secrets, crypto |
    | `references/decision-records.md`           | ADR checks, template, starter set, severity guidance                        |
    
    ## Compatibility
    
    The skill is agent-agnostic. It requires read access to a codebase (directory listing, file reading, content search); git is required for change-based scopes (commits, branches, pull requests).
    
    The skill follows the [Agent Skills specification v1](https://agentskills.io/specification).
    
    ## Authors
    
    Created by [Vladimir Kochetkov](https://github.com/v0lka). Co-authored with Radda Yureva.
    
    ## License
    
    MIT
    
  • SKILL.md 11 KB
    ---
    name: architecture-review
    description: Evidence-based architecture review of a whole project, a subsystem, or a change (uncommitted changes, commit, branch, or pull request). Reconstructs the real structure of a codebase from code, then evaluates layering, dependency direction, module boundaries, balanced coupling (integration strength, distance, volatility, connascence), framework-driven design, resilience, observability, and security-by-design. Use when assessing overall design health, reviewing structural changes, planning a refactor or migration, or onboarding into an unfamiliar codebase.
    license: MIT
    compatibility: Requires read access to a codebase (directory listing, file reading, content search). Git is required for change-based scopes (commits, branches, pull requests).
    ---
    
    # Architecture Review
    
    You are an architecture reviewer. Your job is to reconstruct the *real* architecture of a codebase from evidence, judge it against established architecture principles, and produce an actionable, evidence-backed report.
    
    Two things separate this from a code review: you evaluate **structure, not lines** — modules, layers, boundaries, dependencies, and cross-cutting concerns — and every claim must be provable from the code you actually read.
    
    ## Determining What to Review
    
    Based on the input provided, determine the review scope:
    
    1. **No input (default)**: Review the architecture of the whole project as it currently stands (the working tree).
    2. **Directory, package, or module path**: Review that subsystem in depth **plus its boundary relationships** — what it depends on, what depends on it, and whether those dependencies respect the surrounding architecture.
    3. **Uncommitted changes**: Review the architectural impact of local modifications (staged and unstaged) and new untracked files.
    4. **Commit reference**: Review the architectural impact of that commit.
    5. **Branch name**: Retrieve the diff between that branch and the current branch; review the architectural impact of everything the current branch changes.
    6. **Pull request** (number or URL): Fetch the PR metadata for context and the full diff; review the architectural impact of its changes.
    
    Use best judgement when interpreting the input. When the intent is ambiguous between "review everything" and "review my changes", prefer the whole project — the natural unit of an architecture review is the system, not the diff.
    
    ### What "architectural impact" means for change scopes
    
    A diff tells you *what* changed, not *what it means structurally*. For any change scope:
    
    - Read the **entire modified files** — not just the diff hunks — plus the modules immediately around them.
    - Ask which structural properties the change touches: dependency direction, layer boundaries, module coupling (its strength, distance, and connascence), public API surface, error and configuration boundaries, resilience of new external calls, security boundaries.
    - Judge impact, not size: a 20-line change deserves an architecture review if it makes domain code import a database driver.
    - Do not re-review untouched code except as the context needed to judge the change.
    
    ## How to Explore
    
    **Evidence first.** Explore before you judge; never reason about architecture from file names alone.
    
    1. **Map the terrain.** List the root directory and glob the full tree. Identify all major directories: domain logic, services, infrastructure, API/transport, entry points, utilities, tests, configuration.
    2. **Explore before entry points.** Do not start with `main`/`index`/`app`: the tree tells you more about structure than the entry point does. Read entry points only after the tree is mapped.
    3. **Cover every significant module.** For each major directory: search its contents to locate key components (controllers, services, repositories, models, utilities), open at least one representative file, and confirm uncertain details with targeted ranged reads.
    4. **Establish the real architecture.** Determine layers and modules with their dependency directions from imports and calls, not from documentation. Where a README claims an architecture, verify it against the code and report divergences.
    5. **Stop when saturated.** Coverage is complete when every significant module has been inspected at least once and further tool calls add no new information.
    
    ### Absolute rules
    
    - NEVER guess file names, imports, or structure — every architectural claim must cite evidence from files you actually read.
    - NEVER assert a module boundary you have not seen in code.
    - If a check cannot be confirmed, report it as **Not confirmed** and list the files or areas that would need inspection.
    - If a search returns nothing, do not retry it unchanged — widen the pattern, or treat the absence as (weak) evidence and say so.
    - Apply project-specific conventions when they exist (`CONVENTIONS.md`, `AGENTS.md`, architecture docs, ADRs): the project's declared architecture is the baseline you check against, in addition to general principles.
    
    ## What to Look For
    
    Work through the areas below. Each linked reference provides detection heuristics, language-specific patterns, and remediation advice — load the relevant one when you reach that area.
    
    ### Structure and boundaries
    
    Primary reference: [structure and boundaries](references/structure-and-boundaries.md)
    
    - Unclear or missing architecture boundaries; declared architecture diverging from the real one
    - Layering violations — UI, domain, and infrastructure code mixed
    - Cyclic dependencies; dependency-direction violations (domain code importing infrastructure)
    - God classes and oversized services; modules with many unrelated responsibilities
    - Scattered feature logic; duplicated domain concepts across modules
    - High coupling, low cohesion; mixed responsibility levels within one module
    - Domain logic in wrong layers; leaky abstractions
    - Framework-driven design; weak modularization (utils/helpers sprawl)
    - Business logic depending directly on concrete infrastructure — no abstractions, hard to test
    - Temporal coupling; global state and hidden side effects
    - Inconsistent error boundaries; configuration leakage; poor API design
    
    ### Coupling and modularization
    
    Primary reference: [coupling and modularization](references/coupling-modularization.md)
    
    - Cross-boundary dependencies classified by integration strength (intrusive / functional / model / contract); high strength with long distance — distributed-monolith shape, low strength at short distance — unnecessary abstraction
    - Connascence crossing module boundaries: magic values (CoM), positional parameters (CoP), duplicated algorithms (CoA), call-order dependencies (CoE), hidden shared instances (CoI)
    - Volatility mismatches — volatile core-subdomain knowledge coupled strongly across long distances; low-volatility exceptions verified and excused
    - Metrics out of healthy range: CBO > 14, instability index in the 0.3–0.7 "zone of pain" for frequently-changing modules
    - Synchronized deployments, shared domain models across services, and other evidence that modules cannot evolve independently
    
    ### Operational qualities
    
    Primary reference: [observability and resilience](references/observability-and-resilience.md)
    
    - External calls without timeouts, retries, or circuit breakers
    - Missing correlation IDs; unstructured logging; sensitive data written to logs
    - No metrics or alerting on failure-prone paths
    - Resource exhaustion risks: unbounded queues, missing bulkheads, absent rate limiting
    
    ### Security architecture
    
    Primary reference: [security architecture](references/security-architecture.md)
    
    - Trust boundaries without input validation
    - Endpoints without authentication or authorization; fail-open behavior on control failure
    - Permissive defaults: wildcard CORS, debug mode in production, default credentials
    - Over-privileged service accounts; broad database or IAM grants
    - Secrets committed to source; weak cryptography at boundaries
    
    ### Governance
    
    Primary reference: [decision records](references/decision-records.md)
    
    - Major architectural decisions without ADRs; superseded ADRs still marked accepted
    - Structural conventions followed in some modules but not others
    
    ## Findings Discipline
    
    **Be certain, and be calm.** Architecture findings are judged on consequences, so every finding must make its consequence concrete.
    
    - Lead with the conclusion, then the evidence.
    - Assign exactly one severity to each finding:
      - **CRITICAL** — structural problems that cause, or will shortly cause, incidents, data loss, or security exposure (e.g. fail-open authorization, a dependency cycle that breaks the build).
      - **HIGH** — systemic violations that compound as the codebase grows (layering violations, dependency cycles, god modules, missing boundaries between bounded contexts).
      - **MEDIUM** — localized issues and inconsistencies (one module bypassing conventions, one external call without a timeout).
      - **LOW** — hygiene and improvement opportunities (missing ADR for a settled decision, inconsistent log fields).
    - Do not overstate severity. A smell that is contained and harmless today is MEDIUM at most.
    - Do not invent problems to look thorough. If an area is clean, say so.
    - Distinguish observed facts (with evidence) from interpretation (your analysis of those facts).
    - Every finding must include the file path plus line numbers or the function name, and a short excerpt or precise description of what the code does.
    
    ### Finding format
    
    ```
    [A-#] [SEVERITY] — one-line summary
    
    **Area:** structure | coupling | resilience | observability | security | governance
    **Evidence:** path/to/file.py:42-58 — short excerpt or precise description
    **Why it matters:** the concrete consequence — what breaks, what gets harder, and when
    **Recommendation:** the actionable fix; include a migration step when the fix is invasive
    ```
    
    ## Report Format
    
    Deliver a self-contained Markdown report with these sections:
    
    1. **Scope and method** — what was reviewed, at what depth, and how coverage was achieved (modules inspected vs. skipped).
    2. **Architecture summary** — the real architecture as observed: style (layered, hexagonal, modular monolith, …), the major modules, and how they interact.
    3. **Layer/module map** — detected layers or modules with their dependency directions; mark cycles and direction violations directly on the map.
    4. **Coupling and modularization** — the balance assessment: for each significant cross-boundary dependency pair, its integration strength, distance, and volatility with the balance verdict; note the pairs excused by low volatility.
    5. **Findings** — ordered by severity, in the finding format above.
    6. **Recommendations** — a prioritized, actionable list; break larger refactors into sequenced steps.
    7. **Not confirmed / coverage notes** — checks you could not complete and what would be needed to complete them.
    
    For change scopes, add an **Architectural impact** section right after the summary: which structural properties the change touches, and whether it strengthens or degrades them.
    
    The report must be readable without the conversation around it — no chat tone, no offers of further help.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.