The Spine Manifesto

I. The blob

Something strange is happening in software organizations right now. The code has never been better, and the codebases have never been worse.

Frontier models — Fable, GPT 5.6, Sol, GLM — write better local code than most working programmers: idiomatic, tested, fast, and delivered in minutes. Any honest engineer who has worked with them knows this. And yet the enterprises paying the most for AI are reporting the least to show for it. MIT's 2025 State of AI in Business study put it bluntly: despite $30–40 billion of enterprise GenAI investment, 95% of organizations are getting zero return — only 5% of task-specific pilots ever reach production. S&P Global found the share of companies abandoning most of their AI initiatives jumped from 17% to 42% in a single year. And the code itself is aging worse than anything in the industry's history: GitClear's analysis of 623 million changed lines shows refactoring collapsing (moved code down from 21% of changes in 2022 to under 4% in 2026), copy-paste overtaking refactoring for the first time ever in 2024, and block duplication up 81% since 2023. Their conclusion, verbatim: “The throughput is real, but so is the debt it accrues.”

These two facts are not in tension. They are cause and effect.

A coding model is brilliant locally. It sees a context window — a few hundred thousand tokens at best, minutes of attention — and inside that window it is superb. But software is not built inside one window. It is built across hundreds of sessions, weeks apart, by rotating casts of agents and humans, each starting more or less blind. Run brilliant local coders across a long project with no shared long-term structure and you do not get a brilliant system. You get what we call the brilliantly coded blob: excellent functions, coherent files, and a whole that no one — human or machine — can hold in their head. Duplicated concepts. Drifting conventions. Three notification systems. No line of intent anyone can follow, audit, or safely change.

The blob is not a model failure. Bigger context windows will not fix it — the long-context research is unambiguous. Stanford's Lost in the Middle showed models reliably lose information buried mid-context; NoLiMa (ICML 2025) found that of 13 models advertising 128K-token windows, 11 fell below half their short-context performance by 32K tokens; Chroma's Context Rot study of 18 frontier models found a focused 300-token prompt beating the same information buried in 113,000 tokens, across every model family. Attention is not storage. And when many agents share the work, Berkeley's MAST taxonomy found state-of-the-art multi-agent systems failing 41–87% of the time — with the failures concentrated not in model capability but in specification and inter-agent misalignment, and the biggest measured fixes coming from better role specification and verification steps. Structure, in other words.

The blob is a structure failure. And structure failures need a discipline, not a bigger model.

II. What actually died

Agile is dead. Not wounded, not “misapplied” — dead, in the precise sense that the scarcity it was designed to manage no longer exists.

Agile was a rational response to a real constraint: human replanning is expensive. Sprints, standups, grooming, retros — the whole ceremony exists because getting a group of humans to re-derive “what should we do next?” costs days, so you batch it into cadences. Kanban, likewise, was designed to manage scarce human attention: WIP limits exist because humans thrash; cards are promises of a future conversation between people.

Even its authors saw the decay long before the models arrived. Dave Thomas, Manifesto signatory, declared “Agile is Dead” back in 2014: “the word ‘agile’ has been subverted to the point where it is effectively meaningless.” Kent Beck called what it became “a devastated wasteland… a few religious rituals carried out by people who don't understand the purpose that those rituals were intended to serve.” Martin Fowler named the enemy precisely: “The Agile Industrial Complex imposing methods on people is an absolute travesty.” Ron Jeffries: “It breaks my heart to see the ideas we wrote about in the Agile Manifesto used to make developers' lives worse.” The institutions followed the words: Capital One eliminated its entire ~1,100-person Agile job family in 2023; participation in the industry's own State of Agile survey collapsed roughly 90% in three editions; and in January 2025 the Agile Alliance — the community the Manifesto authors founded — was absorbed into the Project Management Institute, the very body it was born rebelling against.

But the models finished it. When agents do the work, replanning is cheap — an agent re-derives next steps in seconds. Attention is abundant — eight sessions run in parallel without complaint. The scarcities Agile and kanban were built to ration are gone. What is scarce now: human decision bandwidth (you cannot read every diff from a fleet of agents — the bottleneck is judgment, not labor); agent context windows (every session starts near-blind and degrades as it fills — working memory is a consumable); and coherence itself (the thing no individual session can supply: the long line of intent that makes a hundred sessions add up to one system).

