agentleFS
rehantariq121rehantariq121/claude-skills-public/9am-architecture/SKILL.md

9am-architecture

Skill0 starsChanged 2 months agoMITView on GitHub

Orchestrate architecture discovery, domain clarification, multi-application platform design, admin/control-plane structure, module and data ownership, API and event contracts, implementation handoff, and architecture verification. Use for greenfield or existing platforms with admin, customer, partner, operator, public, API, or worker applications; for modular-monolith versus service decisions; or for architecture refactoring. Pair conditionally with grill-with-docs, domain-modeling, codebase-design, implement, and code-review. Do not use for visual styling alone.

The file

Show its rules and text

We split this skill into the rules it gives an agent

17 rules. About 0 are common, 17 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈17

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Treat this skill as the architecture orchestrator.

    line 24
  2. Distinctive:

    Do not run every companion merely because it is installed.

    line 37
  3. Distinctive:

    Never treat an architecture request as authorization to edit code, commit, open a PR, or change production state.

    line 39
  4. Distinctive:

    Before implementation, record the accepted spec/ticket and the baseline commit or other fixed point.

    line 40
  5. Distinctive:

    Stop or loop back when an exit gate fails.

    line 43
  6. Distinctive:

    If grill-with-docs exists but its grilling primitive is unavailable, perform the bounded requirements workflow in …

    line 47
  7. Distinctive:

    If implement exists but tdd is unavailable, follow repository tests at pre-agreed seams and report that the dedicated TDD flow did not run.

    line 48
  8. Distinctive:

    If code-review lacks its issue-tracker setup or cannot resolve a fixed point/spec, do not claim a complete two-axis review.

    line 49
  9. Distinctive:

    Run grill-with-docs first only when its invocation gate is met.

    line 61
  10. Distinctive:

    Do not proceed to architecture until the following are known or explicitly marked Unknown:

    line 63
  11. Distinctive:

    Start with the simplest deployable architecture.

    line 84
  12. Distinctive:

    Use architecture quality gates against the resulting system or plan.

    line 112
  13. Distinctive:

    Keep authorization, financial truth, lifecycle transitions, limits, eligibility, and protected validation server-side.

    line 118
  14. Distinctive:

    Keep controllers and widgets thin: translate input, invoke one use case, and map the result.

    line 120
  15. Distinctive:

    Use explicit DTOs, stable machine error codes, bounded pagination, scoped queries, idempotency, and concurrency protection.

    line 121
  16. Distinctive:

    Keep external calls outside critical database transactions.

    line 122
  17. Distinctive:

    Treat secrets, tenant scope, sensitive fields, exports, uploads, audit, retention, and recovery as architecture concerns.

    line 123

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 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

9AM ARCHITECTURE

Design the smallest architecture that gives every business capability, mutable fact, contract, and operational workflow an explicit owner.

Operating modes

Choose one mode from the request and risk. Do not produce the full artifact set by default.

ModeUse whenRequired output
QuickOne bounded capability, small CRUD tool, or one architecture decisionDecision, owner, interface, trade-off, verification
StandardMulti-app feature, admin workflow, or meaningful refactorCapability map, ownership, representative flow, module/contracts, risks
Full auditPlatform redesign, migration, finance, compliance, multi-tenant authority, or an explicit audit requestAll applicable matrices, flows, quality gates, risks, and implementation phases

For a full audit, read full-architecture-standard.md. Otherwise load only the phase references required by the task.

Companion-skill orchestration

Treat this skill as the architecture orchestrator. Companion skills deepen a phase; they do not replace this skill or run unconditionally.

PhaseCompanionInvoke whenExit evidence
Requirementsgrill-with-docsThe user explicitly invokes it or requests the complete discovery-to-delivery flow and requirements contain consequential unknownsAgreed goals, actors, constraints, unresolved questions, glossary/ADRs where justified
Terminologydomain-modelingTerms are overloaded, capability boundaries are unclear, code contradicts stated domain behavior, or the glossary must changeCanonical terms in CONTEXT.md; sparse ADRs for hard-to-reverse trade-offs
Architecture9am-archetectureRequirements are sufficient to decide capability, application, data, contract, permission, deployment, or operational ownershipArchitecture artifacts appropriate to the selected mode
Module internalscodebase-designA module interface, seam, adapter, dependency direction, test surface, or deepening decision is materialSmall interface, hidden complexity, explicit seam/adapters, test strategy
CodingimplementThe user explicitly authorizes implementation and an accepted spec or bounded ticket existsWorking code, tests, typechecks, and a committed change when the repository workflow permits
Verificationcode-reviewCode changed and a fixed point plus spec/standards source exists, or the user explicitly asks for a diff reviewSeparate Standards and Spec findings; architecture gates remain a separate report

