The spec is born before the code
Nothing gets implemented without a spec that says what to build. The AI (or you) writes from it — never the other way around.
Anchors is a spec-first continuity framework for AI-assisted development: anchors that guide the work on the way up, hold the rope, and confront the code on the way back — and cannot lie.
The name comes from climbing: fixed points that say where to go and mark where you’ve been.
spec-completeness bloqueante ✓12 ✗3 ~1 test-coverage julgamento ⏳2 pendente(s) de IA ~ 1 indeterminado — não é falha: o gate não teve o que confrontar 3 issue(s) — divergências registradas: ✗ [BLOQUEIA] spec-completeness @ Foo.spec.md faltam 2 cenários sem teste correspondente ✗ barrado — 1 gate(s) bloqueante(s) reprovaram
Spec-first means the spec comes before the code — and stays the truth after it. It’s not documentation written after the fact: it’s the origin everything else derives from, and the thing everything is confronted against.
Nothing gets implemented without a spec that says what to build. The AI (or you) writes from it — never the other way around.
If the code diverges from the spec, Anchors detects it and confronts it — the spec stays the truth, or it gets updated explicitly.
Every requirement in the spec carries an identity code that runs through feature, test, and code — traceability knows exactly what covers what.
On a wall, an anchor does three things — and each one solves a real problem for someone who can’t rely on memory alone to get up safely. Anchors applies the same logic to development.
In climbing: It marks the next point on unsupported terrain — knowing where to go is what lets you dare the next move.
In Anchors: The plan and the spec say what to build before the first line — the AI (or you) decides with direction, not in the dark.
In climbing: If you slip, the anchor becomes the safepoint that stops the fall — without it, one mistake would cost the whole climb.
In Anchors: The quality gates are that safepoint: they catch the divergence right away, so a mistake costs one fix — never the whole project.
In climbing: The route stays recorded — whoever comes next doesn’t have to decode the wall again, just follow what’s already validated.
In Anchors: The dependency graph and the issue history do the same: the next session reads what’s already proven and continues from there — it doesn’t start from zero.
Another agent, another day, another human — the next session starts over without knowing the rules, without knowing what was already decided and why.
The project gains lines but loses direction. Agent tooling already handles amnesia within a session — not between sessions.
The suite passes while entire chunks of the spec stay uncovered — and nobody notices until it hurts.
What’s missing isn’t memory. It’s artifact anchored in the repository — something the next session is forced to respect.
Every anchor fulfills one or more of the three climbing functions: it points where to go, it holds the rope so you don’t fall, and it marks where you’ve been. Together they form a material, versioned graph — and every edge knows if it’s in sync.
# planejar: a IA lê o guide de plano, decide o norte $ anchors guide plan # spec — a origem da verdade: o requisito ganha um código de cenário SPCR-V01: usuário autentica com e-mail e senha # map — rastreabilidade: liga spec → feature → teste → código $ anchors map build # check — qualidade: gates determinísticos + julgamento por IA $ anchors check --all
A project is mature when all of its pillars are implemented and vigorous — not when one isolated dashboard says so.
The shape of the repository, read deterministically and confirmed with you.
The north: the live plan that seeds the specs.
The origin of truth: the base anchor, the safepoint everything hangs from.
The glue: continuous identity from spec → feature → test → code, and the map between files.
The engine: makes a change ripple through the organism, marking what went stale.
The gates: deterministic where possible, AI judgment where not.
The live plan (anchors + graph, the current truth) and the history (resolved issues, dated and immutable reports).
Waiving a requirement is explicit, logged, and dated. It waives the requirement, never the record that it was waived.
Every edge in the graph knows if it’s in sync. A change re-propagates only what it touched — never the whole project.
When a confrontation fails and Anchors can’t resolve it alone, it logs an immutable issue. Recurrence is a new issue — history is never rewritten.
anchors guide planplan guideanchors guide spec.spec.mdanchors map builddependency graphanchors guide codecode + featureanchors guide testtestsanchors check / doctorissue if it divergesAnchors doesn’t embed AI: it’s the tool an AI uses, in any client — Claude Code, GPT, Gemini. It reads `anchors guide`, learns the flow, and operates the commands.
From the common mechanism to the six pillars: understand how Anchors keeps a project coherent over time.