- Spec-driven delivery
- Human-approved by design
Software, built to spec.
specd grounds a knowledge base in your own repositories, drafts every ticket into a spec with a citation behind each claim, and gates it behind a named human — so the agent builds what you approved, and nothing else.
MIT licensed · Postgres is the only runtime dependency · agents open PRs, never push
git clone https://github.com/unitypark/specd.git pnpm install && pnpm demoPostgres, the API and the web app — one command, on your machine.
The line · fixed for every project
- ConnectPoint specd at your repositories, a model and a tracker.
- GroundIt reads the repo and opens a PR carrying your knowledge base.
- SpecA ticket becomes requirements, a cited design, and tasks.
- The gateA named human approves that exact version. Nothing skips this.
- BuildOne commit per task, on the spec’s own branch, as a pull request.
- LearnYou merge — the as-built spec files itself and the index refreshes.
- 99.5%
- F1 · Go symbol extractiongraded by go/parser over the Go stdlib — 7,654 files, 316k declarations
- 99.4%
- F1 · Python symbol extractiongraded by the ast module over the Python stdlib — 94k declarations
- 100%
- retrieval recallon the labelled question set · 0.861 MRR
- 0
- unapproved agent changesenforced in the state machine and a database CHECK constraint
Extraction and retrieval scores come from pnpm eval, graded against independent
oracles — the language’s own parser, not a rubric specd wrote for itself — and committed
under evals/results/.
- GitHub
- GitLab
- Jira
- Claude Code
- Cursor
- Windsurf
- MCP
- Postgres
No agent writes code your team hasn’t approved
Not a setting. Not a best practice someone has to remember. A named human approves every spec before a line is written — and the approval is pinned to that exact version, permanently.
A generic coding agent
- Rediscovers your architecture every session, from raw code
- Invents conventions, then drifts from the ones you have
- Ships assumptions silently — you find them in review
- Leaves nothing behind: session twenty is as uninformed as session one
Your specd agent
- Reads your knowledge base first — it is rule one of its brief
- Cites the document behind every design claim it makes
- Flags what it cannot ground instead of guessing quietly
- Files what it built back, so the next spec starts better grounded
Three steps. The middle one is yours.
Everything mechanical is automated. You keep the two decisions that actually carry risk — what gets built, and what gets merged.
01Connect and ground
specd reads your repositories — manifests, CI workflows, compose files, schemas, layout — and writes your team a knowledge base as a pull request you review. What it could not establish says UNVERIFIED rather than being guessed at.
02Draft and approve
A ticket becomes a spec with testable criteria and a citation behind every design claim. You read it and stamp it. Nothing downstream moves without that stamp — not the agent, not the CLI, not a script that asks nicely.
03Build and merge
The agent implements only what you approved, one commit per task, and opens a pull request. Merging files the as-built spec back into knowledge/ — so the next spec starts better grounded than the last.
Every change starts as something you can read
Testable acceptance criteria, a citation behind every design decision, and tasks sized to one pull request. If the agent could not ground a claim in your own docs, it says so instead of guessing.
A knowledge graph, not just a vector store
Five deterministic link kinds extracted with parser rules — no model ever runs at index time, because a hallucinated edge poisons retrieval invisibly. Retrieval is rank fusion over pgvector and Postgres full-text, then one hop across the graph, with every added passage carrying the edge that pulled it in.
Three bounded stages
Rank fusion, a graph hop, then the actual source of the symbols your docs reference.
Four citation verdicts
supported, unsupported, unknown, stale — because “I found no evidence” and “no evidence exists” are different answers.
Drift measured against code
Coupling mined from git history names the code to go read. A 90-day timer only measures time passing.
Run it on your own machine.
specd runs the whole loop end to end against a real Postgres, gated by CI. There is no hosted service yet, and the docs say exactly what a first deployment would still need.