When to write code by hand vs. let AI write it

The question sounds like it’s about productivity. It’s really about where understanding lives. Every line in your codebase is either something you understand well enough to debug, extend, and explain — or something you’re renting. AI moves lines between those categories very quickly in one direction. A deliberate hand/AI split is how you keep the load-bearing lines in the first category while still taking the speedups.

The split, case by case

1. 01

   Let AI write it: boilerplate and glue

   Configuration files, CRUD endpoints, migrations, import statements, test scaffolding, that logging wrapper you've written forty times. The cost of not understanding this code is near zero because you've understood it in every previous job you've had — it transfers. Delegating it is exactly what a power tool is for.

2. 02

   Let AI write it: well-understood patterns you can verify at a glance

   Sorting with a custom comparator, a debounce function, a date formatter, a standard retry loop. You could write these, and you can review them in seconds because you know exactly what correct looks like. The verification cost is trivial — which is the entire justification for delegating.

3. 03

   Write it yourself: the core logic of what you're building

   The algorithm inside the feature, the state machine, the pricing calculation, the parser. This is the part where a subtle bug costs the most and where understanding is the product. If you can't re-derive this code on a whiteboard a week later, you don't own your feature — the AI does, and it has moved on.

4. 04

   Write it yourself: anything you'd debug at 2am

   Concurrency, caching invalidation, timezone handling, anything touching money or auth. When these break in production, you will be reading them without an assistant's full context and under pressure. Code you may have to fix live is code you should have written, or at least rewritten by hand once after understanding it.

5. 05

   Write it yourself: when learning is the point

   New language, new framework, new domain — if the goal is to internalize it, generating your way through defeats the purpose. The struggle of producing code by hand is not waste; it's the encoding process. Delegate after you've built the mental model, not before.

6. 06

   Hybrid: AI drafts, you rewrite the parts that matter

   The most underused pattern: let the assistant produce a first pass, then rewrite the core functions by hand before merging. You get the boilerplate for free, keep the load-bearing logic in your fingers, and the diff between draft and your version is a precise map of what you didn't know.

The rule underneath the cases

Every case above reduces to one question: what does it cost later if you don’t understand this now? Boilerplate has almost no carrying cost — you’ve understood it since your second job. Core logic, concurrency, auth, and money have enormous carrying cost, because the bill arrives during incidents, extensions, and interviews, with interest. Delegate where the carrying cost is low; write or rewrite where it’s high. If you want a single heuristic to remember: if you couldn’t re-derive it on a whiteboard next week, either write it or rewrite it.

This is also the honest answer to “will I lose my skills?” — you lose the ones you stop practicing, and you choose which those are every time you delegate. The mechanics of skill decay and the evidence are covered in does using AI make you a worse programmer?, and the daily habits that keep the split healthy in how to avoid over-relying on AI when coding.

FAQ