architecture-first

Featured

Decide the shape BEFORE the first file, and keep the boundaries honest afterwards: what the modules are, which way dependencies point, where state is owned, and what each module is allowed to know. Merges the layering rules (dependency rule, SOLID, component cohesion, Humble Object, entities vs use cases, frameworks-and-DB-as-details) with domain boundaries (ubiquitous language, bounded contexts, aggregates, domain events, repositories). Use when starting a project, service, site, API or new subsystem; when adding a feature that does not obviously belong to an existing module; when asked "where should this live", "how do we structure this", "what are the modules"; when writing an ARCHITECTURE.md or an ADR; when a dependency points the wrong way or a circular import appears. Do NOT use for a one-file script or a throwaway experiment, for a bug fix inside an existing seam, for word-level naming and function shape (use code-complexity), for splitting a module that is ALREADY too large (use refactoring-safely), o

AI & Automation 150 stars 24 forks Updated 3 days ago MIT

Install

View on GitHub

Quality Score: 88/100

Stars 20%
73
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

# Architecture first — the shape before the first file Most bad structure is not a bad decision. It is an absent one: code goes where the smallest diff puts it, and the smallest diff is always "next to the last thing". This skill exists to make the layout an explicit, cheap, early decision. ## Scope guard — read first Match the ceremony to the problem. Over-applying this is its own failure mode. | Situation | What this skill asks of you | |---|---| | Script, spike, one file, throwaway | Nothing. Skip. | | One module, <500 lines, one reason to change | Name the module and its one job. Stop. | | Service / site / API, several concerns | The full pre-code checklist below. | | Multiple teams or deployables, shared domain | Checklist + bounded-context map + one ADR per boundary | ## The one law **Dependencies point inward, toward policy.** Business rules must not import the web framework, the ORM, the queue, or the file layout. The reverse is required. Violating it silently is the failure — a violation that is written down, with the reason and the cost, is a decision. A violation nobody named is erosion. Practical test: *could this module be exercised by a test with no network, no database and no framework?* If not, something outer leaked inward. ## Pre-code checklist — before the first file 1. **Name the modules by reason to change**, not by technical layer. `queue`, `billing`, `catalog` — not `controllers`, `models`, `utils`. A module that changes for two unrelate...

Details

Author
AnastasiyaW
Repository
AnastasiyaW/codex-claude-code-config
Created
5 months ago
Last Updated
3 days ago
Language
Python
License
MIT

Bundled in these plugins

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Featured

architecture-quality

Keep web applications, APIs and services readable as they grow: choose feature or domain seams, assign state ownership, enforce dependency direction, keep adapters thin, and verify file shape. Use when starting or extending a web app, backend, frontend, API or multi-page product; when a change makes a module hard to read; when architecture review finds a god file, cross-feature imports, a circular dependency or a framework-heavy domain. Load architecture-first first for a new system, and refactoring-safely for an existing oversized module. Do not use for a one-file script, throwaway spike or a purely local naming change.

150 Updated 3 days ago
AnastasiyaW
AI & Automation Listed

architecture

Use for architecture decisions, module boundaries, coupling, layering, system shape.

1 Updated 1 weeks ago
kreek
AI & Automation Listed

architecture

Clean Architecture, Domain-Driven Design, and backend system-design guidance: organizing a codebase into layers with the right dependency direction, choosing structural design patterns (Repository, Strategy, Observer, Command, DI), applying DDD tactical patterns (entities vs value objects, aggregates), designing REST resources and status codes, persistence (unit-of-work, N+1), caching, domain events, layered error handling, and recording decisions as ADRs. Use when designing a new system or feature, deciding which layer code belongs in, refactoring a tangled/God-object codebase, reviewing coupling and boundaries, shaping an API, or writing an Architecture Decision Record.

5 Updated yesterday
nxtg-ai