the drift problemWhy prompt-and-patch quietly degrades.
A language model is a pattern-completer, not a mind-reader. When you vibe-code — prompt, get output, patch the errors, repeat — you're letting it guess at thousands of unstated requirements. It produces confident, plausible code that looks right and solves the wrong problem. One screen, fine. A codebase, repeated across a team, and you get drift: features bolted on instead of integrated, conventions nobody agreed to, security holes nobody read. Studies on enterprise AI output keep landing on the same number — a large share of generated code ships with vulnerabilities. The productivity you felt in week one becomes the technical debt you can't pay down in month six.
- Ambiguity collapse: the model fills unstated requirements with its own assumptions.
- Misaligned intent: code that compiles and runs but does the wrong thing.
- Integration friction: each feature is a bolt-on, not part of a coherent system.
intent → plan → buildWhat spec-driven development actually is.
Spec-driven development makes the specification — not the prose prompt — the source of truth. The canonical shape is four phases. Specify: a high-level description of what you're building and why, in terms of user journeys and success criteria. Plan: the technical approach, stack and constraints, where your organization's standards and compliance rules get encoded. Tasks: the work broken into small chunks each implementable and testable in isolation. Implement: an agent tackles the tasks one by one, each a focused, reviewable change. The point isn't ceremony — it's that intent is captured before code exists, so there's something to verify the output against. Tests become acceptance criteria inside the spec, not an afterthought.
- Specify the why and the boundaries before any code is generated.
- Plan encodes architecture, conventions and the rules agents must obey.
- Tasks are small and verifiable; implementation is gated, not freehand.
the missing pieceA method needs software to be real.
Most teams adopt spec-driven development as a folder of markdown and good intentions. That works until someone is in a hurry — then the spec gets skipped, the gate gets waved through, and you're back to vibe coding with extra steps. A method only holds if a system enforces it. Agentation is that system. You describe intent on the live product, not in a doc nobody reads. A Tech Lead component holds the plan — your architecture, conventions, security posture, your company's rules — and every agent boots inside it, so the spec isn't advisory, it's the floor. The phases stop being a checklist you can skip and become the only path code can take to production.
- Intent is captured where you see the product, not buried in a wiki.
- The Tech Lead encodes the plan once; agents can't ship outside it.
- The workflow is enforced by the tool, not by everyone's discipline.
the gateThe build is gated, or it isn't spec-driven.
The whole promise of the method is that you verify against intent before shipping. In Agentation that verification is deterministic and runs on zero AI judgement: lint, types, tests, and a security scan execute on every change. Green or it doesn't land. Nothing reaches production on vibes; it reaches production through your own GitHub, on your existing AI plan, as reviewed work. That's the difference between 'an agent wrote this' and 'this passed.' The result is code you can maintain — governed against an encoded plan — instead of the unreviewable sprawl that 'just ship it' leaves behind.
- Deterministic gates — lint, types, tests, security — before prod, every time.
- Ships through your GitHub: full history, your branch protection, your audit trail.
- What accumulates is governed code, not the debt vibe coding produces.
cocoricoSovereign on the tooling — a French answer.
Agentation is built by a French team. Here's the honest line on sovereignty: nobody in Europe is sovereign on the frontier models yet — Claude, GPT and the rest are American. But with raw models alone you don't ship much; the leverage is in the orchestration — the layer that turns a model into governed, verified, production software. That layer can be European, and ours is. Hosting in the EU (Hetzner, Germany), data in the EU (Supabase), your code in your GitHub, GDPR by construction. You keep the best models in the world and stop being a passenger on the tooling that wraps them.
- EU hosting (Hetzner) and EU data (Supabase) — GDPR by construction.
- Your code stays in your GitHub; we never hold it.
- Sovereignty where it's winnable: the orchestration, not the model weights.
FAQWhat is spec-driven AI development?
It's the practice of making a specification — not a one-off prompt — the source of truth that AI agents implement against. You move through four phases: specify (what and why), plan (architecture and constraints), tasks (small, testable chunks), and implement (agents build them under verification). Intent is captured before code exists, so output can be checked against it.
How is spec-driven development different from vibe coding?
Vibe coding is prompt, accept output, patch errors, repeat — the model guesses at unstated requirements and quietly drifts off intent. Spec-driven development front-loads the intent and constraints, then gates the build with tests and checks. Use vibe coding to explore and prototype; use spec-driven development to harden and ship anything that has to survive contact with users.
Do I have to write the specs by hand?
No. In Agentation you describe intent in plain language on the live product. The Tech Lead component holds the standing plan — your architecture, conventions, security and company rules — so you don't re-specify them every time. The spec is captured from where you actually see the product, not authored in a document nobody opens.
What stops an agent from ignoring the spec?
Deterministic gates. Lint, type-checks, tests and a security scan run on every change with zero AI judgement involved — green or it doesn't land. Agents boot inside an encoded plan they can't ship outside of, and everything reaches production through your own GitHub. The method is enforced by the structure, not by everyone remembering to follow it.
Is spec-driven development overkill for a small team?
The ceremony is, if you do it by hand. The point of Agentation is that the structure carries the overhead for you — you describe outcomes, the plan and the gates are already there. So a small team gets the governance of a spec-driven pipeline without the paperwork of running one manually.
Where does my code and data actually live?
Your code lives in your GitHub, on your existing AI plan — we never hold it. Agentation's own infrastructure is in the EU: hosting on Hetzner in Germany, data on Supabase, GDPR by construction. You keep the frontier models you already use, with the orchestration layer kept European.