skills

Engineering Workflow Skills A set of Agent Skills that take a change from a vague idea to shipped, verified, documented code, for any AI coding agent. One skill per phase. Run only the ones a change needs, in any order. The state lives in files (a scope, specs, AGENTS.md, tests), not in a chat session. So work survives across sessions, picks up where it left off, and works for a whole team. Run `/debug` anytime something breaks. Run a bare `/scope` anytime to see where things stand. > 📖 **Want the full picture?** Read the **Workflow Guide** — a plain-language walkthrough of every skill, the files that carry the work, who owns what, and one idea followed all the way from scope to shipped. The skills | Skill | What it does | |---|---| | `scope` | Turns a product idea into a living, coarse scope and keeps it current as you ship. | | `audit` | Writes the AGENTS.md context files every other skill reads. | | `architect` | Makes a load bearing decision and writes it as a build spec in `docs/specs/`. | | `develop` | Builds a feature, UI or backend, from its spec. Gates to `/architect` if a decision is owed. | | `check` | Confirms a change before merge. `/check verify` runs the real app; `/check review` reads the code on a second model. | | `test` | Writes a test suite for the code you just changed. | | `document` | Writes the PR text, changelog, release note, or postmortem from the real diff. | | `sync` | Keeps AGENTS.md, the scope, and spec statuses current after a change. | | `debug` | Finds and fixes the root cause of a bug, then hands a regression test to `/test`. | Hardening (systems level failure mode analysis) is temporarily removed and will return as a system design specialization. Install Uses npx skills. Pick your agent: Works on any Agent Skills client (Claude Code, Cursor, Codex, Gemini CLI, and more). Commit the installed skills folder to share the workflow with your team. Each skill's instructions live in its `SKILL.md`, which is what every client reads. The `agents/openai.yaml` beside it is interface metadata only (the name, blurb, and opening prompt Codex shows in its agent picker); it carries no logic of its own. Where to start **New product (greenfield):** `/scope` the idea, then `/architect` the stack, then scaffold the project, then `/audit` to seed AGENTS.md from the real project, then the feature loop. The stack is decided and the project scaffolded before `/audit` runs, so it reads a real project, not an empty one. **Existing codebase (brownfield):** `/audit` first so every skill understands your project, then `/scope` the next slice on top of what exists, then the feature loop. **Any single change:** run only what it needs. A bug goes straight to `/debug`. A small change can be `/develop` then `/check verify`. **Monorepo:** everything scopes to the target workspace, which has its own AGENTS.md, scope, stack, and commands. The feature loop At the end of `/scope` you also pick a **workflow depth** for the project (override per feature anytime): `Prototype` (just `/develop`, self-checked, for throwaway work), `Alpha` (adds `/check verify`), `Beta` (adds `/test`), or `GA` (adds a fresh-model `/check review` and `/document`). The depth is a *suggested* checking tail after `/develop`, never a track you're locked onto: you're in charge, you run or skip any step and mark a feature `done` when you decide it is. The one thing the workflow asks — at every depth — is that a load-bearing decision gets written down (`/architect`), not that any check be run. `/scope` fixes what to build. `/architect` designs how, as a spec whose acceptance criteria are the contract; every later step traces back to that contract. `/develop` gates on the spec: if building would mean inventing an undecided design, provider, or data model, it stops and routes you to `/architect`. You can override and build anyway, but the override is not free: the assumption is recorded as an `Assumed` spec in `docs/specs/` and flagged on the feature until `/architect` ratifies it. The flag doesn't block you from marking `done` — it's a standing reminder that a decision still owes ratification, so it never gets silently lost in chat. The gate is layered, not magic: `/architect` names the source of every value a feature must produce (so gaps surface at design time), `/develop` checks that coverage again before building, and at Beta+ `/architect` recommends running an independent cross-model critic over the spec for decisions it never set