Software Engineering, Ripped and Rebuilt

Skip the code review.

That sounds daring and reckless. A year ago, it would have been. But the structure of software economics has flipped. Generating code now costs nearly nothing. You can produce ten thousand lines for under a dollar. The expensive part is no longer writing. It is reviewing, correcting, iterating.

When fixing costs less than preventing, prevention becomes waste.

Two software architects have understood this before everyone else. Geoffrey Huntley and Steve Yegge are tearing down forty years of best practices of software engineering and rebuilding from scratch. Their tools have weird names. Their methods violate everything we were taught. And they are showing results that are making the skeptics uncomfortable.

Loops, Memory and Coordination

Geoffrey Huntley and Steve Yegge are burning down the old ways and building something new in the ashes.

Huntley created something called Ralph, named after Ralph Wiggum from The Simpsons. If you know the character, you know he is not bright. He eats glue. He says things that make no sense. And now his name is attached to the most talked about technique in AI coding.

Ralph is simple. It is a bash loop that runs an AI coding agent over and over until the task is done. The agent tries, fails, tries again, fails again, and keeps going until something works. Imagine hiring an intern, giving them root access to your entire codebase, and telling them to figure it out. No supervision. No code review. Just persistence. This sounds crazy but it is working.

Yegge built Beads, a memory system for AI agents. Think about the shared whiteboard you pull up on Zoom calls. Everyone can see the tasks, the blockers, the priorities. When the meeting ends, the whiteboard stays.

Beads does this for AI agents. Without it, your agent wakes up every morning with amnesia. It has no idea what it did yesterday or what it should do today. You spend the first hour of every session re-explaining context. This is exhausting and wasteful.

With Beads, the agent checks the board, sees what is done, sees what is blocked, and gets to work. Memory persists even though the agent itself forgets everything between sessions. The whiteboard becomes the brain.

Once you have one agent running in a loop, you start to wonder what happens with thirty. This is Gas Town.

Yegge built Gas Town as an orchestrator. It coordinates up to thirty AI agents working in parallel. There is a Mayor who talks to you. There are workers who write code. There is a system that prevents them from stepping on each other.

Think of it like Infosys, but the developers are robots. You manage tickets, not people. You describe outcomes, not implementations. The agents figure out the rest.

Huntley has his own version called Loom. Same idea, but he owns the infrastructure. Gas Town is outsourcing. Loom is building your own global captive center, staffed with agents

Bottlenecks Moved

Best practices in software were designed around a specific bottleneck: humans are slow, expensive, and forgetful.

Code review exists because human mistakes are costly to fix later. Branches exist because humans working on the same file will overwrite each other. Documentation exists because humans forget what they did last month.

But the bottleneck has moved. Generating code is now nearly free. The expensive part is no longer writing. It is iterating on what the AI produces.

When the bottleneck shifts, the old practices become overhead. Code review slows you down when the cost of fixing a mistake is cheaper than the cost of preventing it. Branches add friction when merging is no longer a human coordination problem. Documentation is less valuable when you can regenerate context faster than you can read what you wrote.

Ceremony Was the Problem

Huntley does not review code anymore. His agents push directly to master. No branches. Deployment happens in under thirty seconds. When something breaks, feedback loops feed back into the active session and the system self-repairs.

This violates everything we were taught. It feels reckless. It feels like chaos.

But think about what he actually removed. He removed the ceremony. The pull requests, the approvals, the waiting, the meetings about the code instead of the code itself. All of that existed to coordinate humans. Without humans in the loop, the coordination overhead becomes pure waste.

Yolo commit sounds like a joke. It is actually a design principle. If fixing is cheaper than preventing, then preventing is the wrong strategy.

Hallucination is Melting Ice

People worry about AI hallucinations. The models make things up. They confidently assert falsehoods. This feels like a fundamental flaw.

But hallucination is a melting ice problem. It is real today. It will be smaller tomorrow. It will be negligible soon. The models are getting better at an extraordinary rate.

Eighteen months ago, skepticism was reasonable. Since then, scaling laws have held. Most recent inflection with Gemini 3 Pro / Codex 5.2 / Opus 4.5 has quieted the loudest critics.

Building your entire workflow around avoiding a problem that is actively shrinking is like refusing to buy a refrigerator because ice melts.

The people who wait for perfect models will be waiting forever. The people who build systems that tolerate imperfection and improve through iteration will win.

Agents Do Not Care About Your Abstractions

This is the part that unsettles experienced engineers the most. Decades of software architecture have been devoted to creating clean abstractions. Layers, interfaces, separation of concerns. We built elaborate structures to make code comprehensible to human minds.

Agents do not care. They do not need your carefully designed interfaces to understand the code. They read everything. They hold more context than any human can. The abstractions that helped humans navigate complexity become unnecessary indirection when the reader has unlimited attention.

This does not mean abstractions are worthless. It means their purpose has changed. Abstractions that help agents work faster are valuable. Abstractions that exist purely for human comprehension are overhead.

The uncomfortable truth is that most of what we call “engineering discipline” was really just coping mechanisms for human limits and those limits are no longer in the loop.