Fred George
What manager allows you to rewrite core systems three times? No manager. That's why we don't have managers.
Writing code since 1968. 70+ languages. 50+ years. Co-developed early GUI elements at IBM, credited as a grandfather of the Eclipse IDE, founded ThoughtWorks University, and pioneered microservices architecture years before the term existed.
Core Thesis
Eliminate every role that doesn't write code or understand the domain — then watch what happens when developers own everything.
Programmer Anarchy
Post-Agile process developed at Forward Internet Group (~2011). Two roles survive: people who understand domain needs and developers who implement solutions. Everything else is eliminated.
- "Anarchy" from the Greek — without rulers, not without rules
- Developers select their own work at daily standup, no assignments
- Only business outcomes are measured, never technical metrics or velocity
- Disagreement is expected and productive — resolve by building, not debating
- Failure is normalized: "What if you were guaranteed not to fail?"
- 40 developers produced 1,076 commits, 577 deploys across 86 projects in 7 days — something new to production every 3-5 minutes
The Truth
You don't need non-developer roles that tell software engineers what important to work on or check their work.
| Eliminated Role | Why |
|---|---|
| Project managers | Developers own delivery end-to-end |
| Business analysts | No "experts" in fuzzy problems — developers talk directly to users |
| QA / testers | Developers test their own code; continuous deploy is incompatible |
| Iteration managers | No sprints, no ceremonies beyond daily standup |
| Programmer managers | Group responsibility replaces individual leadership |
Retained: Ambassadors (facilitate cross-team), Lead developers (mentor, not manage), Concierges (handle logistics).
Disposable Code
The best execution of the best idea always wins.
- Services under 100 lines. Ideally under 20. If a description uses "and," split it
- Rewrite rather than maintain — eliminates technical debt as a concept
- Old services expire; new ones are written in minutes
- Multiple services can bid to handle the same work — natural selection picks the winner
How can this work with smart contracts on the blockchain?
Rapids, Rivers, Ponds
The event-driven architecture that makes anarchy possible.
| Layer | What It Is | Speed |
|---|---|---|
| Rapids | Core event bus carrying all events (Kafka). Single truth | ~250,000 messages/second |
| Rivers | Filtering services pulling relevant messages (ZeroMQ) | ~25,000+ messages/second |
| Ponds | Local databases per service. No shared databases | At rest |
Pinball architecture: Messages bounce through the network, each service adding one data point, until the information gap is filled. Smart endpoints, dumb pipes — all intelligence in the services, none in the routing.
Developer Autonomy
- "Developer does it all" — from identifying the problem to monitoring in production. No handoffs
- Hire self-learners (GitHub activity, open-source, language breadth) with delivery passion
- ~60% of the team should be polyglot — hire developers, not "Java developers"
- Seating follows Tom Allen's law: communication probability is inversely proportional to the square of distance. Double the distance, quarter the communication
Agentic Parallels
The structural map between Programmer Anarchy and agentic coding is direct:
| Programmer Anarchy | Agentic Equivalent |
|---|---|
| Self-organizing developers | Autonomous agents selecting tasks |
| No central manager | No central orchestrator — shared context coordinates |
| Disposable code (< 100 lines) | Disposable outputs — regenerate, don't maintain |
| Competing services | Multiple agents attempt the same task; best output wins |
| Rapids / Rivers / Ponds | Event-driven agent communication |
| Smart endpoints, dumb pipes | Intelligence in agents, not in routing infrastructure |
| Pinball architecture | Multi-step agent workflows, each adding one piece |
| Rewrite don't maintain | Agents rewrite from scratch rather than patching |
| Business metrics only | Measure output quality, not process compliance |
| Fail fast, fail cheap | Agent tasks are cheap to retry; failure is signal |
| Developer owns idea to deploy | Agent owns task from prompt to artifact |
| No QA department | Agents self-verify; quality built in, not inspected after |
The Cynefin framework (via Dave Snowden) is the decision gate: 85% of problems start in "disorder." Anarchy and agents thrive in the complex domain — where no expert exists and the only way forward is to experiment rapidly.
Continuous Delivery
- Ship small: the longer the feedback loop, the more assumptions compound unchecked
- Early delivery surfaces real requirements — what customers say they want and what they actually use diverge quickly
- Continuous delivery is a discipline of humility: you don't know what good looks like until you see someone use it
- Customer satisfaction is the only lagging indicator worth tracking; everything else is a proxy
- The secret assumption: someone has validated the problem being solved — most teams never check
Links
- Programmer Anarchy — GOTO 2012 — The original talk
- Implementing Programmer Anarchy — GOTO Chicago 2014 — Scaling the model
- It's Not Just Microservices — GOTO 2016 — Rapids, Rivers, Ponds
- Microservices — GOTO 2015 — The grandfather's perspective
- SE Radio Episode 253 — Developer Anarchy deep dive
- Developer On Fire #279 — Decision-making
- Fred George Presentations — SlideShare archive
- Microservice Workshop (GitHub) — Build your own
- Martin Fowler — Microservices — Canonical article citing George's early work
Context
- Microservices — The architecture George pioneered
- Agent Protocols — Agentic communication patterns that echo Rapids/Rivers/Ponds
- AI Coding — Where disposable code and agent autonomy converge
- Process Optimisation — Anarchy as the ultimate process reduction
- Performance — Customer satisfaction as the only measure that compounds
- Platform — The substrate that makes continuous deploy possible
Questions
If agents are autonomous developers that select their own work, fail cheap, and rewrite instead of maintain — what management ceremony survives?
- At what team size does programmer anarchy break — and does the same threshold apply to agent swarms?
- If competing services use natural selection, what happens when the "wrong" service wins by speed rather than correctness?
- Which of the eliminated roles (PM, BA, QA) will AI agents recreate under a different name — and does that prove George right or wrong?
- When disposable code meets regulated industries, where does the rewrite-don't-maintain principle hit a wall?