jcardena.com › Blog › Git Is a Bookshelf. Agents Need a Nervous System.
184 posts
EN ES

Git Is a Bookshelf. Agents Need a Nervous System.

AI

We have built software with Git since the early 2000s. It is 2026 and we never re-engineered how we work for what AI agents can build. Git is a bookshelf; agents need a nervous system.

Git Is a Bookshelf. Agents Need a Nervous System.
Field note. A working architect on why the way we build software has not changed since the early 2000s, why that is now the bottleneck, and the one question worth sitting with: if agents can build a universe, what is left for the human to do?

Here is something strange, hiding in plain sight. The single most important tool in software, the one almost every team on Earth uses to build almost everything, was designed in 2005. Git. It is a masterpiece. It is also, by 2026, the quiet reason your AI agents feel so much slower than they should.

We have spent three years putting a jet engine into a horse-drawn cart. The engine is a fleet of AI agents that can write, test, and refactor code faster than any human team in history. The cart is the entire ritual we built for humans: the branch, the commit, the pull request, the review, the merge. We bolted the future onto the past and then wondered why the ride is so rough.

The claim I want to defend is simple, and once you see it you cannot unsee it: Git is version control for artifacts. Agentic development needs state synchronization for processes. Those are not the same job, and they were never going to be.

A bookshelf, not a nervous system

Think about what Git actually is. It is a library. It stores a collection of finished books, each one written by an individual author, each one signed, dated, and shelved so that other humans can come along later and read the history of how the work was made. The whole design serves one goal: a clean, legible record of human decisions. Who changed what, when, and why.

That is a beautiful thing to want. It is also completely wrong for what agents do.

An agentic system is not a library. It is closer to a brain. It is a continuously evolving storm of parallel processes, thousands of small decisions happening at once, none of them a "finished book," all of them just the current state of an ongoing computation. What that needs is not a bookshelf. It needs a nervous system: something that transmits signals in parallel, at millisecond speed, and cares about only one thing, the current valid state required for the next action.

The whole idea, in one line

We are running a planetary-scale nervous system on the operating model of a village library. The category error is causing a system-wide seizure.

This is why "human development speed" and "agentic development speed" are not two points on the same line. They are different in kind. Human development is serial and scarcity-bound: it runs at the speed of one mind holding context, typing, and reviewing. Agentic development is massively parallel and compute-bound: it runs at the speed of however much hardware and orchestration you can point at it. Git was built for the first regime. It becomes the throttle the moment your number of simultaneous authors exceeds what a human coordination layer can police. And a fleet of agents exceeds that on its first afternoon.

The dark geometry of Git

I do not think Git is bad. I think Git is perfect, for a world that no longer fully exists. The trouble is that every one of its elegant assumptions is an assumption about humans, and agents quietly violate all of them at once.

It assumes the author is a single, coherent human. A commit is designed to capture a person's intent. But a hundred agents executing one directive can produce ten thousand micro-changes. Force each to be a "commit" and you get a log of pure noise, the original intent buried under machine exhaust.

It assumes the unit of work is a human-readable feature. The pull request, the formal checkpoint where a person reviews and approves a batch of work before it joins the whole, is a ceremony for human cognitive review. It bundles up days of work so a person can sit and judge it. Asking an agent to open a PR is like asking a single neuron to file a daily report on every synapse it fired. It halts a system that is orders of magnitude faster than the review it is waiting on.

It assumes integration is an occasional, deliberate event. A merge is a careful, sometimes painful act because it reconciles two divergent human stories. For a fleet of agents working the same model at once, divergence is not an event. It is the permanent condition. The whole thing degrades into merge-conflict-resolution-as-a-service, and forward motion stops.

It assumes history is linear and meant for human forensics. git log is a story we tell ourselves about how the software was made. Agents do not need a story. They need a high-fidelity causal graph of state. A neat linear history is a destructive simplification of a massively parallel reality.

It assumes the bottleneck is typing. Git optimizes the act of capturing output from a human who already did the slow part, the thinking. But for agents, thinking and typing are nearly free. The bottleneck moves to everything else: file I/O, network latency, runtime isolation, and the artificial gates of the protocol itself.

The single most damaging assumption

