Spec-driven development makes the specification the source of truth: you decide precisely what to build, and the implementation follows from the spec — increasingly written by an AI coding agent like Claude Code or Cursor. It works right up until the spec and the code diverge. The spec sits in a doc, the agent writes from a copy, a decision upstream changes, and now the spec, the code, and the agent's context all disagree — quietly, until something breaks. Draftlize makes the spec an addressable card the agent reads over MCP before it writes, and flips it to drift_detected the moment the implementation no longer matches.
Spec-driven development lives or dies on whether the spec still matches the code. A markdown spec cannot tell you when it stopped matching; a card that knows its dependencies can.
| Draftlize | Spec in a doc / markdown | |
|---|---|---|
| What the agent reads | Live cards over MCP | A copy pasted into the prompt |
| A decision changes | Dependent specs flag stale | The spec silently goes wrong |
| Implementation status | Flips to drift_detected on its own | Whatever the doc said last |
| One decision, six specs | One card, cited from all six | Six copies that drift apart |
| Who keeps spec and code aligned | The substrate tracks it | Your memory |
You write the spec, the agent builds it, and both are correct on day one. Then the code evolves in pull requests the spec never hears about, and the spec evolves in edits the code never sees. Two sources of truth, diverging — which is the same as having none.
When you paste a spec into a prompt, the agent builds from a snapshot frozen at copy time. Change a decision after that and the agent keeps implementing the old one — confidently, because nothing told it the ground moved.
Flip a decision the API contract rested on and every spec that assumed it is now wrong. Nothing links the decision to the specs, so they read as truth until an engineer — or the agent — trips over the contradiction in review.
Claude Code or Cursor pulls the relevant spec and the decisions under it over MCP before it writes a line — so it implements the current definition, not a paste from last week. The spec is context the agent reads on every turn, not a document it saw once.
Each spec card declares what it depends on. Change an upstream decision and every spec built on it turns stale automatically — the way a build system invalidates everything downstream of a changed file.
When the spec moves after the code was written, the implementation status flips itself to drift_detected — so the gap between spec and code surfaces the moment it opens, not three sprints later in a post-mortem.
Spec-driven development is only as strong as the link between the spec and the code. Make that link something the substrate maintains, not something you remember to.Write the spec once. Let the agent read the live version, every turn.
Spec-driven development is an approach where a precise specification is the source of truth and the implementation follows from it, rather than the design emerging from the code as you write. In the AI era the spec is often what a human writes and the code is what an agent generates from it, which makes keeping the two in sync the central problem.
Test-driven development writes a failing test first, then code to pass it. Spec-driven development writes the specification first, then implements to satisfy it — and tests can be one expression of that spec. The two are complementary: the spec says what to build and why, the tests check that the build matches.
It is arguably where it matters most. An agent like Claude Code or Cursor implements from whatever spec it is given, so the freshness of the spec directly determines the code. The failure mode is the agent building from a stale copy — which is exactly what an addressable, agent-read spec avoids.
Stop storing the spec as a static copy. Draftlize makes the spec a card the agent reads over MCP before it writes, wires each spec to the decisions it depends on, and flips implementation status to drift_detected when an upstream decision changes — so divergence surfaces the moment it happens instead of in review.
Write specs as cards, connect Claude Code or Cursor over MCP, and let the implementation flag drift the moment a decision moves. See Draftlize for developers.
Start free with $5