Invocation rules

  1. Do not run every companion merely because it is installed.
  2. Respect companion invocation constraints. grill-with-docs and implement are opt-in skills; recommend or use them only when the user has explicitly requested that phase or a complete flow that includes it.
  3. Never treat an architecture request as authorization to edit code, commit, open a PR, or change production state.
  4. Before implementation, record the accepted spec/ticket and the baseline commit or other fixed point. This gives code-review a valid comparison after implementation.
  5. Preflight the companion and any primitive it requires. An installed wrapper is degraded when its required primitive is missing. Continue with the relevant phase reference where safe, state the missing specialization, and never fabricate that the companion ran.
  6. Preserve phase outputs. A later phase may refine an earlier decision, but must record the change and its reason instead of silently contradicting it.
  7. Stop or loop back when an exit gate fails. Do not force a linear flow through unresolved authority, data ownership, compliance, or compatibility decisions.

Companion dependency fallbacks

  • If grill-with-docs exists but its grilling primitive is unavailable, perform the bounded requirements workflow in requirements-and-domain.md, use domain-modeling when available, and report the degraded discovery path.
  • If implement exists but tdd is unavailable, follow repository tests at pre-agreed seams and report that the dedicated TDD flow did not run.
  • If code-review lacks its issue-tracker setup or cannot resolve a fixed point/spec, do not claim a complete two-axis review. Report the missing precondition and still run the separate architecture gates.

Default flow

0. Inspect before interviewing

Inspect repository structure, applications, entry points, routes, models, migrations, permissions, jobs, integrations, tests, and current documentation. Prefer structural graph tools for code discovery and verify critical conclusions against checked-out source. Use text search for literals, configuration, migrations, templates, and uncovered formats.

Read requirements-and-domain.md.

1. Establish requirements and language

Run grill-with-docs first only when its invocation gate is met. Use domain-modeling during discovery when terminology or boundaries need active clarification.

Do not proceed to architecture until the following are known or explicitly marked Unknown:

  • product goal and actors;
  • applications/channels and tenant model;
  • sensitive operations and authority;
  • critical lifecycles and systems of record;
  • integrations, jobs, compatibility, and migration constraints;
  • material availability, latency, throughput, privacy, recovery, and compliance targets.

2. Design capability and ownership architecture

Read architecture-and-ownership.md.

Separate five axes:

  1. business capability;
  2. application boundary;
  3. technical layer;
  4. deployment boundary;
  5. data ownership.

Start with the simplest deployable architecture. Prefer a modular monolith until independent scaling, release cadence, isolation, legal boundaries, or end-to-end team ownership justify a service split.

3. Design modules and contracts

Read modules-and-contracts.md.

Invoke codebase-design only for material interface or seam decisions. Keep domain rules server-authoritative, client presentation independent, and contracts explicit.

Trace at least one success flow and the highest-risk failure for every critical capability in Standard or Full mode.

4. Prepare implementation handoff

Read implementation-handoff.md.

Architecture is implementation-ready only when:

  • the scope and acceptance criteria are bounded;
  • capability, data, API/event, and permission owners are named;
  • transaction, concurrency, idempotency, and side effects are explicit;
  • migration, compatibility, rollback, observability, and tests are proportionate to risk;
  • important unknowns are resolved or assigned to investigation work.

Invoke implement only after the user authorizes coding. Do not hide unresolved architecture decisions inside implementation.

5. Verify independently

Read verification-and-operations.md.

Use architecture quality gates against the resulting system or plan. If code changed, use code-review with the recorded fixed point and spec. Keep its Standards and Spec axes separate from the architecture-gate report.

Core rules

  • Organize admin navigation around operator goals, queues, decisions, and configuration—not database tables.
  • Give every mutable business fact one system of record and one writer.
  • Keep authorization, financial truth, lifecycle transitions, limits, eligibility, and protected validation server-side.
  • Represent guarded transitions as named actions; do not expose arbitrary status assignment.
  • Keep controllers and widgets thin: translate input, invoke one use case, and map the result.
  • Use explicit DTOs, stable machine error codes, bounded pagination, scoped queries, idempotency, and concurrency protection.
  • Keep external calls outside critical database transactions; use durable asynchronous work when retries or fan-out are required.
  • Treat secrets, tenant scope, sensitive fields, exports, uploads, audit, retention, and recovery as architecture concerns.
  • Collapse empty layers and reject speculative abstractions.
  • Record Unknown rather than inventing evidence.

Required reporting

For each major decision, report:

FieldContent
RuleOne imperative decision
PurposeFailure or cost prevented
Use whenConditions that justify it
Do not use whenSimpler or different conditions
Trade-offComplexity, latency, ownership, or delivery cost
VerificationCode, contract, test, diagram, or runtime evidence

End with:

  • selected operating mode;
  • companion skills actually used, skipped, or unavailable and why;
  • artifacts produced;
  • unresolved risks and Unknowns;
  • next authorized phase.

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.