The Software Engineering Anarchist

The backlog is dying and nobody is mourning it.

Teams are shipping with a two-page doc and a fleet of agents. No sprint planning, no ticket grooming, no story points. What needs to be done surfaces on its own when the people closest to the work are empowered to act on it.

Most people hear “anarchy” and think chaos. That’s the branding problem. Anarchy isn’t the absence of order. It’s the absence of rulers. It’s what happens when competent people enter voluntary agreements and hold each other accountable without a central authority dictating the plan.

Software engineering has had its central planners for decades. The roadmap is the five-year plan. The backlog is the queue at the bread line. The sprint is the ration. Every ceremony exists to give someone visibility and control over work they don’t do. The work gets done almost as a side effect. The point of the system is the system.

What’s emerging now looks a lot more like a free market.

Competent people identify what needs to happen. They form contracts - not in the legal sense, but in the deepest sense of the word. A contract is a voluntary agreement between parties who trust each other’s competence. It defines what done looks like, not what steps to take. It says here’s the boundary, here’s the acceptance criteria, here’s what we shake hands on. Go.

One form of this contract is technical: a spec, a test suite, a definition of done precise enough for an agent to execute against. The other form is human: an understanding between people about what outcome matters and what good looks like. One is a technique. The other is a way of being.

The old model assumed scarce execution capacity. When building is expensive, you need central planning to allocate it. Prioritization frameworks. Story points. A bureaucracy of estimation. That world made the same bet every planned economy makes: that someone at the top can allocate resources better than the people doing the work.

Agents are breaking that assumption. When execution is abundant and cheap, the bottleneck isn’t allocation. It’s judgment. And judgment doesn’t centralize well. It lives in the people closest to the problem - the ones who know what’s actually broken, what actually matters, what done actually looks like.

So the backlog dissolves. Not into chaos. Into a market. People with context identify work. They define contracts. Agents - or humans, or both - execute against those contracts. No queue. No central planner. Just voluntary collaboration between competent parties who trust each other enough to skip the theater.

This is the software engineering anarchist. Not someone who rejects structure. Someone who rejects imposed structure. Someone who’s realized that the best work happens when capable people make agreements with each other directly, not when they feed tickets into a machine and wait for their number to be called.

The teams already working this way aren’t using a new tool. They’re operating under a new social contract. And like every good anarchist arrangement, it looks like disorder from the outside and runs like clockwork from within.