A discipline built for dead scarcities cannot manage living ones. That is why “doing Agile harder” with AI in the loop produces the blob at higher speed — and why the answer is not less structure (“just prompt better”) but a different structure.

III. Spine programming

We call the discipline Spine programming — Celeborn Spine Programming in full. It stands on one observation: if the project's coherence doesn't live in the humans' heads anymore (too much code, too fast) and can't live in any single model session (too short, too forgetful), then it must live in a human-visible structure on disk that every session reads first and leaves better.

The Spine — pre-planning as an ordered contract. The backlog stops being a pool and becomes a strictly ordered, dependency-aware column where every card carries a brief, real blockers, and a Stop condition — a concrete statement of “this is a clean place to stop.” The invariant: the top card must be startable, verbatim, by a fresh agent with zero context beyond a quick orient. And the discipline's core rule, the ship ritual: you may not ship card N until card N+1 is startable verbatim. Whoever finishes work — at the exact moment the context is hottest in their head — owes the next card its clarity. Discovered work is inserted at the right position, never dumped at the bottom. Think hard once, at ship time, so no one downstream reconstructs your reasoning.

This is what “strong pre-planning” means in practice. Not a waterfall spec — a living total order of intent, maintained at the moment of maximum knowledge, adapted every time reality disagrees. Strong pre-planning plus high adaptability is not a contradiction; it is a rhythm: plan sharply, execute, learn, re-insert. The spine bends. It does not dissolve.

Tiered contextual memory — no session starts blind. Every session begins by orienting: reading a small, always-fresh headline of the project — focus, next action, open threads — instead of re-reading everything or nothing. Every session ends by checkpointing: rewriting that headline so the next session starts cheap. Beneath the headline, memory tiers by need: working notes and a journal on demand, durable knowledge (architecture, conventions, hard-won gotchas) for the long haul. All of it plain Markdown, on disk, in the repo — human-readable, human-auditable, model-agnostic.

Around those two structures, a thin protocol makes a fleet coherent: work is claimed on a shared board (one in-flight card per agent, human or AI), files being edited are touched with a reason, finished work compresses into a Ledger of receipts, and the DOING column becomes a Stage — a live surface where humans watch work happen and answer questions, rather than a to-do list with a live corner. The human's job changes shape: less typing, more judging. Answer the raised hands. Veto the wrong plans. Feed intent. Own the coherence.

That is the whole discipline. It is deliberately small. Kanban's board survives; the ceremony does not.

IV. The bill for pretending otherwise

The alternative is being priced in public, right now.

Gartner puts worldwide GenAI spending at $644 billion for 2025, inside a total AI spend it now forecasts at $2.5 trillion for 2026. Set that against the return side: MIT's 95%-zero-return finding; McKinsey's 2025 state-of-AI survey, where only 39% of nearly 2,000 organizations report any enterprise-level EBIT impact from AI — most of those under five percent; and Gartner's own prediction that at least 30% of GenAI projects would be abandoned after proof of concept. The money is not failing to arrive. It is failing to accumulate — because the work has no structure to accumulate into. MIT's researchers said it themselves, and it is the most important sentence in their report: “The core barrier to scaling is not infrastructure, regulation, or talent. It is learning. Most GenAI systems do not retain feedback, adapt to context, or improve over time.” That is a memory-and-structure problem. It has a memory-and-structure answer.

Meanwhile the engineering telemetry all points the same direction. Google's DORA research has now found two consecutive years of AI adoption correlating with degraded delivery stability — its 2025 conclusion: “AI's primary role is as an amplifier, magnifying an organization's existing strengths and weaknesses.” Stack Overflow's 2025 survey found AI usage at 84% and rising while trust falls: more developers now actively distrust AI output (46%) than trust it (33%), and two-thirds name “almost right, but not quite” as their top frustration. Security telemetry on Fortune-50 repos found AI-assisted developers shipping shallow bugs down — syntax errors −76% — while architectural flaws rose 153% and privilege-escalation paths rose 322%: in Apiiro's phrase, “AI is fixing the typos but creating the timebombs.” And in METR's randomized controlled trial, experienced open-source developers using AI tools took 19% longer on real issues in their own repos — while believing, even afterward, that AI had made them about 20% faster. Sit with that 39-point perception gap. It is the blob, experienced from the inside: the coherence tax is real, and you cannot feel yourself paying it.

