[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7C804E4XWQFZAHVSAJC9WF3":3,"skill-same:01M7C804E4XWQFZAHVSAJC9WF3":54},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":27,"commitSha":28,"skillDirectory":29,"forksCount":14,"repositoryHtmlUrl":30,"repositoryHomepageUrl":6,"ownerHtmlUrl":31,"ownerBlogUrl":6,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M7C804E4XWQFZAHVSAJC9WF3","design-code-architecture",null,"Guided journey from an app idea to a deliberate architecture: boundaries, domain model, data decisions, and resilience, making only the expensive-to-reverse decisions and deferring the rest. Orchestrates eight skills phase by phase - clean-architecture, domain-driven-design, system-design, ddia-systems, software-design-philosophy, release-it, pragmatic-programmer, 37signals-way - asking the user questions at every decision point and recording results in the project docs\u002F folder (ARCHITECTURE.md, DESIGN-CODE-ARCHITECTURE-PLAN.md) so the journey resumes across sessions. Use when the user wants to design a new app's architecture, choose boundaries and a domain model, decide monolith versus microservices, or says 'how should I structure this app'. If a codebase already exists, use remove-technical-debt (aged), improve-code-quality (fresh prototype), or architecture-optimization (slow but working); if unvalidated, run create-business or create-app first. For one framework in isolation, invoke that skill directly.","sung1-labs\u002Fsddx","sung1-labs","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F325716214?v=4","01M7C7MDYAWVBFW42T3YCQYG7N","SunG1 Labs","01M7C7MDYZYBYQ5FNSK0XN0YY2",0,"MIT","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Flibrary\u002Fai-skills\u002Fsddx-ai-design-code-architecture\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: design-code-architecture\ndescription: 'Guided journey from an app idea to a deliberate architecture: boundaries, domain model, data decisions, and resilience, making only the expensive-to-reverse decisions and deferring the rest. Orchestrates eight skills phase by phase - clean-architecture, domain-driven-design, system-design, ddia-systems, software-design-philosophy, release-it, pragmatic-programmer, 37signals-way - asking the user questions at every decision point and recording results in the project docs\u002F folder (ARCHITECTURE.md, DESIGN-CODE-ARCHITECTURE-PLAN.md) so the journey resumes across sessions. Use when the user wants to design a new app''s architecture, choose boundaries and a domain model, decide monolith versus microservices, or says ''how should I structure this app''. If a codebase already exists, use remove-technical-debt (aged), improve-code-quality (fresh prototype), or architecture-optimization (slow but working); if unvalidated, run create-business or create-app first. For one framework in isolation, invoke that skill directly.'\nlicense: MIT\nmetadata:\n  author: wondelai\n  version: \"1.0.2\"\n---\n\n# Design Code Architecture\n\nDesign the architecture for a new app: get the small number of expensive-to-reverse decisions right and stay aggressively simple everywhere else. This is an interactive, resumable journey of eight phases — the agent asks before every decision and records the outcome in your project's `docs\u002F` folder, so you can stop after any phase and resume later. It runs from the most foundational and hardest-to-reverse (boundaries, domain) through the tunable (data, resilience) to the cross-cutting disciplines (complexity, reversibility, scope) you apply throughout. A weekend project uses three phases lightly; a funded team building toward launch wants the whole stack.\n\n## Core Principle\n\n**Architecture is the set of decisions that are expensive to reverse: make exactly those deliberately, and defer everything cheap.** This skill sequences the phases, asks the decision questions, and records every choice in `docs\u002F`. The constituent skills carry the method — invoke them rather than improvising their frameworks. The whole strategy is to convert expensive decisions into cheap ones by putting a boundary in front of them, so the irreducibly expensive set stays small enough to get right with care.\n\n## Journey Map\n\n| Phase | Skill | Question it answers | Artifact |\n|---|---|---|---|\n| 1 | clean-architecture | Do source-code dependencies point inward — is the core testable with no DB, web, or framework? | Creates docs\u002FARCHITECTURE.md |\n| 2 | domain-driven-design | Where does the business actually split, and what does each term mean? | Extends docs\u002FARCHITECTURE.md |\n| 3 | system-design | How little system does our real load actually need? | Extends docs\u002FARCHITECTURE.md |\n| 4 | ddia-systems | Which data model, storage engine, and consistency does each workload need? | Extends docs\u002FARCHITECTURE.md |\n| 5 | software-design-philosophy | Is complexity hidden behind deep modules, or is this classitis? | Extends docs\u002FTECH-DEBT.md |\n| 6 | release-it | Will it degrade gracefully when a dependency is slow or down? | Creates docs\u002FRELIABILITY.md |\n| 7 | pragmatic-programmer | What thin slice proves the boundaries, and what habits keep them reversible? | Extends docs\u002FTESTING.md + docs\u002FTECH-DEBT.md |\n| 8 | 37signals-way | What is essential for v1, and what speculative abstraction do we cut? | Extends docs\u002FARCHITECTURE.md + docs\u002FTECH-DEBT.md |\n\n## Operating Rules\n\n1. **Resume first.** Before anything else, read `docs\u002FDESIGN-CODE-ARCHITECTURE-PLAN.md` and every artifact in the Journey Map. If the tracker exists, summarize the journey state in 3-5 lines and ask which phase to enter. Done when the user has confirmed an entry point. A journey with a tracker is resumed, never restarted.\n2. **Intake on first run only.** No tracker: run the Intake below, then create `docs\u002FDESIGN-CODE-ARCHITECTURE-PLAN.md` with every phase statused `pending | in-progress | awaiting-evidence | done | deferred: reason | skipped: reason`. Done when the tracker exists and the user has confirmed the phase plan.\n3. **Phase entry.** Announce: what the phase does, the decision it forces, the artifact it produces, rough effort. Offer proceed \u002F skip \u002F defer — phases marked GATE may be deferred, never skipped. Mark the phase `in-progress` on proceed. Done when the user chose.\n4. **Skill invocation and fallback.** Load the phase's skill and use it: each phase's Invoke line names the skill by slug — use that skill to run the phase. If it is not available, offer: `npx skills add wondelai\u002Fskills\u002F\u003Cslug> --global`. If the user declines, run the phase from its Brief — the minimum viable method. State which mode you are in.\n5. **In-phase decisions.** Ask every question under \"Decide with the user\" — with concrete options and your recommendation. Record the choice in the tracker's Key Decisions. A decision made silently is a defect.\n6. **Phase exit.** Present the draft artifact content for sign-off before writing. On approval: write or extend the docs\u002F files, update the tracker (status, Key Decisions, Next Actions). Done when the files are written and the phase row shows `done`.\n7. **Artifact discipline.** Read before writing; create a file only if missing, otherwise extend — add or update your sections, preserve everyone else's. Files are UPPERCASE in `docs\u002F`. Every recommendation lands as a checkbox or a table row with owner and priority. See [references\u002Fartifact-templates.md](references\u002Fartifact-templates.md) when creating a docs\u002F file for the first time — create it from the full skeleton (all section headings), then fill the sections your phase names.\n8. **Every expensive-to-reverse decision gets a Decision Log row (decision, why, alternatives rejected) before any code assumes it.** Default to a modular monolith: services split only along proven bounded contexts.\n\n## Intake\n\nAsk these before creating the tracker:\n\n1. What will the app do, and what is the one feature that is genuinely your competitive advantage? (frames the core subdomain in Phase 2 — where to invest deep modeling versus buy off-the-shelf)\n2. What stack are you leaning toward — language, web framework, ORM, database? (gates the Phase 1 boundary and Phase 4 data decisions; treated as a detail, never the skeleton)\n3. What load is realistic in year one — rough daily active users and the main actions each takes? (gates Phase 3 sizing: requirements before solutions)\n4. What outbound dependencies will it call — payments, email, LLM APIs, shipping, queues? (gates the Phase 6 integration-point audit)\n5. Which data is the system of record, and are there second read patterns like search, analytics, or feeds? (gates Phase 4 consistency and derived-data decisions)\n6. Has anyone validated that people actually want this app? (if not, route to create-business \u002F create-app first — do not architect an unvalidated idea)\n7. How many teams will own this system, and how much of the journey do you want now? (gates the team-topologies optional phase and the Phase 8 appetite)\n\nPhase-skip heuristics: skip Phase 3's scaling machinery and most of Phase 4's replication when year-one load is far below any threshold (a single indexed DB is the answer — record it and move on); skip the team-topologies optional phase for a single-team app. Never skip Phase 1 or Phase 2 — boundaries and the domain model are the additive work that makes every later decision cheap; Phase 6 resilience is not optional once real users and outbound calls exist. Then create the tracker from the template and confirm the plan.\n\nDone when `docs\u002FDESIGN-CODE-ARCHITECTURE-PLAN.md` exists with every phase statused and the user has confirmed the plan.\n\n## Phases\n\nPhases run in the listed order, from hardest-to-reverse to tunable to cross-cutting — each assumes the previous phase's artifact exists. Any phase can be entered, skipped, or deferred per the Operating Rules; Phases 1-2 are the additive work that makes everything after them cheap to change.\n\nThe phases form a dependency chain that mirrors the system: Domain-Driven Design says *where* the boundaries belong (contexts and aggregate seams); Clean Architecture says *which way* dependencies cross them; Data-Intensive Apps decides what lives inside them at the persistence layer; System Design says how much infrastructure that actually requires — usually far less than feared. Software Design keeps the modules deep instead of multiplying into shallow ceremony, Release It! hardens the integration points, Pragmatic Programmer supplies the cross-cutting habits that hold the structure over time, and the 37signals Way governs the whole thing by fixing time and cutting scope.\n\n### Phase 1 — Draw the boundaries (clean-architecture)\n\n**Purpose:** Keep business rules independent of the framework, database, and vendors so every later decision stays swappable — the move that buys back all the others.\n\n**Brief (fallback):** The Dependency Rule — source-code dependencies point inward: Frameworks → Interface Adapters → Use Cases → Entities; nothing inner names anything outer. Database, web, and vendors are details, plugins to your rules. Enforce with Dependency Inversion: a use case owns a repository interface; the Postgres\u002FStripe implementation lives in an outer adapter. Draw full boundaries only at real volatility (DB, external services, delivery); collapse layers elsewhere — direction matters, not folder count.\n\n**Invoke:** Use the `clean-architecture` skill with a concrete first feature and the stack from intake. Ask it to layer that feature (entities, a use case with request\u002Fresponse models, repository + gateway interfaces, the HTTP controller and DB adapter in the outer ring), and to flag which boundaries are ceremony versus earning their cost at real volatility.\n\n**Decide with the user:** (1) Modular monolith versus services — default to a modular monolith with clean internal boundaries; a microservice with a shared data model is a distributed monolith, strictly worse. (2) Which volatility points get full boundaries with interfaces now versus collapsed layers.\n\n**Artifact:** Create docs\u002FARCHITECTURE.md with `## System Context` (what it does, integrations), `## Layer Map & Dependency Rule` (layers, what depends on what; violation | location | fix | status), and the monolith-versus-services choice in `## Decision Log` (date | decision | why | alternatives rejected). Update the tracker.\n\n**Done when:** the layer map exists, the first feature is layered with framework\u002FORM types confined to the outer ring, the core is designed to test with no DB\u002Fweb\u002Fframework, the monolith-versus-services decision is a Decision Log row, and Phase 1 shows `done`.\n\n### Phase 2 — Model the domain (domain-driven-design)\n\n**Purpose:** Put boundaries where the business actually splits and make the code speak the domain — cheapest now, inventing the vocabulary from a blank page.\n\n**Brief (fallback):** The model is the code — build a Ubiquitous Language so team words are code words. Name after domain concepts (`Order.place()`, not `OrderManager.process()`); a name that resists is a design signal, not an annoyance. Bounded contexts: a region where a word means exactly one thing (\"Customer\" differs in billing versus support) — these are your future service seams. Aggregates: a small root cluster enforcing invariants, immediately consistent inside and eventually consistent outside; reference other aggregates by ID. Push behavior into entities — no anemic data bags.\n\n**Invoke:** Use the `domain-driven-design` skill with the domain vocabulary and the Phase 1 layer map. Ask for the bounded-context map built from the words the team actually uses, the core aggregates with their invariants, and a subdomain classification (core \u002F supporting \u002F generic).\n\n**Decide with the user:** (1) Where the same word legitimately means different things across contexts — do NOT unify into one omniscient model. (2) Which subdomain is core (invest deep modeling) versus generic (buy or use OSS — auth, email, payments).\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md: `## Bounded Contexts & Context Map` (contexts, relationships, anti-corruption layers) and `## Domain Glossary (Ubiquitous Language)` (term | meaning | code name); record aggregate and core-domain choices in `## Decision Log`. Update the tracker.\n\n**Done when:** contexts are mapped with their relationships, the glossary names the core terms, each aggregate states its invariants and by-ID references, the core subdomain is chosen, and the context boundaries line up with the Phase 1 layer map.\n\n### Phase 3 — Size the system honestly (system-design)\n\n**Purpose:** Prove with numbers how small the system can be, so you skip the machinery you cannot justify.\n\n**Brief (fallback):** Start with requirements, not solutions. Back-of-envelope: QPS = daily-active-users × actions\u002Fday ÷ 86,400, peak 2-5× average; storage = records\u002Fday × size × retention. For hundreds-to-thousands of users, a single indexed DB plus a read-path cache carries you a long time. Scale in order: vertical first, then cache-aside (TTL + explicit invalidation), then read replicas, and shard last, only with evidence. Reach for a message queue to decouple slow\u002Fspiky work, a CDN for global static assets. Premature sharding and premature service-splitting are named mistakes.\n\n**Invoke:** Use the `system-design` skill with the load reality from intake. Ask for average and peak QPS, yearly storage, which component bottlenecks first, and a plain list of the techniques (sharding, replicas, CDN, queues, multi-region) you do NOT need yet.\n\n**Decide with the user:** Which scaling moves to make now versus defer — tied to the numbers (don't build for 50k users while at 50) — and the first slow workload, if any, to move behind a message queue.\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md `## System Context` with the load reality and back-of-envelope numbers; record each scaling move (adopt now \u002F defer with trigger) in `## Decision Log`. Update the tracker.\n\n**Done when:** average\u002Fpeak QPS and yearly storage are written down, the first bottleneck is named, and every scaling technique is either adopted with a reason or deferred with the number that would trigger it.\n\n### Phase 4 — Make deliberate data decisions (ddia-systems)\n\n**Purpose:** Get the layer that outlives the code right — data model, storage engine, and consistency chosen by access pattern, not habit.\n\n**Brief (fallback):** Data outlives code. Match model to access pattern — relational for many-to-many and ad-hoc queries, document for self-contained aggregates with locality, graph for recursive traversals; storage engines trade reads against writes (LSM write-throughput versus B-tree read-latency). Most databases default to read-committed or snapshot, NOT serializable — naive read-then-write triggers write skew (two buyers taking the last unit). Lock explicitly (`SELECT ... FOR UPDATE`) or use a serializable transaction where invariants demand it. Single-leader + read replicas is the read-heavy default; replication lag forces deliberate read-your-writes. Separate system-of-record from rebuildable derived data.\n\n**Invoke:** Use the `ddia-systems` skill with the workloads implied by the Phase 2 aggregates and the Phase 3 replica plan. Ask for a per-workload model + storage-engine fit, the actual default isolation level and its anomalies, and which read-then-write paths need locking.\n\n**Decide with the user:** (1) One datastore versus polyglot persistence, per workload fit. (2) Which paths get a lock or serializable transaction versus tolerate eventual consistency; whether a second read pattern (search, analytics) justifies derived data kept in sync by CDC.\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md `## Data & Storage Decisions` (models, engines, isolation level, locked paths, system-of-record versus derived) and log the reasoning in `## Decision Log`. Update the tracker.\n\n**Done when:** each workload has a model + engine chosen by fit, the default isolation level is documented, every write-skew-prone path is locked or serializable, and any derived data has a defined sync mechanism.\n\n### Phase 5 — Keep modules deep (software-design-philosophy)\n\n**Purpose:** Stop the structure from becoming its own disease — hide machinery behind simple interfaces instead of shattering into shallow classes.\n\n**Brief (fallback):** Complexity is the enemy; the test for every decision is whether it makes the whole system simpler. Module depth = functionality ÷ interface complexity — deep modules hide power behind small interfaces; shallow ones (classitis) add interface cost without hiding complexity. Clean layering and deep modules are allies; clean layering and classitis are not. Information leakage — one design decision reflected in many modules — is a top red flag; encapsulate each piece of knowledge once. Strategic over tactical: invest 10-20% to keep the design clean; startup shortcuts compound into debt as the team grows.\n\n**Invoke:** Use the `software-design-philosophy` skill with the module set proposed in Phases 1-2. Ask which modules are shallow pass-throughs to consolidate, where knowledge leaks across boundaries, and whether any planned boundary is ceremony rather than depth.\n\n**Decide with the user:** Which shallow modules to consolidate into deeper ones now, guarding against over-merging genuinely unrelated concerns; the design conventions the team adopts (naming, where behavior lives, one file per piece of knowledge).\n\n**Artifact:** Extend docs\u002FTECH-DEBT.md `## Smell Inventory` (shallow-module \u002F information-leakage entries with the consolidation applied) and record the agreed rules under `## Adopted Conventions`. Update the tracker.\n\n**Done when:** each shallow-module cluster is consolidated or logged with a fix, no single design decision is duplicated across modules, and the design conventions are written down.\n\n### Phase 6 — Design for failure (release-it)\n\n**Purpose:** Make the system degrade gracefully instead of collapsing when a dependency is slow or down — cheapest to design in now, not at 2 a.m.\n\n**Brief (fallback):** The software that passes QA is not what survives production. Integration points are the number-one killer and a slow response is worse than none — a hanging dependency exhausts threads and pools with nothing in the logs. Non-negotiable: connect + read timeouts on every outbound call; a circuit breaker on critical ones (trips open, fails fast, half-open recovery); bulkheads to isolate pools per dependency; retry with backoff + jitter. Paginate every list endpoint (unbounded result sets crash under real data); schedule steady-state cleanup. Decouple deploy from release with feature flags and backward-compatible expand-contract migrations.\n\n**Invoke:** Use the `release-it` skill with the outbound dependencies from intake. Ask for timeout values and breaker thresholds per dependency, bulkhead placement, a graceful-degradation path per integration, and the deep-health-check + RED-metrics + expand-contract-migration essentials.\n\n**Decide with the user:** Breaker thresholds, which dependencies get dedicated pools, how core flows degrade when a non-critical dependency is down, and the rollback path you trust. Resist chaos engineering \u002F multi-region failover for the first thousand users.\n\n**Artifact:** Create docs\u002FRELIABILITY.md with `## Integration-Point Audit` (dependency | timeout | circuit breaker | bulkhead | retry policy | status), `## Query & Resource Findings`, `## Health Checks & Metrics`, and `## Deploy vs Release`. Update the tracker.\n\n**Done when:** every planned outbound call has a timeout, critical dependencies have breakers and bulkheads, every list endpoint is paginated, a deep health check + RED metrics + expand-contract migration + trusted rollback are specified, and the audit has no open rows for critical paths.\n\n### Phase 7 — Prove the wiring and lock in habits (pragmatic-programmer)\n\n**Purpose:** Build one thin real slice through every layer to prove the boundaries connect, and set the habits that keep the architecture reversible.\n\n**Brief (fallback):** Tracer bullet — build one thin but fully real vertical slice (HTTP → use case → repository → DB → back), kept as production code, for end-to-end feedback on day two and proof the boundaries link before you flesh them out. Reversibility: abstract every vendor behind your own interface (forking-road test — could you swap DB or LLM provider in a week?). Orthogonality: a dramatic change to one requirement should touch one module. DRY for knowledge, not coincidence — merge duplicated rules, leave look-alikes alone. Broken Window: fix the first hack or board it up with a tracked ticket.\n\n**Invoke:** Use the `pragmatic-programmer` skill with the Phase 1 boundaries. Ask for the thinnest end-to-end tracer bullet that exercises every layer, an adapter interface for each vendor, and an audit of where one change would touch many modules or a vendor API would leak into business logic.\n\n**Decide with the user:** Which slice is the tracer bullet (one authenticated core action, minimal functionality); the broken-windows policy and debt budget per iteration; which vendors get an owned interface first.\n\n**Artifact:** Extend docs\u002FTESTING.md `## Test Strategy`, `## Safety Net Map` (the tracer-bullet path as the first end-to-end test), and `## CI Gates`; extend docs\u002FTECH-DEBT.md `## Debt Budget & Broken-Windows Policy` and `## Adopted Conventions` (reversibility, orthogonality). Update the tracker.\n\n**Done when:** the tracer-bullet slice runs end-to-end through every layer and is pinned as the first CI gate, each vendor sits behind an owned interface, and the broken-windows policy and debt budget are written down.\n\n### Phase 8 — Cut scope to the essential (37signals-way)\n\n**Purpose:** Decide whether any of this ships — fix time, flex scope, and delete speculative abstraction before it becomes complexity you carry.\n\n**Brief (fallback):** Build less — the best products do fewer things well; half a product beats a half-assed one. Fix an appetite (the time this work is genuinely worth) and cut scope to fit, rather than estimating an open-ended architecture that balloons. YAGNI: every speculative abstraction (generic plugin system, event sourcing, configurable multi-tenancy for zero users) is a decision deferred to an imaginary future at the cost of present complexity. Make tiny reversible decisions; say no by default so the great decisions breathe. Never cut the small set of expensive-to-reverse decisions.\n\n**Invoke:** Use the `37signals-way` skill with the full architecture plan from Phases 1-7. Ask it to shape the work into a fixed appetite, separate essential-for-launch from gold-plating, name the rabbit holes, and list the speculative abstractions to delete or replace with the simplest thing that could work.\n\n**Decide with the user:** The appetite for v1 architecture work; which abstractions to cut now, defer with a revisit trigger, or replace with the simplest thing; confirm no expensive-to-reverse decision is being cut just to save time.\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md `## Decision Log` with what is deliberately NOT built for v1; extend docs\u002FTECH-DEBT.md `## Debt Ledger` (deferred abstractions as deliberately-taken debt, each with the trigger that would revisit it). Update the tracker.\n\n**Done when:** v1 scope is fixed to an appetite, every cut or deferred abstraction is a Decision Log or Debt Ledger row with a revisit trigger, and no expensive-to-reverse decision was cut for time.\n\n## Optional Phases\n\n| Skill | Add when | Artifact |\n|---|---|---|\n| team-topologies | More than one team will own the system, so module boundaries must align with team boundaries (Conway) | Extends docs\u002FOPERATIONS.md (`## Team Structure`) |\n\nOptional phases follow the same operating rules — load and use each listed skill exactly as a core phase would; insert where the Add-when condition first becomes true — here, right after Phase 2, once the bounded contexts that team boundaries must mirror exist.\n\n## Common Mistakes\n\n| Mistake | Fix |\n|---|---|\n| Letting the framework be the architecture | Apply Clean Architecture's Dependency Rule (Phase 1) — framework calls inward; ORM and request types stay confined to the outer ring. |\n| Over-engineering for scale you cannot prove you need | Run back-of-envelope QPS\u002Fstorage math first (system-design, Phase 3); one indexed DB plus a cache is usually years of runway. |\n| Over-correcting into classitis | Apply the deep-module rule (software-design-philosophy, Phase 5) — a few deep modules beat a swarm of shallow ones; boundaries at real volatility only. |\n| Ignoring the database's actual consistency guarantees | Check the default isolation level and lock write-skew-prone paths (ddia-systems, Phase 4) — write skew passes every single-user test. |\n| Treating resilience as a post-launch concern | Design timeouts, breakers, and pagination in from the start (release-it, Phase 6) — a slow dependency with no timeout freezes everything. |\n| Confusing build-less with build-carelessly | Cut features and speculative abstractions (37signals-way, Phase 8), never the small set of expensive-to-reverse decisions. |\n\n## Completing the Journey\n\nMatch the dose to the project: a weekend build leans on the Phase 1 Dependency Rule, a quick Ubiquitous Language, timeouts on outbound calls, and the Phase 8 instinct to cut scope — a few hours that save weeks. A funded team building toward launch works the whole stack, pulling the data and resilience phases in as real bottlenecks and integration points appear.\n\nExit checklist — every box tied to an artifact:\n\n- [ ] Each expensive-to-reverse decision (boundaries, contexts, data\u002Fconsistency) is a Decision Log row with alternatives rejected (ARCHITECTURE.md).\n- [ ] Core business rules are designed to run with no DB, web, or framework (ARCHITECTURE.md Layer Map, no inward-pointing violations).\n- [ ] Every outbound call has a timeout, critical ones have breakers, and every list is paginated (RELIABILITY.md Integration-Point Audit clear).\n- [ ] A tracer-bullet slice proves the boundaries connect end-to-end and is the first CI gate (TESTING.md).\n- [ ] v1 scope is fixed to an appetite with speculative abstractions cut or deferred with a trigger (TECH-DEBT.md Debt Ledger).\n\nClose the tracker: every phase `done` or `skipped: reason`, with remaining Next Actions carried into the ARCHITECTURE.md Decision Log and TECH-DEBT.md so nothing is lost. Then route forward: when the architecture serves a product that still needs validating and building, continue with the `create-app` skill; when an existing prototype must be brought up to this structure, continue with the `improve-code-quality` skill.\n","# Design Code Architecture\n\nDesign the architecture for a new app: get the small number of expensive-to-reverse decisions right and stay aggressively simple everywhere else. This is an interactive, resumable journey of eight phases — the agent asks before every decision and records the outcome in your project's `docs\u002F` folder, so you can stop after any phase and resume later. It runs from the most foundational and hardest-to-reverse (boundaries, domain) through the tunable (data, resilience) to the cross-cutting disciplines (complexity, reversibility, scope) you apply throughout. A weekend project uses three phases lightly; a funded team building toward launch wants the whole stack.\n\n## Core Principle\n\n**Architecture is the set of decisions that are expensive to reverse: make exactly those deliberately, and defer everything cheap.** This skill sequences the phases, asks the decision questions, and records every choice in `docs\u002F`. The constituent skills carry the method — invoke them rather than improvising their frameworks. The whole strategy is to convert expensive decisions into cheap ones by putting a boundary in front of them, so the irreducibly expensive set stays small enough to get right with care.\n\n## Journey Map\n\n| Phase | Skill | Question it answers | Artifact |\n|---|---|---|---|\n| 1 | clean-architecture | Do source-code dependencies point inward — is the core testable with no DB, web, or framework? | Creates docs\u002FARCHITECTURE.md |\n| 2 | domain-driven-design | Where does the business actually split, and what does each term mean? | Extends docs\u002FARCHITECTURE.md |\n| 3 | system-design | How little system does our real load actually need? | Extends docs\u002FARCHITECTURE.md |\n| 4 | ddia-systems | Which data model, storage engine, and consistency does each workload need? | Extends docs\u002FARCHITECTURE.md |\n| 5 | software-design-philosophy | Is complexity hidden behind deep modules, or is this classitis? | Extends docs\u002FTECH-DEBT.md |\n| 6 | release-it | Will it degrade gracefully when a dependency is slow or down? | Creates docs\u002FRELIABILITY.md |\n| 7 | pragmatic-programmer | What thin slice proves the boundaries, and what habits keep them reversible? | Extends docs\u002FTESTING.md + docs\u002FTECH-DEBT.md |\n| 8 | 37signals-way | What is essential for v1, and what speculative abstraction do we cut? | Extends docs\u002FARCHITECTURE.md + docs\u002FTECH-DEBT.md |\n\n## Operating Rules\n\n1. **Resume first.** Before anything else, read `docs\u002FDESIGN-CODE-ARCHITECTURE-PLAN.md` and every artifact in the Journey Map. If the tracker exists, summarize the journey state in 3-5 lines and ask which phase to enter. Done when the user has confirmed an entry point. A journey with a tracker is resumed, never restarted.\n2. **Intake on first run only.** No tracker: run the Intake below, then create `docs\u002FDESIGN-CODE-ARCHITECTURE-PLAN.md` with every phase statused `pending | in-progress | awaiting-evidence | done | deferred: reason | skipped: reason`. Done when the tracker exists and the user has confirmed the phase plan.\n3. **Phase entry.** Announce: what the phase does, the decision it forces, the artifact it produces, rough effort. Offer proceed \u002F skip \u002F defer — phases marked GATE may be deferred, never skipped. Mark the phase `in-progress` on proceed. Done when the user chose.\n4. **Skill invocation and fallback.** Load the phase's skill and use it: each phase's Invoke line names the skill by slug — use that skill to run the phase. If it is not available, offer: `npx skills add wondelai\u002Fskills\u002F\u003Cslug> --global`. If the user declines, run the phase from its Brief — the minimum viable method. State which mode you are in.\n5. **In-phase decisions.** Ask every question under \"Decide with the user\" — with concrete options and your recommendation. Record the choice in the tracker's Key Decisions. A decision made silently is a defect.\n6. **Phase exit.** Present the draft artifact content for sign-off before writing. On approval: write or extend the docs\u002F files, update the tracker (status, Key Decisions, Next Actions). Done when the files are written and the phase row shows `done`.\n7. **Artifact discipline.** Read before writing; create a file only if missing, otherwise extend — add or update your sections, preserve everyone else's. Files are UPPERCASE in `docs\u002F`. Every recommendation lands as a checkbox or a table row with owner and priority. See [references\u002Fartifact-templates.md](references\u002Fartifact-templates.md) when creating a docs\u002F file for the first time — create it from the full skeleton (all section headings), then fill the sections your phase names.\n8. **Every expensive-to-reverse decision gets a Decision Log row (decision, why, alternatives rejected) before any code assumes it.** Default to a modular monolith: services split only along proven bounded contexts.\n\n## Intake\n\nAsk these before creating the tracker:\n\n1. What will the app do, and what is the one feature that is genuinely your competitive advantage? (frames the core subdomain in Phase 2 — where to invest deep modeling versus buy off-the-shelf)\n2. What stack are you leaning toward — language, web framework, ORM, database? (gates the Phase 1 boundary and Phase 4 data decisions; treated as a detail, never the skeleton)\n3. What load is realistic in year one — rough daily active users and the main actions each takes? (gates Phase 3 sizing: requirements before solutions)\n4. What outbound dependencies will it call — payments, email, LLM APIs, shipping, queues? (gates the Phase 6 integration-point audit)\n5. Which data is the system of record, and are there second read patterns like search, analytics, or feeds? (gates Phase 4 consistency and derived-data decisions)\n6. Has anyone validated that people actually want this app? (if not, route to create-business \u002F create-app first — do not architect an unvalidated idea)\n7. How many teams will own this system, and how much of the journey do you want now? (gates the team-topologies optional phase and the Phase 8 appetite)\n\nPhase-skip heuristics: skip Phase 3's scaling machinery and most of Phase 4's replication when year-one load is far below any threshold (a single indexed DB is the answer — record it and move on); skip the team-topologies optional phase for a single-team app. Never skip Phase 1 or Phase 2 — boundaries and the domain model are the additive work that makes every later decision cheap; Phase 6 resilience is not optional once real users and outbound calls exist. Then create the tracker from the template and confirm the plan.\n\nDone when `docs\u002FDESIGN-CODE-ARCHITECTURE-PLAN.md` exists with every phase statused and the user has confirmed the plan.\n\n## Phases\n\nPhases run in the listed order, from hardest-to-reverse to tunable to cross-cutting — each assumes the previous phase's artifact exists. Any phase can be entered, skipped, or deferred per the Operating Rules; Phases 1-2 are the additive work that makes everything after them cheap to change.\n\nThe phases form a dependency chain that mirrors the system: Domain-Driven Design says *where* the boundaries belong (contexts and aggregate seams); Clean Architecture says *which way* dependencies cross them; Data-Intensive Apps decides what lives inside them at the persistence layer; System Design says how much infrastructure that actually requires — usually far less than feared. Software Design keeps the modules deep instead of multiplying into shallow ceremony, Release It! hardens the integration points, Pragmatic Programmer supplies the cross-cutting habits that hold the structure over time, and the 37signals Way governs the whole thing by fixing time and cutting scope.\n\n### Phase 1 — Draw the boundaries (clean-architecture)\n\n**Purpose:** Keep business rules independent of the framework, database, and vendors so every later decision stays swappable — the move that buys back all the others.\n\n**Brief (fallback):** The Dependency Rule — source-code dependencies point inward: Frameworks → Interface Adapters → Use Cases → Entities; nothing inner names anything outer. Database, web, and vendors are details, plugins to your rules. Enforce with Dependency Inversion: a use case owns a repository interface; the Postgres\u002FStripe implementation lives in an outer adapter. Draw full boundaries only at real volatility (DB, external services, delivery); collapse layers elsewhere — direction matters, not folder count.\n\n**Invoke:** Use the `clean-architecture` skill with a concrete first feature and the stack from intake. Ask it to layer that feature (entities, a use case with request\u002Fresponse models, repository + gateway interfaces, the HTTP controller and DB adapter in the outer ring), and to flag which boundaries are ceremony versus earning their cost at real volatility.\n\n**Decide with the user:** (1) Modular monolith versus services — default to a modular monolith with clean internal boundaries; a microservice with a shared data model is a distributed monolith, strictly worse. (2) Which volatility points get full boundaries with interfaces now versus collapsed layers.\n\n**Artifact:** Create docs\u002FARCHITECTURE.md with `## System Context` (what it does, integrations), `## Layer Map & Dependency Rule` (layers, what depends on what; violation | location | fix | status), and the monolith-versus-services choice in `## Decision Log` (date | decision | why | alternatives rejected). Update the tracker.\n\n**Done when:** the layer map exists, the first feature is layered with framework\u002FORM types confined to the outer ring, the core is designed to test with no DB\u002Fweb\u002Fframework, the monolith-versus-services decision is a Decision Log row, and Phase 1 shows `done`.\n\n### Phase 2 — Model the domain (domain-driven-design)\n\n**Purpose:** Put boundaries where the business actually splits and make the code speak the domain — cheapest now, inventing the vocabulary from a blank page.\n\n**Brief (fallback):** The model is the code — build a Ubiquitous Language so team words are code words. Name after domain concepts (`Order.place()`, not `OrderManager.process()`); a name that resists is a design signal, not an annoyance. Bounded contexts: a region where a word means exactly one thing (\"Customer\" differs in billing versus support) — these are your future service seams. Aggregates: a small root cluster enforcing invariants, immediately consistent inside and eventually consistent outside; reference other aggregates by ID. Push behavior into entities — no anemic data bags.\n\n**Invoke:** Use the `domain-driven-design` skill with the domain vocabulary and the Phase 1 layer map. Ask for the bounded-context map built from the words the team actually uses, the core aggregates with their invariants, and a subdomain classification (core \u002F supporting \u002F generic).\n\n**Decide with the user:** (1) Where the same word legitimately means different things across contexts — do NOT unify into one omniscient model. (2) Which subdomain is core (invest deep modeling) versus generic (buy or use OSS — auth, email, payments).\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md: `## Bounded Contexts & Context Map` (contexts, relationships, anti-corruption layers) and `## Domain Glossary (Ubiquitous Language)` (term | meaning | code name); record aggregate and core-domain choices in `## Decision Log`. Update the tracker.\n\n**Done when:** contexts are mapped with their relationships, the glossary names the core terms, each aggregate states its invariants and by-ID references, the core subdomain is chosen, and the context boundaries line up with the Phase 1 layer map.\n\n### Phase 3 — Size the system honestly (system-design)\n\n**Purpose:** Prove with numbers how small the system can be, so you skip the machinery you cannot justify.\n\n**Brief (fallback):** Start with requirements, not solutions. Back-of-envelope: QPS = daily-active-users × actions\u002Fday ÷ 86,400, peak 2-5× average; storage = records\u002Fday × size × retention. For hundreds-to-thousands of users, a single indexed DB plus a read-path cache carries you a long time. Scale in order: vertical first, then cache-aside (TTL + explicit invalidation), then read replicas, and shard last, only with evidence. Reach for a message queue to decouple slow\u002Fspiky work, a CDN for global static assets. Premature sharding and premature service-splitting are named mistakes.\n\n**Invoke:** Use the `system-design` skill with the load reality from intake. Ask for average and peak QPS, yearly storage, which component bottlenecks first, and a plain list of the techniques (sharding, replicas, CDN, queues, multi-region) you do NOT need yet.\n\n**Decide with the user:** Which scaling moves to make now versus defer — tied to the numbers (don't build for 50k users while at 50) — and the first slow workload, if any, to move behind a message queue.\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md `## System Context` with the load reality and back-of-envelope numbers; record each scaling move (adopt now \u002F defer with trigger) in `## Decision Log`. Update the tracker.\n\n**Done when:** average\u002Fpeak QPS and yearly storage are written down, the first bottleneck is named, and every scaling technique is either adopted with a reason or deferred with the number that would trigger it.\n\n### Phase 4 — Make deliberate data decisions (ddia-systems)\n\n**Purpose:** Get the layer that outlives the code right — data model, storage engine, and consistency chosen by access pattern, not habit.\n\n**Brief (fallback):** Data outlives code. Match model to access pattern — relational for many-to-many and ad-hoc queries, document for self-contained aggregates with locality, graph for recursive traversals; storage engines trade reads against writes (LSM write-throughput versus B-tree read-latency). Most databases default to read-committed or snapshot, NOT serializable — naive read-then-write triggers write skew (two buyers taking the last unit). Lock explicitly (`SELECT ... FOR UPDATE`) or use a serializable transaction where invariants demand it. Single-leader + read replicas is the read-heavy default; replication lag forces deliberate read-your-writes. Separate system-of-record from rebuildable derived data.\n\n**Invoke:** Use the `ddia-systems` skill with the workloads implied by the Phase 2 aggregates and the Phase 3 replica plan. Ask for a per-workload model + storage-engine fit, the actual default isolation level and its anomalies, and which read-then-write paths need locking.\n\n**Decide with the user:** (1) One datastore versus polyglot persistence, per workload fit. (2) Which paths get a lock or serializable transaction versus tolerate eventual consistency; whether a second read pattern (search, analytics) justifies derived data kept in sync by CDC.\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md `## Data & Storage Decisions` (models, engines, isolation level, locked paths, system-of-record versus derived) and log the reasoning in `## Decision Log`. Update the tracker.\n\n**Done when:** each workload has a model + engine chosen by fit, the default isolation level is documented, every write-skew-prone path is locked or serializable, and any derived data has a defined sync mechanism.\n\n### Phase 5 — Keep modules deep (software-design-philosophy)\n\n**Purpose:** Stop the structure from becoming its own disease — hide machinery behind simple interfaces instead of shattering into shallow classes.\n\n**Brief (fallback):** Complexity is the enemy; the test for every decision is whether it makes the whole system simpler. Module depth = functionality ÷ interface complexity — deep modules hide power behind small interfaces; shallow ones (classitis) add interface cost without hiding complexity. Clean layering and deep modules are allies; clean layering and classitis are not. Information leakage — one design decision reflected in many modules — is a top red flag; encapsulate each piece of knowledge once. Strategic over tactical: invest 10-20% to keep the design clean; startup shortcuts compound into debt as the team grows.\n\n**Invoke:** Use the `software-design-philosophy` skill with the module set proposed in Phases 1-2. Ask which modules are shallow pass-throughs to consolidate, where knowledge leaks across boundaries, and whether any planned boundary is ceremony rather than depth.\n\n**Decide with the user:** Which shallow modules to consolidate into deeper ones now, guarding against over-merging genuinely unrelated concerns; the design conventions the team adopts (naming, where behavior lives, one file per piece of knowledge).\n\n**Artifact:** Extend docs\u002FTECH-DEBT.md `## Smell Inventory` (shallow-module \u002F information-leakage entries with the consolidation applied) and record the agreed rules under `## Adopted Conventions`. Update the tracker.\n\n**Done when:** each shallow-module cluster is consolidated or logged with a fix, no single design decision is duplicated across modules, and the design conventions are written down.\n\n### Phase 6 — Design for failure (release-it)\n\n**Purpose:** Make the system degrade gracefully instead of collapsing when a dependency is slow or down — cheapest to design in now, not at 2 a.m.\n\n**Brief (fallback):** The software that passes QA is not what survives production. Integration points are the number-one killer and a slow response is worse than none — a hanging dependency exhausts threads and pools with nothing in the logs. Non-negotiable: connect + read timeouts on every outbound call; a circuit breaker on critical ones (trips open, fails fast, half-open recovery); bulkheads to isolate pools per dependency; retry with backoff + jitter. Paginate every list endpoint (unbounded result sets crash under real data); schedule steady-state cleanup. Decouple deploy from release with feature flags and backward-compatible expand-contract migrations.\n\n**Invoke:** Use the `release-it` skill with the outbound dependencies from intake. Ask for timeout values and breaker thresholds per dependency, bulkhead placement, a graceful-degradation path per integration, and the deep-health-check + RED-metrics + expand-contract-migration essentials.\n\n**Decide with the user:** Breaker thresholds, which dependencies get dedicated pools, how core flows degrade when a non-critical dependency is down, and the rollback path you trust. Resist chaos engineering \u002F multi-region failover for the first thousand users.\n\n**Artifact:** Create docs\u002FRELIABILITY.md with `## Integration-Point Audit` (dependency | timeout | circuit breaker | bulkhead | retry policy | status), `## Query & Resource Findings`, `## Health Checks & Metrics`, and `## Deploy vs Release`. Update the tracker.\n\n**Done when:** every planned outbound call has a timeout, critical dependencies have breakers and bulkheads, every list endpoint is paginated, a deep health check + RED metrics + expand-contract migration + trusted rollback are specified, and the audit has no open rows for critical paths.\n\n### Phase 7 — Prove the wiring and lock in habits (pragmatic-programmer)\n\n**Purpose:** Build one thin real slice through every layer to prove the boundaries connect, and set the habits that keep the architecture reversible.\n\n**Brief (fallback):** Tracer bullet — build one thin but fully real vertical slice (HTTP → use case → repository → DB → back), kept as production code, for end-to-end feedback on day two and proof the boundaries link before you flesh them out. Reversibility: abstract every vendor behind your own interface (forking-road test — could you swap DB or LLM provider in a week?). Orthogonality: a dramatic change to one requirement should touch one module. DRY for knowledge, not coincidence — merge duplicated rules, leave look-alikes alone. Broken Window: fix the first hack or board it up with a tracked ticket.\n\n**Invoke:** Use the `pragmatic-programmer` skill with the Phase 1 boundaries. Ask for the thinnest end-to-end tracer bullet that exercises every layer, an adapter interface for each vendor, and an audit of where one change would touch many modules or a vendor API would leak into business logic.\n\n**Decide with the user:** Which slice is the tracer bullet (one authenticated core action, minimal functionality); the broken-windows policy and debt budget per iteration; which vendors get an owned interface first.\n\n**Artifact:** Extend docs\u002FTESTING.md `## Test Strategy`, `## Safety Net Map` (the tracer-bullet path as the first end-to-end test), and `## CI Gates`; extend docs\u002FTECH-DEBT.md `## Debt Budget & Broken-Windows Policy` and `## Adopted Conventions` (reversibility, orthogonality). Update the tracker.\n\n**Done when:** the tracer-bullet slice runs end-to-end through every layer and is pinned as the first CI gate, each vendor sits behind an owned interface, and the broken-windows policy and debt budget are written down.\n\n### Phase 8 — Cut scope to the essential (37signals-way)\n\n**Purpose:** Decide whether any of this ships — fix time, flex scope, and delete speculative abstraction before it becomes complexity you carry.\n\n**Brief (fallback):** Build less — the best products do fewer things well; half a product beats a half-assed one. Fix an appetite (the time this work is genuinely worth) and cut scope to fit, rather than estimating an open-ended architecture that balloons. YAGNI: every speculative abstraction (generic plugin system, event sourcing, configurable multi-tenancy for zero users) is a decision deferred to an imaginary future at the cost of present complexity. Make tiny reversible decisions; say no by default so the great decisions breathe. Never cut the small set of expensive-to-reverse decisions.\n\n**Invoke:** Use the `37signals-way` skill with the full architecture plan from Phases 1-7. Ask it to shape the work into a fixed appetite, separate essential-for-launch from gold-plating, name the rabbit holes, and list the speculative abstractions to delete or replace with the simplest thing that could work.\n\n**Decide with the user:** The appetite for v1 architecture work; which abstractions to cut now, defer with a revisit trigger, or replace with the simplest thing; confirm no expensive-to-reverse decision is being cut just to save time.\n\n**Artifact:** Extend docs\u002FARCHITECTURE.md `## Decision Log` with what is deliberately NOT built for v1; extend docs\u002FTECH-DEBT.md `## Debt Ledger` (deferred abstractions as deliberately-taken debt, each with the trigger that would revisit it). Update the tracker.\n\n**Done when:** v1 scope is fixed to an appetite, every cut or deferred abstraction is a Decision Log or Debt Ledger row with a revisit trigger, and no expensive-to-reverse decision was cut for time.\n\n## Optional Phases\n\n| Skill | Add when | Artifact |\n|---|---|---|\n| team-topologies | More than one team will own the system, so module boundaries must align with team boundaries (Conway) | Extends docs\u002FOPERATIONS.md (`## Team Structure`) |\n\nOptional phases follow the same operating rules — load and use each listed skill exactly as a core phase would; insert where the Add-when condition first becomes true — here, right after Phase 2, once the bounded contexts that team boundaries must mirror exist.\n\n## Common Mistakes\n\n| Mistake | Fix |\n|---|---|\n| Letting the framework be the architecture | Apply Clean Architecture's Dependency Rule (Phase 1) — framework calls inward; ORM and request types stay confined to the outer ring. |\n| Over-engineering for scale you cannot prove you need | Run back-of-envelope QPS\u002Fstorage math first (system-design, Phase 3); one indexed DB plus a cache is usually years of runway. |\n| Over-correcting into classitis | Apply the deep-module rule (software-design-philosophy, Phase 5) — a few deep modules beat a swarm of shallow ones; boundaries at real volatility only. |\n| Ignoring the database's actual consistency guarantees | Check the default isolation level and lock write-skew-prone paths (ddia-systems, Phase 4) — write skew passes every single-user test. |\n| Treating resilience as a post-launch concern | Design timeouts, breakers, and pagination in from the start (release-it, Phase 6) — a slow dependency with no timeout freezes everything. |\n| Confusing build-less with build-carelessly | Cut features and speculative abstractions (37signals-way, Phase 8), never the small set of expensive-to-reverse decisions. |\n\n## Completing the Journey\n\nMatch the dose to the project: a weekend build leans on the Phase 1 Dependency Rule, a quick Ubiquitous Language, timeouts on outbound calls, and the Phase 8 instinct to cut scope — a few hours that save weeks. A funded team building toward launch works the whole stack, pulling the data and resilience phases in as real bottlenecks and integration points appear.\n\nExit checklist — every box tied to an artifact:\n\n- [ ] Each expensive-to-reverse decision (boundaries, contexts, data\u002Fconsistency) is a Decision Log row with alternatives rejected (ARCHITECTURE.md).\n- [ ] Core business rules are designed to run with no DB, web, or framework (ARCHITECTURE.md Layer Map, no inward-pointing violations).\n- [ ] Every outbound call has a timeout, critical ones have breakers, and every list is paginated (RELIABILITY.md Integration-Point Audit clear).\n- [ ] A tracer-bullet slice proves the boundaries connect end-to-end and is the first CI gate (TESTING.md).\n- [ ] v1 scope is fixed to an appetite with speculative abstractions cut or deferred with a trigger (TECH-DEBT.md Debt Ledger).\n\nClose the tracker: every phase `done` or `skipped: reason`, with remaining Next Actions carried into the ARCHITECTURE.md Decision Log and TECH-DEBT.md so nothing is lost. Then route forward: when the architecture serves a product that still needs validating and building, continue with the `create-app` skill; when an existing prototype must be brought up to this structure, continue with the `improve-code-quality` skill.\n",{"name":5,"license":15,"metadata":24,"description":7},{"author":25,"version":26},"wondelai","1.0.2","main","7d9c45c72ac89da53a28423808dabd6dc0be6795","skills\u002Flibrary\u002Fai-skills\u002Fsddx-ai-design-code-architecture","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx","https:\u002F\u002Fgithub.com\u002Fsung1-labs","Building open-source tools for AI-assisted software development, spec-driven engineering, and reliable developer workflows.","2026-09-07 02:51:20",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add sung1-labs\u002Fsddx --skill design-code-architecture",{"tool":40,"command":41},"bunx","bunx skills add sung1-labs\u002Fsddx --skill design-code-architecture",{"tool":43,"command":44},"pnpm","pnpm dlx skills add sung1-labs\u002Fsddx --skill design-code-architecture","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Flibrary\u002Fai-skills\u002Fsddx-ai-design-code-architecture\u002FSKILL.md",true,[48],{"path":49,"resourceType":50,"resourceTypeDesc":51,"sizeBytes":52,"sourceHtmlUrl":53},"references\u002Fartifact-templates.md","REFERENCE","参考文档",3227,"https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Flibrary\u002Fai-skills\u002Fsddx-ai-design-code-architecture\u002Freferences\u002Fartifact-templates.md",[55,62,69,76,83,90],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":59,"categories":60,"keywords":61,"publishedAt":19},"01M7C8TCN2HNT036445CS1VBHT","sddx-verify","Verify the complete SDDx change against its specifications, architecture, implementation, tests, security, operations, and deployment expectations.","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Fworkflow\u002Fsddx-verify\u002FSKILL.md",[],[],{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":68,"publishedAt":19},"01M7C8T9FQKTSN971MP6RSV0GK","sddx-quick","Handle a small, bounded change with minimal durable artifacts while preserving verification and automatic escalation when scope grows.","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Fworkflow\u002Fsddx-quick\u002FSKILL.md",[],[],{"skillNo":70,"name":71,"nameZh":6,"description":72,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":73,"categories":74,"keywords":75,"publishedAt":19},"01M7C8T6C21FE8ZX8XDSJ5VJ5R","sddx-propose","Turn a resolved SDDx exploration into durable proposal, requirements, design, tasks, and optional RFC artifacts.","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Fworkflow\u002Fsddx-propose\u002FSKILL.md",[],[],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":19},"01M7C8T2QDGTK9PPG4A3JXXS28","sddx-explore","Explore a change before implementation, resolve the applicable product, UX, architecture, security, testing, deployment, and operational questions, and recommend the next SDDx workflow.","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Fworkflow\u002Fsddx-explore\u002FSKILL.md",[],[],{"skillNo":84,"name":85,"nameZh":6,"description":86,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":19},"01M7C8SZ9GTETBRKEXT43EZ9G9","sddx-debug","Diagnose and fix a defect through reproduction, evidence-based hypotheses, a minimal fix, regression coverage, and verification.","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Fworkflow\u002Fsddx-debug\u002FSKILL.md",[],[],{"skillNo":91,"name":92,"nameZh":6,"description":93,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":94,"categories":95,"keywords":96,"publishedAt":19},"01M7C8SW14B7XG3TSQGGWZ0ZCH","sddx-archive","Complete a verified SDDx change, preserve its durable record, synchronize specifications, and recommend the next workflow.","https:\u002F\u002Fgithub.com\u002Fsung1-labs\u002Fsddx\u002Fblob\u002Fmain\u002Fskills\u002Fworkflow\u002Fsddx-archive\u002FSKILL.md",[],[]]