The Omega Programming Manifesto
We've been here before. The first time someone wrote a program, they wrote a hack. The first time a team wrote a program together, they invented engineering. We're at that second moment, again.
Why we are writing this
A new generation of AI tools — Claude, Cursor, Cline, Aider, Codex, and everything that comes next — has changed what one person can build in an afternoon. This is genuinely new, and genuinely good.
It has also produced a default style of work we will call vibe-coding: prompt the model, accept what it gives you, ship it, repeat. Vibe-coding is exhilarating. It is great for prototypes, weekend projects, and demos. It is how most people first encounter agent-assisted development, and the speed is intoxicating.
Vibe-coding does not scale to a real codebase, a real team, or a real customer who is going to call you on Tuesday. The same tools that let you ship a working app in an evening will let you ship five hundred subtle bugs into a system you have to maintain for a decade. We have watched it happen. We have done it ourselves.
Omega Programming is the opposite stance. Same tools. Same models. Different discipline.
What we believe
We believe that LLMs are powerful collaborators and unreliable narrators, at the same time, in the same response. Treating them as either pure magic or pure danger is a category error.
We believe that the failure modes of agent-assisted development are not intelligence failures. They are process failures — the same kinds of process failures that motivated Extreme Programming, Agile, code review, and continuous integration in the first place. Our predecessors solved these problems for human teams. Our job is to solve them for human-and-agent teams.
We believe that an agent without a method is a junior developer with no manager: capable of brilliance, capable of catastrophe, predictable in neither. The fix is not a smarter agent. The fix is a method.
We believe that software written this way still has to be maintained, by humans and by future agents who will read it cold and try to change it without breaking it. We optimize for that future reader.
The four practices
These are the practices that distinguish Omega Programming from vibe-coding. They are not optional. Skip any one and you have something else.
1. Evidence over assumption
Agents do not know — they predict. When the code is broken, the most probable tokens are no longer the right tokens, and confident output becomes a liability. Before changing logic, the agent reads the code, logs the inputs, runs the test, and inspects the actual values it is operating on. "I think this is the bug" is not allowed; "the log says X, so the bug is Y" is.
2. Memory the agents can't escape
Every commit carries a note explaining the why, not just the what. Future agents read those notes before touching the file. Decisions accumulate instead of getting re-litigated every session. The codebase becomes its own institutional memory, and the agent's context window stops being the limiting factor.
3. Specialization, not god-agents
One giant agent that does everything is a junior developer with no manager. Predictable failure modes: context bloat, tool overload, average judgment on every problem instead of expert judgment on a few. We run role-specialized teams — PM, developer, QA, designer — each with a focused tool surface and focused memory. Org charts, not chat threads.
4. Visual feedback loops
Agents that ship anything — code, slides, images, infrastructure — must be able to see what they made and judge it. Render, inspect, iterate, until the artifact is right. Most of the spectacular failures of agent-assisted work are not the agent being wrong; they are the agent being unable to notice it was wrong. Build the loop. Make it cheap. Make it mandatory.
What we are not
We are not anti-agent. We use agents for everything we ship. The point of this movement is not to slow down; it is to ship more, ship better, and ship things that are still standing in two years.
We are not a methodology you have to buy. There is no certification. There is no enterprise tier. The practices either work in your repo or they don't, and you can find that out for free this week.
We are not a single platform or a single tool. The practices are tool-agnostic. They work in Cursor, they work in Claude Code, they work on the command line with a shell script. They work on whatever tool replaces all of those a year from now. The discipline is what carries across.
How we work
Omega Programming is being built in the open, the way Extreme Programming was. We push principles. We ship reference implementations. We argue about the practices in public and we change them when we are wrong.
If you've felt the ceiling of vibe-coding — the moment when "it works on the demo" stopped being good enough — you already understand why we wrote this. Read the practices. Try them in your repo. Push back where you disagree. The point is to figure out, collectively, how to use agents to build software that lasts.
The tools are not going to wait for us to figure this out.
Let's get to work.