What is AI-Directed Engineering?

There's a quiet line that most people working with AI tools haven't noticed they crossed. On one side, AI helps you write code faster. On the other, AI writes the code and you direct it. They look similar from the outside: there's a human, there's an AI, there's a repository getting bigger. But the day-to-day is completely different, and so are the skills that make you good at it.

The second mode is what I call AI-directed engineering, and over the last few months it has become how the work actually gets built here: client sites, products, even the automation that keeps a one-person business running.

AI-assisted vs. AI-directed

AI-assisted engineering is the world of autocomplete. You're in the editor, you're writing the function, and a model suggests the next few lines. You're still the one doing the engineering. The AI shortens the distance between your intent and the characters on screen. It's genuinely useful, and for a long time it was the whole story.

AI-directed engineering flips the roles. You describe the outcome, the constraints, and the taste. An agent reads the codebase, makes a plan, edits files, runs the tests, reads the failures, and tries again. You're not writing the lines. You're deciding what "done" means, reviewing what came back, and steering the next move. You've moved up the stack from author to director.

The tell is simple: in AI-assisted work, the bottleneck is how fast you can type. In AI-directed work, the bottleneck is how clearly you can think.

What the director actually does

Directing isn't sitting back. It's a different kind of work, and most of it happens before and after the agent runs, not during.

• Specify the outcome, not the implementation. "Add a newsletter signup that stores emails GDPR-compliantly and double-opt-ins" is a direction. "Add a useState hook here" is typing. The more precisely you name the outcome and its constraints, the less you have to correct later.
• Set the guardrails. A good agent works inside boundaries you define: the stack it's allowed to use, the patterns to follow, what counts as a test passing, what it must never touch. In sebb.pro's repos these live in plain CLAUDE.md files the agent reads before it starts.
• Review like an editor, not a proofreader. The interesting question isn't "is this line correct", it's "did it solve the right problem, in a way I'd be willing to maintain." You read the diff for intent and architecture, and you push back when the shape is wrong.
• Close the loop. The biggest multiplier is giving the agent a way to check its own work: tests, a type checker, a running app it can poke. An agent that can see its failures fixes most of them before you ever look.

Why this matters for a one-person business

I run a Gewerbe in the Allgäu: client web development plus a SaaS product. There is exactly one of me. AI-directed engineering is the only reason the workload is sane.

The honest economics: the parts of the job that used to eat the day (wiring up boilerplate, migrating a config, writing the fifth contact form of the quarter, chasing a type error across a refactor) are now directed rather than done by hand. That frees the hours for the parts that don't delegate: understanding what a client actually needs, making the taste-level calls, and owning the legal and data-protection decisions that are mine to own regardless of who wrote the code.

The same practice reshaped operations behind the scenes. A handful of small agents run on a schedule and handle the recurring overhead: summarising what changed across projects, triaging the inbox, watching error rates. None of those were written by hand either; they were described and directed into existence. The business runs on the same practice it sells.

What AI-directed engineering is not

It is not "the AI does it and you stop paying attention." The accountability doesn't move. When I ship a client's site, I'm responsible for it: the code, the GDPR posture, the bill. The agent is leverage, not a liability shield. Directing well means understanding what shipped well enough to stand behind it.

It's also not magic. Agents go down wrong paths, over-engineer simple things, and confidently miss the point. Most of the skill is in catching that early, which is exactly why the director's judgement is the scarce ingredient, not the AI.

The skill that's actually scarce

If typing was the old bottleneck, judgement is the new one. Knowing what to build, what "good" looks like, where the real constraints are, and when an answer is subtly wrong, that's the work now. The tools will keep getting better at the doing. They won't decide what's worth doing, or whether the result is something you'd put your name on.

That's the part that's still yours. AI-directed engineering just clears everything else off your desk so you can spend more time on it.