gspec

An agent team, not a pile of prompts.

gspec is built in five layers with a single organizing idea:

Skills are the brains, agents are the hands, commands are the conversations, the runtime is the deterministic driver, and hooks are the hard floors.

1

Skills

the brains

Reusable expertise your AI loads on demand. Eight persona skills (product, architect, designer, engineer, QA, practices, steward, orchestrator) each carry a quality bar; five convention skills cover authoring, templates, memory, agnosticism, and shared conventions.

13
2

Agents

the hands

Isolated workers, each bounded to one job: 9 producers that write a single spec type, 10 read-only validators that return a verdict, 6 investigators and planners (codebase inspection, competitor research, cross-referencing, build ordering), 3 transformers (decompose, implement, migrate), and 1 that runs the learning loop. Fresh context every time — no drift.

29
3

Commands

the conversations

The slash commands you actually talk to. Each is a thin orchestrator that loads the right persona skill, asks what it needs, and delegates the real work to agents behind a writer → validator quality gate.

16
4

Runtime

the driver

A deterministic Node driver — not a prompt — that runs the autonomous build. It sequences stages, gates each one, tracks progress in a resumable manifest, and re-delegates on failure. Control flow lives in code, judgment lives in agents.

Harness support varies. The autonomous build runs only on harnesses — the AI coding tools gspec installs into — with a wired headless engine. Today that means Claude Code, Codex, and Pi. Compare platform capabilities →

1
5

Hooks

the hard floors

Deterministic shell guards on lifecycle events that turn soft conventions into hard blocks: task immutability, spec integrity, profile agnosticism, style-guide token discipline (no literal colors outside the token block), and practices enforcement.

Harness support varies. Hard, deterministic blocking is full-fidelity only on Claude Code. Other harnesses enforce these floors on the build path or as advisory guidance, depending on what the platform allows. Compare platform capabilities →

10

Producer ≠ checker

The single biggest reason gspec produces better output: the agent that writes a spec or a slice of code is never the one that approves it. Every producer is followed by an independent, read-only validator. Nothing advances on the author's own say-so.

1

The producer writes

One agent, one spec or one slice of code. It owns the work but never grades its own homework.

2

A separate validator checks

A read-only agent, loaded with the QA persona, returns a structured verdict against the acceptance criteria — it can’t edit, only judge.

3

Failure loops back

A failing verdict hands the work back for a bounded revision. Deterministic checks (build + test via verify.sh) back the judgment with hard signal.

Harness support varies. The producer/checker split runs as agents on every supported harness. How firmly the gate is enforced differs: deterministic blocking and the verify.sh build gate are full-strength on Claude Code and on the autonomous build path (Claude Code, Codex, Pi); elsewhere the gate is advisory. Compare platform capabilities →

New in 3.0

It gets better every run

When a validator rejects work or you correct an agent, that memory is recorded to .gspec/memory/pending/ — tagged with exactly which layer it belongs to. A reviewer step then commits recurring memories to the skills themselves, with your approval. Corrections become durable expertise instead of evaporating.

Record

A failing QA verdict or a user correction is written to .gspec/memory/pending/ — one file per memory, address-tagged to its target layer.

Memorize

The memorizer reviews pending memories and proposes surgical skill edits — one at a time, for your approval. Nothing recorded changes behavior until you commit it.

Improve

Committed memories are composed into the skills. The next run starts with the correction already baked in.

Harness support varies. Recording and /gspec-memorize run on every harness that ships agents — it is a plain file write, not a harness memory feature. Claude Code is the only one where the address tag is hook-enforced; elsewhere it is a convention the agents follow. Antigravity runs workflows rather than agents, so recording lands there with its agent adapter. Compare platform capabilities →

Claude-first, degrade gracefully

One source tree builds for every supported harness. Claude Code gets the full split — skills, agents, commands, and hooks. Other targets collapse each agent back into a skill or command and enforce what their platform allows.

See what each harness supports →

See it end to end

The autonomous build wires all five layers together — the runtime driving agents through the pipeline, gated by validators and hooks, recording learnings as it goes.

Explore the build pipeline →