Earlier this year I changed one line in the backend of a marketplace I run. Then I waited for CI to recompile the whole Haskell project.
That wait is why I let agents rewrite the backend in Go. I didn’t write the code, and I didn’t review it line by line. I couldn’t, as there was far too much of it. First, the agents wrote more tests to capture how the old system behaved, and I used mutation testing and coverage analysis to make sure those tests would actually catch a change in behaviour. Those tests became a characterization of the old system: they pinned down what it actually did, bugs included. Then the agents rebuilt the system against them, on their own.
The marketplace has about half a million registered accounts and several thousand active users a month in Germany and Austria. For the past three months, the Go backend has served all of its traffic without an outage. In a load test on five public endpoints, the Go backend handled 1.5 to 7 times as many requests per second and used 32 MB of memory instead of 218 MB. (It is also much bigger. The Haskell version was a third smaller, but nobody reads the Go version anyway, which is more or less the point of this post.)
A few years ago I would have called this reckless. To be honest, part of me still does. Getting here gave me a small identity crisis as an engineer, and this post is my attempt to sort out what I actually believe now.
Every slow loop I’ve known
I started at sixteen with an Ausbildung, Germany’s three-year vocational training: you work in a company, with blocks of school in between. Mine was at Matrix Advanced Solutions, a small AI company that used neural networks and genetic programming for industrial, pharma and biotech problems.
For security reasons, our coding machines had no internet. A second machine was for browsing, and a switch box connected both to one monitor and keyboard, with a three-to-four-second delay every time you switched. You read the documentation, memorised what you could, switched, typed two words, and switched back. It was really annoying, but it worked. When looking something up is expensive, you learn things by heart.
Later, at Qlaym and then at 2-FIFTY-5, I found Chiusano and Bjarnason’s Functional Programming in Scala and fell in love with its algebraic abstractions: structures like monoids and monads that follow laws, so you can write elegant, generic code that hides the implementation details. At 2-FIFTY-5 I got to pick the stack for a distributed system. On good days I wrote a thousand lines of dense code, tests included.
At Kadena I worked on the Pact smart-contract language and later on parts of Chainweb, both in Haskell. Haskell’s tooling was still weak back then. In large codebases, jump-to-definition only partly worked, so you got fast by grepping and by remembering where things were. (To be fair, the Haskell Language Server has become quite good since.) Learning a new codebase meant rebuilding the whole system in your head first. That was also when I first tried AI on real work: on the code at Kadena, and on the proofs for my PhD (more on that below). My verdict back then: it fills in some blanks, and the hype is overstated.
At Cantor8 that changed. I used Claude to trace production issues: to find dependencies, read protocols and come up with hypotheses. It worked well, with me still doing the review as a human, line by line. But the bottleneck had moved somewhere else. Pull requests sat unmerged, and decisions waited for the next meeting. I really liked the team and the mission, but I was frustrated by the speed, so in the end I left.
Then, more or less by accident, I took over the marketplace. Customers and partners relied on it, but it carried a lot of technical debt and hadn’t seen real updates or new features in years; the last major work on it was about six years earlier. At the same time, the frontier models kept getting better, so the marketplace became my personal testbed for building software with them. First I used models to brainstorm. Then I gave them exact function signatures and test cases and reviewed every line. But 5,000 to 10,000 lines a day is easy to generate, and on some days it was far more. Nobody reads that much. Within weeks I was skimming. Soon I couldn’t find my own files.
That was the point where I had to accept something uncomfortable: agents produce code much faster than any human can properly review it. And it isn’t only new lines. Refactoring a large part of a system, or rewriting it completely, has become cheap too. Before, you simply didn’t touch code that worked. Changing it, rolling it back or throwing it away was a big investment, so you thought hard up front and hoped you were right.
Now being wrong is cheap. You can try something, see that it doesn’t work, and redo it the same day. What is still expensive is not noticing. Looking back, every slow part of my career was exactly that delay between making a mistake and finding out: three seconds at a switch box, minutes for a Haskell build, days for a pull request. With agents, that delay can be close to zero, or it can be never. It depends on what checks the code.
Being sure is not being right
In parallel, my colleague Jonas at Sartorius, a biotech PhD working in automation, talked me into finishing my degree and starting a part-time PhD at the University of York. The topic is a small graph programming language whose proofs had only ever been done with pen and paper. My job is to mechanise them in the interactive theorem provers Isabelle/HOL and HOL4.
It happens to me again and again. A proof looks complete on paper and convinces everyone who reads it, and the prover won’t accept it. The idea is usually fine. But somewhere a step quietly relies on an assumption that nobody wrote down. Every larger piece of work I’ve formalised has turned up a few. Usually they aren’t errors. They’re things an expert takes as given and never writes down, and a prover takes nothing as given.
I now see the same thing in the Go marketplace: definitions of the same concept that conflict from one file to the next. Each one is reasonable on its own. Together they’re wrong, and no single file shows it.
My former CTO, John Wiegley, turned this idea into a working check for real software. For years he has maintained Ledger, a double-entry accounting tool written in C++. Recently he wrote down what Ledger actually means, as mathematics proved in Lean 4, and built from those definitions an executable oracle: a program that reads ordinary journal files and computes the balances the mathematics says they should have. Now the program has to agree with the mathematics, and every disagreement is a mistake found early.
Working with provers taught me the most important lesson of my career. Humans are wrong all the time, even when we’re sure, and so are agents. That part I can live with. But agents work around the clock, so they can also find and fix their mistakes around the clock, as long as something tells them they’re wrong.
The problem is how long we stay wrong.
So I stopped reading the code
Agents now produce code faster than anyone can review it. I tried to keep up for weeks, and what I ended up doing was skimming and calling it review. That felt diligent, and it mostly slowed things down.
There are still areas where thorough review is mandatory, and rightly so. In mission-critical software, a small bug in production can cost lives. In hardware design, a flaw in a chip is extremely expensive once it is manufactured, and it damages your reputation for years. There, you write little, and humans check every line against the design.
Most software isn’t like that. The amount of code added and changed in ordinary applications is growing fast, and most of it runs web apps, shops and marketplaces, where a bug in production costs a day of fixing, not a life or a production run of chips.
Where exactly “critical” starts is a question I want to think through properly. I’d like to write a separate post about it, with some guiding principles for deciding when review is still worth the cost.
What checks the code instead
If humans don’t read the code, machines have to check it. They have two jobs: make sure what worked keeps working, and check every new change.
In the marketplace, I needed exactly that. I had lost track of my own files, and I kept finding conflicting definitions across the Go code. My own eyes were no longer enough to tell me when the agents got something wrong. This is what I’ve ended up with so far:
- Every check has to prove it can fail. There are 30 scripted checks and 8 custom Go analyzers, covering layering, database boundaries and no leaks of internal information. Each comes with a test that shows it catches what it claims to catch. I don’t trust a check I haven’t seen fail.
- Skipping a test fails the build. Agents like to quietly skip tests that get in their way. A census counts skipped tests, and only skips listed explicitly are allowed.
- The UI is checked like code. An accessibility scan runs on every passing UI test. A phone-fit check fails a page if it scrolls sideways, has a tap target smaller than 44 pixels, or puts the main button below the first screen. A lint rejects hard-coded colours.
- Simulated users walk through the product. Subagents follow predefined flows through the application as different personas, for example an 18-year-old with little IT experience, in a rush, on a phone. They report where a step is unclear or doesn’t follow logically from the one before. This doesn’t replace feedback from real customers, but it catches the confusing parts before they do.
- Pages can only get faster. Lighthouse has to score 100 in every category, on phone and desktop, in light and dark mode. Every page has a size budget just above its current size, so it can shrink but never grow. Nobody wrote “fast” into a ticket, but on customer-facing pages, speed drives conversion.
'categories:performance': PERFECT,
'categories:accessibility': PERFECT,
'resource-summary:document:size': atMost(documentBytes(route)), To be fair, this has costs. The full Lighthouse run takes hours: 910 measurements across 106 routes. Writing code is no longer the slow part; knowing that it works is. I think that is the number to watch now: not how long something takes to build, but how long it takes to know it works.
What’s left for the engineer
Most features look right on a whiteboard. Whether one actually helps, and whether people use it the way you intended, you usually only find out once they can use it. In my experience, that second part is where reality differs most from the plan.
I never liked agile when I was writing code by hand, and I never saw a team estimate a sprint correctly. But I’ve come to think agile was wrong about code and right about products: ship, talk to your customers, check whether it makes their lives easier, and repeat. AI finally makes that loop work, because the unit of iteration is now the day, not the sprint. A wrong feature caught after one day beats a right feature delivered after a week.
So what makes an engineer senior, if code is cheap? I think it’s ownership: taking a feature from the first conversation with a customer, into the product, through checking whether it actually helps, to making the hard call to roll it back when it doesn’t.
And cheap code doesn’t make coordination cheap. From what I have seen, teams work best at four to six people; beyond that, alignment gets worse faster than output grows. The research agrees on the direction, if not on my exact numbers. Teams of three to six or seven do best in studies of work groups (Wheelan, 2009) and IT projects (QSM), output per developer falls as open-source teams grow (Scholtes et al., 2016), and people in larger teams perform worse individually (Mueller, 2012). How teams of people and agents should work together is the subject of Part 2.
What I don’t know yet
I’m confident about the marketplace. I’m much less sure about four things:
- Where does “critical” start? When are human review and slowness still worth the cost?
- What happens when we depend on the model providers? We’ve handed our mental models of our own systems to a handful of companies. If they raise prices or their models get worse, what then?
- What happens when models learn from AI-written code? More and more of the code models are trained on was written by models. Does that slowly lower the quality of what they produce?
- What if the model itself is attacked? If someone compromised a model provider, or poisoned its training data, could the generated code quietly contain security holes, in every codebase that uses it?
The first two will get their own posts. The last two I honestly can’t answer yet.
What I do believe: correctness doesn’t come from being right up front. It comes from how quickly you find out you’re wrong. Every slow part of my career slowed exactly that loop: a three-second switch box, a Haskell compile, a pull request nobody merged. AI has made building nearly free. What’s left is how fast you learn.
If you’re going through the same shift, I’d really like to hear how you check code you didn’t read.
This is Part 1 of a series on how engineering work is changing. Part 2: how teams and products change when code is cheap.
References
- Mueller, J. S. (2012). Why individuals in larger teams perform worse. Organizational Behavior and Human Decision Processes, 117(1), 111–124. doi:10.1016/j.obhdp.2011.08.004
- QSM (2025). 4 key studies on team size. Industry analysis of 491 IT projects. qsm.com
- Scholtes, I., Mavrodiev, P. & Schweitzer, F. (2016). From Aristotle to Ringelmann: a large-scale analysis of team productivity and coordination in Open Source Software projects. Empirical Software Engineering, 21, 642–683. doi:10.1007/s10664-015-9406-4
- Wheelan, S. A. (2009). Group size, group development, and group productivity. Small Group Research, 40(2), 247–262. doi:10.1177/1046496408328703