Then comes the second invoice. Klarna's CEO boasted in 2024 that its AI did the work of 700 agents and later that AI “can already do all of the jobs that we as humans do” — then, in May 2025: “cost unfortunately seems to have been a too predominant evaluation factor… what you end up having is lower quality,” and Klarna started hiring humans back. Commonwealth Bank of Australia declared 45 roles redundant in favor of a voice bot, and reversed within weeks after admitting the assessment “did not adequately consider all relevant business considerations.” These are not isolated embarrassments: in Orgvue's 2025 survey of over a thousand senior leaders, 39% had made employees redundant because of AI — and 55% of those now admit they made the wrong decisions. Forrester predicts roughly half of AI-attributed layoffs will be quietly reversed, and has coined “AI-washing” for cuts that were financially motivated and blamed on AI after the fact. What did these organizations actually delete? Not typing capacity — the models supply that. They deleted the people who understood the system, exactly as the code those systems ship grows measurably harder to maintain. That trajectory has a destination, and it is a maintenance disaster with a subscription model.

None of this is an argument against the models. It is the strongest possible argument for structure. A power tool without a jig doesn't give you worse craftsmanship — it gives you faster wreckage.

V. Humans, retrained — not replaced

Spine programming is also a statement about people.

Humans remain load-bearing in AI-era software — but not where the org chart thinks. Not as typists; the models type. Humans are needed as supervisors of judgment and custodians of coherence: the ones who hold the long line of intent, answer the questions agents raise, veto the locally-brilliant globally-wrong plan, and keep the spine true across months. That is a real skill, and it can be taught. Engineers and engineering leaders need to be trained in it — in Celeborn Code as the tooling and in Spine programming as the discipline — the way a previous generation was trained in version control or code review. The companies that invest there will compound. The companies that fire the context-holders and rent more tokens will keep paying the second invoice.

VI. What this looks like on Monday

A discipline you can't start this week is a philosophy. Spine programming starts in an afternoon:

1. Lay the spine. Take your backlog and force it into a total order — the act of ordering is the act of thinking. Give the top ten cards each a brief (what, why now, where to look), honest blockers, and a Stop condition concrete enough that a stranger could check it. If you cannot write the Stop condition, the card isn't understood yet — which is precisely the thing you want to discover before an agent burns a session on it.

2. Give the project a memory. A small always-fresh headline file (focus, next action, open threads) that every session — human or agent — reads first and rewrites last. Working notes and a journal beneath it. Plain Markdown, in the repo, versioned with the code it explains.

3. Adopt the two rules. One in-flight card per agent. And the ship ritual: nobody ships card N until card N+1 is startable verbatim.

4. Move the humans up the stack. Stop reviewing every line; start owning the spine. Answer the questions agents raise, veto the plans that are locally brilliant and globally wrong, and re-order the spine every time reality teaches you something.

Do that with a Makefile and a TODO.md if you like — the discipline doesn't care. Celeborn Code is the reference implementation: it automates the orient, the checkpoint, the board, the touches, and the gauges, so the discipline costs nothing to keep. uv tool install celeborn, then celeborn init.

VII. Values

In the spirit — and the format — of the manifesto this one succeeds:

• Coherence over velocity. Speed that produces a blob is not progress; it is debt issued at machine scale.
• Ordered intent over reactive backlogs. A pool of tickets is a place where thinking goes to hide. A spine is thinking, made visible.
• Persistent memory over ritual communication. The standup was a cache refresh for human RAM. Write it down once, where every session reads it.
• Human judgment over human throughput. People are no longer the typing; they are the deciding — staff, train, and pay them accordingly.

VIII. An open movement

That is: while there is value in the items on the right, the items on the left are what keep an AI-built system whole.

Celeborn Code is open source, and Spine programming belongs to no one. The discipline is a set of ideas — ordered intent, stop conditions, ship rituals, orient/checkpoint, tiered memory, one shared board for humans and agents — that work with any sufficiently capable model and could be implemented by any tool. We built the reference implementation; we would rather the discipline win than the tool.

Kanban gave manufacturing a way to see work. Agile gave software a way to adapt. Spine programming gives the AI era the thing it is actually missing: a way to stay coherent.

Seventeen people at a ski lodge once rewrote how the industry worked, with nothing but a web page and a set of values that fit the moment. The moment has changed. The models are ready. The blob is optional.

Choose a spine.

Start here: uv tool install celeborn · then celeborn init in your project · source on GitHub