Get Started

Install the stack, type /pds, and approve a direction. The conductor asks the lane first — Sketch by default — then runs the cycle, one phase per session, and stops at every gate for your decision.

Prerequisites — Node.js 18+ and Claude Code installed, inside a front-end project (Next, Nuxt, SvelteKit, Astro, or Remix).

Install the stack

Run the installer at the root of your project:


npx pds-stack install

Answer nine questions (ten in a git repo): framework, UI library, your level, which AI tools you use, optional modules. Nothing you already have is overwritten. You get:

STACK.md — your stack config: lane defaults, modules, the user_level dial
CLAUDE.md — agent registry and hard constraints
agent-system/ — RAY, BOB, ANALYZER, the conductor flow, the direction brief gate, ADRs, spec templates, context stubs
memory/ — identity.md, directions/INDEX.md and the other stores the direction reads first
scripts/ with two npm commands — npm run memory:index after every delivery, npm run tokens to measure your sessions
.claude/settings.json — the guard that stops bob-build from reading an image (ADR-014)
Entry points for every tool you picked — /pds, /bob --brief, /ray, /bob --proto, /bob --build, /analyzer in Claude Code, Cursor, Gemini CLI, VS Code / Copilot or Codex CLI
Optional git guardrails in .git/hooks/

Start the cycle


/pds Add a compact newsletter signup to the footer

The conductor asks the lane, reads memory/identity.md, and drives from there. The steps below are what it orchestrates — you can also call each agent yourself.

Lane	When	Phases	Human gates
Sketch (default)	explore, iterate — the 80 %	DIRECTION → PRODUIRE	1
Standard	a screen or component going to review or dev	all four	2
System	it touches the design system	all four + written decision	3

DIRECTION — approve the brief · gate ①


/bob --brief Add a compact newsletter signup to the footer

BOB’s brief half reads the memory — identity, the directions already judged, the design system, the references — and writes a direction brief on five dimensions. Then it waits.

This is gate ①. If the direction is right, approve it. If not, correct it now — in text, before anything exists. Nothing is produced before this brief is approved.

CADRE — freeze the scope · gate ②

(Standard and System only — Sketch has no spec file, no score, no written decision.)


/ray

RAY writes the scope against the approved direction: numbered tasks, a mandatory ## OUT OF SCOPE block, and the work cut into lots of about 50 turns each. At statut: VALIDATED the scope is frozen.

PRODUIRE — make it


/bob --proto

The first output, in every lane, is a clickable HTML prototype of the approved direction. Sketch stops here. In Standard and System, the prototype becomes a Figma frame (/design-workflow), and code follows when modules.code is on:


/bob --build

Each lot gets a fresh bob-build — never a resumed one — which commits after each task (feat(N): task-title) and proves its criteria in text with Playwright CLI. It cannot read an image back: the guard in .claude/settings.json blocks it.

JUGER + MÉMORISER — two verdicts · gate ③


/analyzer

ANALYZER renders two verdicts, never averaged: a conformance score /20 the system computes, and a binary direction verdict — retenue / refusée — that only you render.

Conformance	Direction	Commits?
≥ 18	`retenue`	✅ yes
≥ 18	`refusée`	❌ no — back to DIRECTION
< 18	any	❌ no — back to PRODUIRE (RAY if <10)

The direction goes to memory/directions/, retained or refused, with the learning. Then npm run memory:index.

One phase, one session

A project with several features? Start with a session 0:


/pds cadrer my-project

It gathers the project once — target, constraints, references, the features — and crosses no gate. It writes one file, agent-system/sessions/project_my-project.md (about 60 lines at most), plus a state file per feature, then hands you a dispatch plan: one line per feature, with the session title and the prompt to paste. You open the sessions; each one is a single agent on a single phase. A lone feature skips this and starts with /pds. (ADR-017)

At every gate the conductor writes agent-system/sessions/state_<feature>.md — the lane, what was approved, what was produced — and ends the phase. Open a new session and pick up from the file:


/pds reprendre newsletter-signup

This is where V5 saves its tokens: a cycle held in one chat re-reads its whole history on every turn. Measured on our own stack, the main conversation went from ~75 % of the spend (up to 669k of context) to 10 % (≤ 62k). What a cycle costs.

A session that runs long or drifts mid-phase is cut the same way: the conductor updates the state file and gives you the prompt for a fresh session. Relay, don’t fork — a forked conversation carries its whole history, which is exactly what you were trying to leave behind.

What just happened

You didn’t review output hoping it had taste. You set the direction first, froze the scope around it, and let the build execute against a contract — then wrote the verdict into the memory the next direction reads.

Next: meet the agents, or read the core concepts.