How AI made me twenty times faster at making mistakes

Hello, I'm Brenden. And I'm an addict.

It's been seven months since I last wrote a line of code myself.

Before that, I was hooked. Not because I'm good at developing. I'm not. But I loved writing code, and more than that, I loved good code. Code that scales. Code you can put more people and more features on. Bounded contexts. DDD.

For some of us, OCD-DDD.

And as a CTO, I had to admit something uncomfortable. I liked being in the code a little too much.

I could think up an architecture in minutes. Turning it into reality took days, weeks, sometimes months. And an alarming amount of management.

I had become my own bottleneck.

Then AI showed up.

Suddenly, I was twenty times faster. Twenty is an assumption. Feel free to challenge it. I won't change it.

Unfortunately, the world around me stayed at one times.

My ideas still waited for the weekly refinement meeting. My code still waited for someone to review the pull request. People kept asking: if AI makes you that much faster, why isn't the project going faster?

Because I was faster. The company wasn't.

Collecting Infinity Stones

Yes, I'm doing an MCU metaphor. You were warned by the title. Oh wait, you weren't.

I had three stones already. Coding, reasoning and leadership. The ability to build things, figure out what to build, and convince other people that building them was a good idea.

AI gave me a fourth: parallelism. Instead of doing one thing twenty times faster, I could work on several things simultaneously. While one project waited for a review, a meeting or a decision, I could move another forward.

Then memory.

Remember Limitless? Bradley Cooper takes a pill and suddenly remembers every conversation he's ever had. That's what transcripts did to my technical audits. Notes are summaries, and summaries carry bias. A transcript doesn't care what I thought someone meant. It says what they said.

And my brain has a context window too. Mine apparently compacts after lunch.

Then perception. Across interviews, I could find contradictions. In code walkthrough recordings, I could inspect things I'd missed when someone scrolled past them.

And finally, the seventh stone: borrowed expertise.

Remember The Matrix?

"I know kung fu."

With an LLM, you say "you are now a machine learning engineer" and off it goes. I'd never built a machine learning model myself. I could now build machine learning applications. I knew practically nothing about 3D modeling. I could now build 3D worlds.

Was that wise? I'll get back to you on that.

With all seven stones, I had reached a rather exciting conclusion.

The only bottleneck left was imagination.

Anything I could imagine, I could build.

I could end this post here. I won't.

Then I met a bird

I thought I had become an android-powered human.

Then I met a bird.

I'd come across research where someone had annotated bird body parts. Beak here. Wing there. Probably by hand. Probably for a thousand birds or so.

There are about 11,000 species.

The sensible answer was: later.

Android-powered me said: hold my beer.

First attempt: a vision-language model. A VLM can understand that a bird has a wing. It can even tell you roughly where that wing is. But understanding an image and producing pixel-accurate coordinates are two very different things.

The polygons came back shifted. Close. Not close enough.

So I asked Claude.

I've led data science teams for six years. I had never built a machine learning model myself. To me, it's magic. So when Claude said "sure, I can do that", I believed it.

It suggested Segment Anything. SAM keeps the link between pixels and output. You don't prompt it with words, though. You give it a point or a box. Scatter points all over the bird and it returns tail, legs, breast, wing, eye, beak.

Solved.

Except SAM has no idea it's looking at a bird. Shapes, no names. Fine. The VLM already knew what a wing was. It just couldn't draw one.

Then nature sent me a blackbird.

A blackbird is, and I cannot stress this enough, black. Plenty of contrast with the background. Almost none inside the bird. Legs, beak and tail came out fine. The rest was one dark blob.

Back to Claude. More AI. Edge detection. Other SAM variants. Other parameters. Other algorithms.

You can feel the spiral coming. You might have been there.

Then it hit me. My fault, all along. I had asked the wrong question. I didn't need better segmentation. I needed more pieces.

Machine learning has a deeply unglamorous trick for that called clustering. Cut the image into fragments. They make no sense on their own. Doesn't matter. I gave the VLM 114 fragments plus the SAM masks and asked it to name each one. Merge the ones with the same name, take the centre of each polygon, done.

And it worked. Not perfectly. But well enough.

I could end this post here.

I wrote a blog post instead. Then I looked at the bill.

Roughly $0.25 per bird. Across 11,000 birds, that's $2,750.

For identifying bird parts.

My precious

Rereading my own blog post, I found a sentence admitting it felt like brute force. That there was probably a more elegant solution in some research paper I didn't have time to read.

Claude can read research papers.

I had forgotten.

So I asked it to research existing approaches instead of improving mine.

It found Grounding DINO: give it an image and the word "head", and it gives you a box where the head probably is. And SAM, which I hadn't thrown away, happily accepts boxes.

No clustering. No 114 fragments. No reasoning model reconstructing a wing from a collection of polygons.

