Mon 26 January 2026

Or: Vibecoding versus LAD

Software development with the assistance of coding agents is incredibly more productive than without - it’s the difference between building a house brick by brick yourself versus having a crew of expert tradespeople helping you.

However, vibecoding isn’t quite the right approach – that’s akin to asking the tradespeople to design and architect your house.

Write The Spec, Let the AI Design?

Most of the recommendations I’ve seen for using coding agents involve writing the design doc and design principles and letting the AI implement the software. You specify, walk away, a swarm of coding agents implements, and you enjoy the results.

I’ve tried this in earnest multiple times and it’s failed every time.

The pattern is: AI writes the software and I’m overjoyed with the incredible pace of implementation. It works! Amazing!

Eventually there’s a problem in the operation of the software. I give the error message or the symptoms to the coding agent, it dutifully researches the problem and tries solutions, but fails with every attempt.

Now I have to deal with it myself. I crack open the code (that I supposedly reviewed before committing) and realize:

I’m a tourist in a land of extremely mediocre code and design.

I’ve allowed a diligent but naive junior developer to design my system. I’m now charged with digging into this idiot’s code, and at every turn I curse his decisions and approach.

To be fair I also curse my own decisions and idiotic approach when I look at code I have written myself, but at least I’m not a tourist. I know what’s where and why it’s there, even if it was placed there stupidly.

Is It Just Me?

I don’t think so. The number of times I’ve asked colleagues and friends why their code does X and gotten the response “I have no idea” is terrifying.

You can let the AI design all your code, but I think you’re just punting the pain down the road. You write code once but you maintain it for a long time, and being a tourist is just setting you up to have your pocket picked that whole time.

Terrible At Architecture

LLMs are great at design of small things - a django model, a function, a database table. They are (currently) very bad at architectural decisions for maintainable software.

Let me convince you with anecdata from the last few days:

Big Picture Blindness

The LLM has implemented 3 new API endpoints, all subtle filtering variants of existing APIs. I ask it: wouldn’t it be cleaner to add filters to the existing APIs? Oh yes you great genius, let me do that right away!

The Rabbit Hole

There’s a subtlety in the way a sub-system has to be written (due to Temporal sandboxes and non-determinism rules). The LLM tries to do a reasonable thing that won’t work because of the subtlety. It correctly identifies the issue, but instead of stepping back and changing approach, the LLM starts to rewrite the entire subsystem piece by piece trying to work around the subtlety, pursuing an approach that will never work.

Plain Stupidity

The LLM decides to build a whole shadow API as an abstraction on top of our existing nice clean API. I still have no idea why. Why not just use the API? Great idea you divine light of wisdom, let me do that right away!

What Works? LAD

LLM Assisted Development. LAD.

Treat the LLM as a diligent, well meaning, extremely hardworking, but naive and inexperienced junior developer. He’s just a lad trying his best to help you, but left to his own devices he’ll make terrible big picture decisions.

Pair program with the LAD. Use the AI to replace typing, not thinking.

You design the software, think deeply about architecture, and plan out an incremental approach to building the system. You include the lad in this process, asking its opinion, asking it to research, having it write the design document.

Then you ask the lad to implement a small step in that incremental plan, look carefully at the code as if you’re pair programming with a human, test the result, and then move to the next step.

Fun and Profit

Developing software this way is incredibly more efficient than writing code yourself. Pair programming with the LAD gives you the positives - you have designed the system, you understand every part of the code - and avoids the negatives of a naive, unknown, and unsustainable design.

AI slop and the low quality of LLM generated software may have made you skeptical, but the answer is not to throw the baby out with the bathwater. Try it this way. Pair program. It is fun and very high quality - frankly the code I’m getting is higher quality than if I’d hand-written it, because the lad is an extremely diligent coder and has an encyclopedic knowledge of almost everything under the sun.