Web Directions Year round learning for product, design and engineering professionals

Everything Is a Factory

The age of hand-crafted software is ending. Not because humans are becoming obsolete, but because the economics have shifted so radically that we're building the wrong thing when we build by hand.

For decades, software development meant hiring people to write code. You'd bring in engineers, they'd spend months building features, and you'd hope the result was good enough to ship. It was slow, expensive, and fragile. A single person's absence could halt a team. A architectural misstep early on could propagate through a codebase for years.

Then something changed. AI systems became capable enough to write code. Not perfectly, but iteratively—taking a prompt, generating an attempt, running it against tests, and refining until it works. The implications are staggering: what if you could bypass the hiring cycle entirely? What if you could specify what you wanted in plain language and have a system autonomously iterate toward a working solution?

This isn't science fiction. It's happening now, and Geoff Huntley's work traces the path from the earliest experiments to production systems operating at scale.

The Ralph Wiggum Loop—a brute-force technique where AI agents keep trying and testing until they get things right—was a proof of concept. It showed that you didn't need perfect prompts or clever architectural tricks. You just needed enough iteration and feedback. Then came Loom, which took that insight and turned it into an actual software factory: a system that orchestrates AI agents to build software at speed and scale.

But here's what makes this genuinely interesting: this isn't just about replacing human labour with automation. It's about transforming the role of the engineer. When code becomes a commodity—when you can generate working code from specifications—engineering becomes orchestration. The valuable work shifts from "write this feature" to "specify what matters," "evaluate what was built," and "refine until it's right."

Huntley's recent work on the Cursed programming language takes this further: an entire compiler written by AI loops, with no human hand-coding of the implementation. It's a demonstration that AI-driven factories can handle arbitrary complexity. They're not limited to simple, cookie-cutter problems. They can tackle infrastructure, systems programming, and novel architectural challenges.

The implications ripple outward. Teams become smaller and faster. Time-to-market collapses. The barrier to building software drops dramatically—you don't need deep expertise in every domain, just the ability to clearly specify what you want and evaluate whether it works.

There are real costs too. The craft that many engineers love—the flow of writing code, the problem-solving depth, the ownership of a carefully constructed solution—that changes. The role demands different skills. Some people will thrive; others will feel untethered.

But the momentum is real. Once software factories work this well, going back to hand-crafting is like going back to hand-weaving after the industrial loom. The economics don't allow it.

Geoff Huntley has been thinking about this transition longer than almost anyone. His journey from the Ralph Wiggum Loop through Loom to today offers crucial perspective on what's actually changing, what's hype, and what the engineering role genuinely looks like when everything becomes a factory.

Catch Huntley's keynote at AI Engineer Melbourne 2026 (June 3–4) to explore what software development becomes when humans stop writing code and start orchestrating its creation.