Just two models doing what they were designed to do.

I had spent all that time optimising a representation that didn't contain the answer.

And now I had to throw my beautiful pipeline away.

I'd spent days building it. Debugging it. Improving it. Understanding it. I'd even written about it.

It was clever. It was mine.

My precious.

Turns out I don't only get attached to code. I get attached to ideas.

Anyway.

No LLM. Ran it on ECS. All 11,000 birds.

$25.

I could end this post here. But apparently, one expensive lesson wasn't enough.

One does not simply build a 3D world

Machine learning, I at least knew a little about. Could I pick a domain I knew nothing about and still build something I was proud of?

I'm bad at front-end. The hardest front-end I can think of is 3D.

So, naturally, 3D.

I started building Cameolot, a multiplayer party game. Blender for the assets, through an MCP someone kindly built so Claude could be the artist I'm not. Three.js as the engine. Rapier for physics, so you neither fall through the world nor float off into space.

And because a world is boring on your own, a game. Capture the flag. Bots. LLMs are far too slow for bots, so each one has a priority list, checked thirty times a second, picking the most important thing to do. Somebody has our flag? Combat. Flag carrier down? Bring it home.

At some point, Claude asked me to pick one of four options. You know the moment. I picked one. I don't remember which.

It doesn't matter. They were all wrong.

Two billion tokens later, I had a room where the window frames floated slightly away from the walls. Fixing it meant redoing every single window.

Isn't a window a generic thing, Claude?

"Sure. You just never asked."

Blender supports modular kits built from references. Change the window once, it changes everywhere. Oh, and you need an extra file where all the rooms are fitted together, or you get gaps.

Claude didn't mention it. I didn't know. I was vibe coding.

Two billion tokens to discover object references.

So that went well.

Jumping felt off, too. Claude checked by taking a screenshot. One second after the jump had finished. Of course it looked fine.

I had to output the jump as text before Claude could see what I saw.

A steering wheel doesn't make a Volvo

Claude knew Blender. It knew the modeling techniques, modifiers, rigging approaches and export formats. It could explain each one in considerable detail.

But when it asked me to choose between them, I had no idea what the right answer was.

I had borrowed expertise. I hadn't acquired judgment.

Adding knowledge to an LLM doesn't make it a true engineer. Just as adding a steering wheel to my desk doesn't make it a Volvo.

And this wasn't limited to unfamiliar domains.

I started noticing the same pattern in software architecture. In greenfield and brownfield alike, AI repeats what it sees.

Start with hello world. Add a notification when your house uses too much energy. Then your home battery. Then your car. Every prompt politely continues the architecture that's already there, and by the time you notice, you have god classes.

I asked a different model to review my game. Its verdict: a state machine without the state machine.

Fair.

The refactor turned my god class into a god facade.

Progress.

The only thing that fixed it was me designing the architecture. Three state machines. That file gone. Nothing more. Then it could act on it.

And even with multiple AI reviewers, things weren't necessarily better. They could all approve the same bad decisions.

We automated agreeing with ourselves.

The bottleneck moves again

Coding was my bottleneck. AI removed it. Then the organisation became the bottleneck. Parallel agents helped with that.

Then domain knowledge became the bottleneck. Borrowed expertise helped with that.

But every workstream eventually needed someone to decide whether the result was any good.

Review. Judge. Decide.

And there's one more bottleneck nobody warned me about. My head. I'm faster, but my brain isn't bigger. At the end of the day, I'm tired in a way I wasn't before.

The bottleneck hadn't disappeared. It had moved.

Again.

Vibe coder or reasoning engineer

On one end, the vibe coder: keep prompting until you're stuck in a loop. On the other, the reasoning engineer: research, decide, judge.

It's a spectrum, not a team you join. Throwing together a tool you'll use once? Vibe away. Just notice when you're sliding too far to one side.

The models will get better. Some of this advice will probably look ridiculous six months from now. But for now, understanding the problem and challenging the architecture are what keep me from spending another two billion tokens discovering something I learned twenty years ago.

And there's something else I hadn't expected.

AI didn't just make me build faster. It made me make mistakes faster.

I could spend weeks building the wrong architecture before. Now I can do it before lunch.

Which sounds terrible.

Except I also get to discover why it's wrong, throw it away, and try again. Sometimes several times in the same afternoon.

I wasn't just failing faster. I was learning faster.

Seven months clean

I haven't written a line of code myself in seven months. I've built machine learning pipelines without being a machine learning engineer. I've built 3D worlds without being a 3D artist.

Both things work. I cursed a lot.

I thought I'd finally kicked my coding addiction. Turns out I don't need to write the code to become emotionally attached to it.

AI didn't remove the engineer. It changed where the engineering happens.

And apparently, it made me a more efficient idiot.

Now I can end this post.