Micromanaging AI Is a Terrible Strategy

I came across Simon Willison’s article on using LLMs for coding and while there’s solid insight in there, one part stood out as flat-out bad advice:

“Tell them exactly what to do.”

I pushed back in this X thread, and @simonw asked “why?”. Fair question—here’s why that approach doesn’t work.

AI Is a Pair, Not a Puppet

I’ve spent decades working with agile engineering teams, extreme programming, and pair programming. One thing I’ve learned? The best results don’t come from dictating every step—they come from collaboration.

If two senior engineers are pairing, does one just bark orders while the other types? No. They have a conversation. They refine each other’s ideas. That’s where the magic happens.

The same applies to AI-assisted development. If you treat AI like a junior dev who needs micromanaging, you’re not using it effectively. The worst pair programming habits—assuming you already know the best solution, over-controlling the implementation, failing to trust your partner—translate directly into bad AI usage.

Why People Want to Micromanage (and Why It’s Slowing Them Down)

I get it. AI still makes mistakes. When you’re on a deadline, it feels safer to spoon-feed it precise instructions. You don’t want it going rogue and breaking your code.

But here’s the reality: when you micromanage AI, you’re not just avoiding errors—you’re limiting what it can do for you. You’re turning a potential thought partner into a dumb autocomplete.

Instead of obsessing over control, shift the approach:

Set the problem up. Explain the goal, the constraints, and what matters.
Discuss possible solutions. Let the AI propose approaches, then refine together.
Iterate in small batches. Let it take a first pass, review its reasoning, tweak as needed.
Build trust over time. Learn how it thinks, and let it help you think better.

This is what I call AI-native development. AI isn’t just a code generator—it’s an augmentation tool.

The Engineers Who Thrive With AI

The devs who get the most out of AI aren’t micromanaging it. They’re navigating—steering high-level decisions while letting AI handle execution details. They work in small increments, get fast feedback, and let AI accelerate their thinking, not just their typing.

The ones struggling the most? They fall into two camps:

The skeptics – Won’t let AI generate anything substantial because “it’s not as good as me.”
The YOLOs – Expect AI to generate entire features with zero oversight, then rage when it breaks things.

Both are missing the middle ground where AI actually accelerates development.

Stop Babysitting AI—Start Building With It

I stand by my take: “Tell it exactly what to do” is a terrible AI coding strategy. The best results happen when you treat AI like a thinking partner, not a code monkey.

If you’re skeptical, try this: Next time you need to build a feature, don’t just command the AI—talk to it. Treat it like a strong engineering pair. Guide it instead of micromanaging it.

And here’s where this is really headed: AI isn’t just a pair. Over time, it’s evolving into a co-architect—one that helps shape systems, not just implement them. The sooner you stop treating it like an intern and start treating it like a collaborator, the faster you’ll build, and the better your software will be.