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, ADRs, 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.

idea → /scope → /audit → /architect → /develop → /check verify → /test → /check review → /document → /sync

Run /debug anytime something breaks. Run a bare /scope anytime to see where things stand.

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 ADR in docs/adr/.
develop	Builds a feature, UI or backend, from its ADR. 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 ADR 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:

# Claude Code (installs into .claude/skills, then restart Claude Code)
npx skills@latest add JavaScript-Mastery-Pro/pilot -a claude-code

# Generic .agents/skills, read by Codex and other agents
npx skills@latest add JavaScript-Mastery-Pro/pilot

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.

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

/architect → /develop → /check verify → /test → /check review → /document → /sync

/scope fixes what to build. /architect designs how, as an ADR whose acceptance criteria are the contract; every later step traces back to that contract. /develop gates on the ADR: if building would mean inventing an undecided design, provider, or data model, it stops and sends you to /architect first.

What gets written, and where

Artifact	Path	Owner
Scope	docs/scope/	scope
ADRs	docs/adr/	architect
Context files	AGENTS.md (plus a thin CLAUDE.md pointer)	audit, kept current by sync
Design system	design.md (art direction; token values live in CSS)	develop
Review findings	docs/reviews/	check
Tests	your test dirs	test
App code	your source tree	develop
Human docs	PR body, CHANGELOG.md, docs/releases/, docs/postmortems/	document

If docs/ is a published docs site, these move to .workflow/ so they do not ship with your site. Because state lives in files, each skill suggests /clear at handoffs, so a fresh session re-reads from disk and long chats do not pile up cost.

Skill reference

For each skill: what it does, and when to run it.

scope: Turns an idea into a living, coarse plan of what to build, in order. When: to start a new product or plan the next slice. Greenfield: run it first. Brownfield: it enrolls what already exists, then plans the new work. Monorepo: writes one scope per workspace.

audit: Writes the AGENTS.md context files that give every skill your project's stack, commands, and conventions. When: brownfield, run it first. Greenfield, run it after the stack is chosen and the project is scaffolded. Monorepo: gives each workspace its own nested AGENTS.md.

architect: Runs a deep design conversation and writes the decision as a build spec ADR. When: a load bearing choice is unmade (a stack, a data model, a provider, a page design), or /develop says a decision is owed. Greenfield: it decides the stack first. Monorepo: reads the target workspace's stack.

develop: Builds a feature, UI or backend, from its ADR, runs migrations, and advances the scope. When: after the decision exists. It gates to /architect if a design is owed. Monorepo: builds inside the target workspace using its commands.

check: Confirms a change before merge, in two modes. When: /check verify after /develop to run the real app and prove the feature works against the spec; /check review before a PR for a senior review on a different model than wrote the code. Any project type.

test: Writes a senior test suite for your uncommitted change and saves your framework choice. When: after building a feature or fixing a bug. Monorepo: resolves the framework per package.

document: Writes the human facing prose (PR, changelog, release note, postmortem) from the real diff. When: a finished change needs writing up. Any project type.

sync: Reconciles AGENTS.md, the scope, and ADR statuses to what the repo now shows. When: the last step around merge. Monorepo: reconciles the right workspace.

debug: Runs a disciplined root cause loop and hands a regression test to /test. When: anytime something is failing, throwing, or behaving wrong. Not tied to project type.

---

Built with the Agent Skills open format.