Ralph Wiggum on Crack building a Cathedral
For a very long time I believed that software engineering was a craft in the classical sense. Not in the marketing sense of “craftsmanship”, but in the architectural sense, where foundations are designed to survive storms and time and structure is considered before the first stone is placed. I wanted to be the architect who understands every beam, every joint, every load-bearing wall. We were shaping silicone into something that could think, convincing sand to comprehend through abstraction and logic. There was a certain pride in knowing that every meaningful part of a system had passed through your own hands. Confidence came from proximity to the implementation.
During my time at Equal Experts, people like Steve Yegge and Gene Kim were often treated as lighthouses for the industry. They were not simply authors but orientation points, voices that helped frame how engineering practice evolves. When I encountered “Vibe Coding – Building Production-Grade Software with GenAI, Chat Agents and Beyond”, the ideas felt less like a novelty and more like a continuation of a longer arc. The book outlines a transition from syntax-driven coding toward workflows where intent is expressed in natural language and agents handle generation, testing and refinement. Developers shift from writing every detail toward designing direction, constraints and flow. The logic is straightforward. If abstraction has always moved us closer to intent, then natural language and agent orchestration are simply another step.
My early reaction to agentic development was sceptical. I imagined loops without discipline, models generating variations until something happened to work. The infinity monkey theorem seemed like a fitting metaphor. Given enough attempts, something coherent might appear. That image did not align with my understanding of engineering as deliberate construction. Reading Geoffrey Huntley’s work on the Ralph loop changed the frame. Refinement cycles are anchored in explicit constraints and evaluators. Outputs are generated, checked against acceptance criteria, reintroduced with tighter boundaries and shaped through feedback. What looks like stochastic behaviour begins to resemble a bounded system in which iteration is directed and convergence reflects the design of the surrounding structure.
Steve Yegge’s work with Beads and later GasTown expands that structural approach. Beads treats memory as a first-class concern for coding agents, introducing persistence and shared context that survive beyond a single prompt. GasTown builds on that with a swarm-like orchestration model where multiple agents operate in parallel, validate each other’s outputs and coordinate through shared memory and constraints. The tone in Yegge’s writing is energetic, sometimes bordering on reckless enthusiasm, but the underlying model is deliberate. Roles are defined. Feedback loops are embedded. Coordination rules are explicit. Attention shifts away from writing code directly and toward designing the system that produces it.
For years I equated engineering excellence with proximity to code. The closer you were to the implementation, the more serious the work felt. Handcrafting every line carried a sense of integrity. Delegating generation to a model introduced distance and that distance felt uncomfortable. Yet the history of our field consistently moves in the direction of abstraction. Machine code gave way to assembly, assembly to higher-level languages, manual memory management to managed runtimes, bespoke server configurations to declarative infrastructure. Each layer reduced direct contact with the machine and increased focus on intent. Prompt engineering and agent orchestration extend that trajectory rather than disrupt it.
In my own work this shift has already changed how products take shape. I begin with an agent that performs market analysis to test whether an idea has traction beyond intuition. From there I request structured user stories around capabilities that could form a viable product. Another agent refines those stories into small, coherent packages suitable for independent implementation. These packages enter a Ralph loop where specifications are translated into code, evaluated against constraints and iteratively refined until a working prototype emerges. The pipeline is still early and the economics remain under scrutiny, especially model cost and sustained usage. Even at this stage, the centre of gravity has moved. Less time is spent writing syntax and more time defining invariants, decomposing problems and designing the path from idea to executable form.
The product currently evolving through this workflow is written entirely via layered agents. Questions around scalability, performance under load and long-term cost discipline are unresolved. Yegge himself repeatedly warns that systems like GasTown are not modest experiments and certainly not cost-efficient. They are for people willing to spend serious amounts of Claude credits and accept that they may not fully inspect what is produced.
“It’s also 100% vibe coded. I’ve never seen the code and I never care to, which might give you pause. ‘Course, I’ve never looked at Beads either and it’s 225k lines of Go code that tens of thousands of people are using every day. I just created it in October. If that makes you uncomfortable, get out now.”
A few years ago that statement would have felt irresponsible to me. After building smaller loops and seeing them converge within well-defined constraints, the discomfort is less visceral. What matters is not whether every function passed through my hands, but whether the constraints are sound.
Engineering value has long been associated with manual effort and visible authorship. As abstraction deepens, that association becomes harder to sustain. The role does not disappear, but its focus shifts. Instead of shaping every line, attention moves toward shaping systems that generate lines. Structural thinking remains essential, as do discipline and judgement. The difference lies in where those qualities are applied. For anyone with a clear idea and a solid understanding of the software development lifecycle, the barrier to experimentation is lower than it has been in decades. Complexity has not vanished. It has moved. The work now lies in articulating intent precisely enough that autonomous systems can operate within it without drifting into incoherence.
I’ve been the architect, sat beside the architect and cleaned up after the architect. Everything here was learned the hard way and in production.
