Give Away the Writing, Keep the Reading

“The most essential gift for a good writer is a built-in, shockproof, shit detector.” — Ernest Hemingway

A stream of sandstone stepping stones passing through a charcoal torii gate; one clay stone pauses at the gate for inspection.

Linus Torvalds spent 2024 calling AI “90% marketing and 10% reality.” Then in January 2026 he shipped a hobby project, AudioNoise, and the README says the quiet part out loud: the Python visualizer was “basically written by vibe-coding”; the audio math, in C, he wrote by hand. In the merge commit he admits the AI’s visualizer was “much better than I could do by hand”. The same commit also has him finding the bug in the built-in rectangle-select himself and telling the tool to write a custom one before it worked.

One repository, the whole argument. He gave the writing away where he wasn’t the expert and nothing much was at stake, and kept it where the stakes were real. What mattered wasn’t the code he typed by hand but the judgment underneath: he read the visualizer and caught the bug, and he decided what to hand off.

Give away the writing, keep the reading.

AI-written code moves from a code window through a human reading gate before it ships. A dashed path that bypasses the gate ends in uncertainty because unread code cannot be distinguished as working or broken. — Give away the writing. Keep reading it — you're the only one who knows what you meant.

BLUF: Bottom line up front

Let the AI write the code; you own the understanding.
For anything that has to be right, read every diff you’d ship. If you won’t read it, don’t ship it. Throwaway you can skip.
Review can guard harder than writing. You’re sceptical of code you didn’t write in a way you never manage with your own, so handing off the writing can raise your bar, not lower it. A wager from experience, not a measured law.
Write to build the judgment; read to keep it. Hand-write the hard parts while the instinct is forming. After that you read far more than you write, but you keep writing: reading leans on knowing what building takes, and that knowledge goes stale if you stop.
Learn to read — there’s no checklist. It’s an instinct: pattern recognition that flags the wrong shape before you’ve worked out why. You build it by reading a lot of code, with feedback.

Why the reading, and not the tests

“Verify” and “read” aren’t the same word. Tests and types check the properties you managed to write down. They can’t cover the intent you never wrote down, and the part that goes wrong is usually the part you didn’t think to spell out. A human who owns that intent can read the code and judge it against what they meant. That judgment is fallible, but it can be independently right.

You can’t hand it back to the AI. Ask the model what it built and you get a description of the same guess. Its tests encode what it thought it was doing, which is the very thing in question. A second model’s blind spots overlap with the first’s, so it flags an inconsistency but can’t recover intent you never supplied. Only one check sits outside that guess: a human who owns the intent, reading the code.

When people don’t really read it, it shows. A Stanford study found that developers with an AI assistant wrote less secure code on most tasks, and were more likely to think it was secure. It ran on a 2022, codex-era model, so it carries the human pattern forward, not a verdict on today’s tooling. They had the code in front of them and still missed it. Access to the diff was never the point. A trained read against a real bar is.

The code is only as good as the guard

The model alone doesn’t set AI code quality; the reader does. Hold a real bar and you can get more good code than you’d write alone; hold none and you just get more code.

From my own work: the AI wrote me a caching layer that filled the cache inside the .then, after the fetch resolved. Green tests. Ran fine. But read the shape: two callers on a cold cache both fire the fetch — you have to cache the promise the moment it starts, not the result when it lands. Nothing ran wrong to show me that. Reading the code did.

// what the AI wrote: the cache fills after the fetch resolves
function get(key) {
  return fetch(key).then(res => {
    cache[key] = res;        // two cold callers both reach here — double fetch
    return res;
  });
}

// what reading it catches: cache the promise the moment it starts, not the result
function get(key) {
  return (cache[key] ??= fetch(key));   // the second caller reuses the in-flight promise
}

This next part is a wager, not a finding. For a lot of engineers the guard is stronger in review than it ever was on their own writing. Your own code you trust; you cut corners, you let things slide. Code you didn’t write, you’re sceptical of. Hand the writing to the machine and you’ve moved the work into the mode where you pay attention.

The catch: the guard only guards if the review is real. Skip it and you’re the Stanford study’s overconfident subject, waving through the bug in front of you.

Reading moved to the front

Most of the argument about AI and review is about the pull request — someone reading a bot’s code after the fact. That review matters, but yours is the one that sets the quality, and yours happens earlier. You direct the machine, it writes, and you read what comes out as it comes out.

Working with the AI to write is already a review. You steer and read in the same motion, on the code as it lands, not on a pull request days later. The taste that used to go in as you typed goes here now. You can put some of it in the prompt, but the machine does the writing, so your judgment lands on what it produced. You own the code the moment you accept it, and accepting is the one act in the whole loop that takes no understanding at all.

The pass

Picture the pass — the counter where a kitchen’s plates line up before they go out. The chef there cooked almost none of them; the whole job is to look. A glance down the line and the wrong plate catches his eye, not because he tasted it, but because he’s plated ten thousand and this one’s off. He sends it back and lets the rest go. His name is on the door, so the plate is his the moment it leaves, and the rush is exactly when he’s tempted to wave it through without looking.

The line got faster. You’re at the pass, and the reading is the glance.

Reading it was always the point: knowing whether it does what you meant, holding it to a standard, catching where it’s quietly wrong. The writing is safe to give away because your value was never in it. Give the reading away and you keep shipping, faster than ever, right up until the day you can’t tell whether any of it works. Neither can the model that learned from you.

How sure I am: The review-beats-writing guard and the caching catch are marked in the text as experience or a wager, not measured results.

Sources

Linus Torvalds, AudioNoise — project README and merge-commit notes (2026); “90% marketing and 10% reality” remark (2024).
Perry, Srivastava, Kumar & Boneh, Do Users Write More Insecure Code with AI Assistants?, arXiv:2211.03622 (2022) — the Stanford study.

Related: The Productivity Mirage — why the trade feels free while it’s costing you.