architecture-quality

Featured

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.

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 quality — readable by construction This skill turns the architecture decision into a small, repeatable delivery contract. It complements `architecture-first`; it does not add layers for their own sake. ## Working contract Before a non-trivial web or service change, record these five facts in `ARCHITECTURE.md` or `docs/architecture/README.md`: 1. **Feature/domain modules** — name them by reason to change, not by a generic `utils`, `helpers` or `services` bucket. 2. **Ownership** — each mutable state, database table boundary and external side effect has one owner. 3. **Dependency direction** — policy/domain code is independent of the web framework, ORM, queue and filesystem; adapters point inward through small ports. 4. **Vertical slice** — prove one user-visible path from entry point to state and test before multiplying layers or pages. 5. **Verification boundary** — list the architecture checks and the test command that must remain green after the change. If the project is a small script or a single-module experiment, state that scope and skip the document. A missing document is a finding only once the project has enough shape to need one, not a reason to create ceremony around a toy. ## Web application shape - Keep routes/controllers thin: parse input, call a use-case or feature API, map the result and return. Do not put business policy, SQL and provider retries in a route. - Keep domain/use-case code framework-free where practical. Inj...

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-first

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

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
Web & Frontend Listed

software-architecture

Stack-agnostic software architecture guidance for any kind of software — game, desktop app, web/SPA, backend service, CLI. Picks the lightest macro structure and micro/runtime pattern for the problem, with per-domain examples, costs, and explicit "avoid when" guidance. Use when designing or refactoring an app's architecture, choosing how to layer or modularize code, drawing module/process boundaries (including IPC), managing dependencies and coupling, structuring state and persistence, handling errors/logging/config/async across boundaries, or when the user mentions layering, hexagonal/clean/onion, ports and adapters, dependency inversion, DDD, ECS, design patterns, state management, CQRS, or over-engineering.

3 Updated 2 days ago
Firzus