Underneath all of it is one belief: that scarcity lives in review. The entire human philosophy, the senior engineer, the approving reviewer, the gate, was built on the idea that writing code is easy and checking it is the hard, scarce resource that guarantees quality. In the agentic era that inverts completely. A fleet can generate and self-correct at near-infinite scale. The scarce thing is no longer review. It is knowing what to build and being able to trust that it was built right. The pull request has become a monument to a scarcity that no longer exists: a dam holding back an ocean.

"If Git is the problem, why is it still the standard?"

Because being the standard is exactly the problem. This is not a fringe complaint. The industry is starting to say it out loud. The infrastructure that powers modern development was built, over almost two decades, around a single load-bearing assumption: that the unit of work is one human developer, moving at a human pace. An agent does not respect that. It does not open one pull request and wait politely for a review. It opens fifty at once, each one firing the entire build-and-review pipeline simultaneously, and the system that was sized for human cadence buckles.

The people closest to Git agree. The co-founder of GitButler has said plainly that these systems "should fundamentally change" and that we need "different primitives." The CEO of a version-control startup put it even more bluntly: Git's architecture is an issue that actively prevents scaling. The popular stopgap, running agents in parallel Git worktrees, helps with files but not with reality: it isolates the working tree while leaving the ports, the databases, the caches, and the secrets all shared, so the agents simply trample each other one level down. The conclusion is becoming hard to avoid. In the agent era, parallel execution is the entire point, and the layer we use to coordinate it was built for a world where parallelism was the exception.

From the bookshelf to the forge

So what replaces it? Not a better Git. A different shape entirely. If the agentic substrate is a nervous system, the place you build with it is not a repository. It is a factory.

This is not theory for me. I built one. It is called qForge, and the description on the box is "where humans direct and agents build." You give it a mission. It breaks the mission into tasks. It dispatches those tasks to a fleet of more than a hundred agent workers spread across a row of machines, each one picking up a task, doing it, and reporting back. The human does not write the code. The human defines the work and judges the result. The repository stops being the center of gravity. The directive becomes the unit, and the live, orchestrated state of the fleet becomes the thing you actually manage.

That is the real shift hiding inside all the noise about coding agents. It is not that the typing got faster. It is that the entire shape of the work is changing, from a single craftsman building a cathedral stone by careful stone, to an architect standing in front of a universe of parallel construction, conducting it.

What is left for the human

This is the part people get wrong in both directions. The optimists say the agents will build everything and we can finally rest. The pessimists say we will be automated out of the work we love. Both are missing it.

When you remove the bottleneck of production, you do not arrive in paradise. You arrive at a new, harder bottleneck: specification and verification. It turns out that defining what you want with enough precision that a non-sentient fleet can execute it without ambiguity is genuinely difficult. And verifying the result is harder still. If a fleet generates a million lines of working code in an hour, how do you review it? How do you test a system whose complexity has quietly grown past what any single human mind can hold?

That is the honest dark side of this dream, and it is bigger than Git. We can fix the substrate. We do not yet know how to fully fix the problem of directing and trusting a workforce that is non-deterministic and superhumanly productive. The factory is real. So is the loneliness of being its only quality inspector.

So what should you actually take from this?

Picture a workshop where one master craftsman builds something beautiful by hand. It is real, it is meticulous, and you can feel the care in it. Now zoom out, all the way out, until the whole workshop is a single point of light on a dark planet. That is human-scale software. It is genuine, and it is small.

Agentic development is the same act of creation, zoomed out to a scale a human pipeline simply cannot hold: not one craftsman, but a galaxy of them, working in parallel. The mistake is to keep running that galaxy through a tool built for the single workshop. Git is the workshop's logbook. It is wonderful. It is not the control room for a universe.

So here is the clear message. Keep Git for what it is good at, the human-scale, the deliberate, the things a person signs their name to. But stop pretending it is the right substrate for agentic work. It is not. The future of building is a factory you direct, not a repository you commit to. And the job that survives, the only one that gets more valuable as the agents get faster, is not typing. It is judgment: knowing what is worth building, and being able to look at a universe of work and say, honestly, whether it is good.

That is the whole shift, in one sentence: you are no longer the bricklayer. You are the architect of a universe. Act like it.

Juan Cardena

JC
Juan Cardena
Enterprise AI & Agentic Systems Architect

Enterprise architect with 25 years across web, software, data, and AI. MIT CDAO ’25. Writing on agentic AI in production.