Craft in the age of AI-assisted development

There is a comfortable myth that AI-assisted development is mostly about speed — that the win is typing less. It is partly that. But the more interesting shift is subtler: when a competent first draft of almost any function, component, or schema is nearly free, the bottleneck moves. It moves from producing code to deciding which code deserves to exist.

The first draft is no longer the hard part

Anyone can now generate a plausible implementation in seconds. The plausible implementation is exactly the trap. Plausible code compiles, passes the happy path, and reads fluently — while quietly encoding the wrong boundary, the missed edge case, or an abstraction that will calcify by month three.

So our work has shifted upstream and downstream of generation: upstream into framing the problem precisely, and downstream into verifying ruthlessly. The model handles the middle.

What we actually do

• Specify before generating. A clear spec turns a vague prompt into a verifiable one. If we cannot state what 'correct' means, the model cannot either.
• Keep units small. Generated code is easiest to review when each piece does one thing. Small surfaces are also where models are most reliable.
• Verify by running, not reading. Fluent code earns trust it has not yet deserved. We confirm behavior with tests and the running system before believing it.

Tools accelerate; judgment decides. The teams that win this era will be the ones who got faster without getting careless.

None of this is nostalgia for hand-typed software. We use these tools heavily and happily. But craft did not disappear when the first draft got cheap — it concentrated. The taste to know what to build, and the discipline to confirm it works, are worth more now, not less.