agentleFS
L-X-TL-X-T/ng-agentic-skills/.agents/skills/ng-review-architecture/SKILL.md

ng-review-architecture

Skill13 starsChanged 44 days agoMITView on GitHub

Review the architecture of an Angular project against domain-driven design and module depth – bounded contexts, library categories (feature/ui/data-access/util/domain/api/shell), domain isolation, access restrictions, smart/dumb components, and deep vs shallow modules. Produces a structured review, then drills into chosen findings. Use when the user wants an Angular architecture review, to assess domain structure or boundaries, find refactoring or deepening opportunities, or check DDD/Nx layering and dependency rules.

The file

We split this skill into the rules it gives an agent

2 rules. About 0 are common, 1 is distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Read first – these and AGENTS.md override any generic example here:

    line 23
  2. Very specific:

    Sharpening a fuzzy term mid-conversation?: Update CONTEXT.md right there.

    line 56

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Review Angular architecture

Review an Angular codebase against two lenses that compose:

  • Domain structure (DDD): is the system carved into bounded contexts with isolated domains, the right library categories, and enforced access restrictions? Vocabulary and checklist in references/ddd.md.
  • Module depth: are the modules behind those seams deep (much behaviour behind a small interface) or shallow pass-throughs? Vocabulary in references/language.md.

The frame that unites them: bounded contexts name where the seams belong; depth measures the modules sitting behind them. A finding can be a misplaced seam (DDD), a shallow module (depth), or both. Use the terms in references/ddd.md and references/language.md exactly – consistent language is the point, so don't drift into "component", "service", "API", or "boundary".

This review is informed by the project's own domain model: a CONTEXT.md glossary names good seams, and ADRs record decisions the review must not re-litigate (check for a root ADR.md with ## ADR-NNN sections or a docs/adr/NNNN-title.md folder; when neither exists, create ADR.md lazily on the first decision worth recording).

1. Explore

Read first – these and AGENTS.md override any generic example here:

  • The project domain glossary (CONTEXT.md) and any ADRs touching the area under review.
  • style-guide/style-guide.md, then the specific guides for the code being judged (style-guide/style-guide.ts.md, style-guide/style-guide.html.md, style-guide/style-guide.scss.md).

Detect the project shape, because it sets how the DDD model maps:

  • Nx monorepo (nx.json, apps/ + libs/): the library categories are real libs with type:/scope: tags enforced by @nx/enforce-module-boundaries.
  • Plain Angular app (a single angular.json project): the same categories map to feature folders under src/app; access restrictions are conventions plus ESLint, not buildable-lib boundaries.

Then explore organically with the tools available (rg, the Nx project graph when present, focused reads); use multi-agent exploration only when that tooling actually exists. Note where you feel friction, against both lenses (full checklists in references/ddd.md and references/language.md):

  • Domain: Can you name the bounded contexts? Do domains leak into each other except through a domain's api/shell? Is the domain layer free of infrastructure (data-access, HTTP, framework)? Are feature (smart) and ui (dumb) components separated? Is the ubiquitous language consistent, or do the same concepts wear different names across contexts?
  • Depth: Where does understanding one concept require bouncing between many small modules? Where is a module shallow – its interface nearly as complex as its implementation? Apply the deletion test to anything you suspect is a pass-through: would deleting it concentrate complexity, or just move it?

2. Write the review

Open the report with a one-paragraph domain map – the bounded contexts you identified and the overall health – then a numbered list of findings, grouped by context/domain (or by lens when a finding is cross-cutting). For each finding:

  • Where – the files, libraries, or feature folders involved.
  • Problem – the friction, named in DDD and depth terms (e.g. "the booking domain reaches into boarding's data-access directly, bypassing its api seam", or "PricingService is a shallow pass-through with no locality").
  • Recommendation – the plain-English change: where the seam should sit, which category the code belongs in, what the deepened module's interface would look like.
  • Benefits – in terms of domain isolation, access restrictions, locality, leverage, and how testability improves through the interface.

Use CONTEXT.md vocabulary for the domain, references/language.md for architecture, references/ddd.md for structure, and the style guide for code-shape constraints. If a finding contradicts an existing ADR, surface it only when the friction is real enough to reopen the ADR, and mark it clearly ("contradicts ADR-0007 – worth reopening because…"). Don't list every theoretical refactor an ADR forbids.

End with: "Which finding would you like to explore?" Do not propose detailed interfaces yet.

3. Drill in (grilling loop)

Once the user picks a finding, walk the design tree with them – constraints, dependencies, where the seam sits, what lives behind it, what survives in tests. Side effects happen inline as decisions crystallize:

  • Naming a module or domain after a concept not in CONTEXT.md? Add the term (create CONTEXT.md lazily if absent) – format below.
  • Sharpening a fuzzy term mid-conversation? Update CONTEXT.md right there.
  • User rejects a finding with a load-bearing reason a future reviewer would need? Offer to record an ADR so the next review doesn't re-suggest it (format below). Skip ephemeral reasons ("not worth it right now") and self-evident ones.
  • Exploring alternative interfaces for a deepened module? See references/interface-design.md. Classify the module's dependencies and pick a verification strategy with references/deepening.md. Per AGENTS.md, tests are written deliberately: when a drill-down needs a verification spec and a test setup exists, write it via ng-testing or create-e2e-tests; never scaffold specs as filler.

CONTEXT.md entry format

## <Term>
<One-sentence definition in the project's own words.> Bounded context: <which>. Avoid: <terms it must not be confused with>.

ADR format (root ADR.md section by default, or docs/adr/NNNN-title.md where that layout already exists)

# ADR-NNNN: <decision>
Status: accepted · Date: <YYYY-MM-DD>

## Context
<the friction and constraints>

## Decision
<what was decided>

## Consequences
<trade-offs, and why future reviews should not re-suggest the rejected alternative>

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.