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.
In this repository6 other files it gives its agents.
- amar-protocolSkill
- graphifySkill
- prototypeSkill
- routeSkill
- source-first-uiSkill
- triageSkill
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
- Distinctive: line 24
Treat this skill as the architecture orchestrator.
- Distinctive: line 37
Do not run every companion merely because it is installed.
- Distinctive: line 39
Never treat an architecture request as authorization to edit code, commit, open a PR, or change production state.
- Distinctive: line 40
Before implementation, record the accepted spec/ticket and the baseline commit or other fixed point.
- Distinctive: line 43
Stop or loop back when an exit gate fails.
- Distinctive: line 47
If grill-with-docs exists but its grilling primitive is unavailable, perform the bounded requirements workflow in …
- Distinctive: line 48
If implement exists but tdd is unavailable, follow repository tests at pre-agreed seams and report that the dedicated TDD flow did not run.
- Distinctive: line 49
If code-review lacks its issue-tracker setup or cannot resolve a fixed point/spec, do not claim a complete two-axis review.
- Distinctive: line 61
Run grill-with-docs first only when its invocation gate is met.
- Distinctive: line 63
Do not proceed to architecture until the following are known or explicitly marked Unknown:
- Distinctive: line 84
Start with the simplest deployable architecture.
- Distinctive: line 112
Use architecture quality gates against the resulting system or plan.
- Distinctive: line 118
Keep authorization, financial truth, lifecycle transitions, limits, eligibility, and protected validation server-side.
- Distinctive: line 120
Keep controllers and widgets thin: translate input, invoke one use case, and map the result.
- Distinctive: line 121
Use explicit DTOs, stable machine error codes, bounded pagination, scoped queries, idempotency, and concurrency protection.
- Distinctive: line 122
Keep external calls outside critical database transactions.
- Distinctive: line 123
Treat secrets, tenant scope, sensitive fields, exports, uploads, audit, retention, and recovery as architecture concerns.
≈ “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.
Files
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.
| Mode | Use when | Required output |
| Quick | One bounded capability, small CRUD tool, or one architecture decision | Decision, owner, interface, trade-off, verification |
| Standard | Multi-app feature, admin workflow, or meaningful refactor | Capability map, ownership, representative flow, module/contracts, risks |
| Full audit | Platform redesign, migration, finance, compliance, multi-tenant authority, or an explicit audit request | All 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.
| Phase | Companion | Invoke when | Exit evidence |
| Requirements | grill-with-docs | The user explicitly invokes it or requests the complete discovery-to-delivery flow and requirements contain consequential unknowns | Agreed goals, actors, constraints, unresolved questions, glossary/ADRs where justified |
| Terminology | domain-modeling | Terms are overloaded, capability boundaries are unclear, code contradicts stated domain behavior, or the glossary must change | Canonical terms in CONTEXT.md; sparse ADRs for hard-to-reverse trade-offs |
| Architecture | 9am-archetecture | Requirements are sufficient to decide capability, application, data, contract, permission, deployment, or operational ownership | Architecture artifacts appropriate to the selected mode |
| Module internals | codebase-design | A module interface, seam, adapter, dependency direction, test surface, or deepening decision is material | Small interface, hidden complexity, explicit seam/adapters, test strategy |
| Coding | implement | The user explicitly authorizes implementation and an accepted spec or bounded ticket exists | Working code, tests, typechecks, and a committed change when the repository workflow permits |
| Verification | code-review | Code changed and a fixed point plus spec/standards source exists, or the user explicitly asks for a diff review | Separate Standards and Spec findings; architecture gates remain a separate report |
Invocation rules
- Do not run every companion merely because it is installed.
- 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.
- Never treat an architecture request as authorization to edit code, commit, open a PR, or change production state.
- Before implementation, record the accepted spec/ticket and the baseline commit or other fixed point. This gives code-review a valid comparison after implementation.
- 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.
- Preserve phase outputs. A later phase may refine an earlier decision, but must record the change and its reason instead of silently contradicting it.
- 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:
- business capability;
- application boundary;
- technical layer;
- deployment boundary;
- 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:
| Field | Content |
| Rule | One imperative decision |
| Purpose | Failure or cost prevented |
| Use when | Conditions that justify it |
| Do not use when | Simpler or different conditions |
| Trade-off | Complexity, latency, ownership, or delivery cost |
| Verification | Code, 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.
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
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.

