antirez: in the AI era, own the ideas — let the model type

5 min read 1 source clear_take
├── "In the AI era, developers should own the ideas and system model, not the keystrokes"
│  └── Salvatore Sanfilippo (antirez) (antirez.com) → read

Antirez argues that LLMs have decoupled 'thinking about the design' from 'typing out the code' — two activities that used to be fused. The developer's job is now to hold the mental model of the system: what it does, what invariants must hold, and what a good solution looks like before code is generated. Typing is negotiable; the thinking is not.

├── "Letting the model originate the design leaves you defending code you don't understand"
│  └── Salvatore Sanfilippo (antirez) (antirez.com) → read

Antirez warns that a model can produce code for an idea faster than a human can, but it cannot originate the idea, hold the invariants, or decide what's worth building. If developers cede that upstream work to the model, they end up in code reviews they can't win, defending an artifact they never actually reasoned through.

└── "Typing speed was never the bottleneck — agent-heavy 'model builds the PR' pitches miss the hard part of the job"
  └── top10.dev editorial (top10.dev) → read below

The editorial frames antirez as part of a practitioner camp (alongside Zed's engineers and Simon Willison) pushing back on productivity-maximalist tools like Cursor, Windsurf, and Devin. Their shared claim is that the interesting bottleneck in software was never keystrokes, so compressing the human toward review doesn't actually remove the difficult work of design and invariant-holding.

What happened

Salvatore Sanfilippo — antirez, the creator of Redis — published a short essay called *Control the Ideas, Not the Code* that hit the Hacker News front page and sat at 131 points. It's a working programmer's argument, not a manifesto, and it lands harder because of who's writing it: a person who spent two decades hand-crafting one of the most-deployed pieces of infrastructure on the internet is telling you to relax about the keystrokes.

The thesis is compact. In the pre-LLM world, controlling the code and controlling the ideas were roughly the same activity — you thought about a design by typing it out, and the artifact you produced was both the specification and the implementation. In the LLM world those two things have started to come apart. A model can produce the code for an idea faster than you can, but it cannot originate the idea, hold the invariants, or decide what's worth building — and if you let it try, you end up defending code you don't understand in a review you can't win.

Antirez's prescription is that the developer's job is now to be the one who holds the model of the system: what it does, what it must never do, where the sharp edges are, and what a good solution looks like before a single line is generated. The typing is negotiable. The thinking is not.

Why it matters

This lands in the middle of an industry argument that has been running hot all year. On one side you have the productivity-maximalist camp — Cursor, Windsurf, Devin, and the various "agent builds the PR" pitches — where the implicit promise is that the model can carry more and more of the loop, and the human's job compresses toward review. On the other side you have practitioners like Zed's engineers, Simon Willison, and now antirez, saying that the interesting bottleneck was never typing speed and the models don't actually remove the hard part of the job.

What makes antirez's version distinct is the framing. He isn't warning that models are bad at code — he's warning that outsourcing the specification is where the damage is done. A junior who copies a Stack Overflow snippet learns something about the shape of the problem; a senior who prompts a model into a 400-line diff and merges it learns nothing, and now owns 400 lines of code whose failure modes live in someone else's head. That's the loop he wants to break.

There's a second, quieter point that's easy to miss. If ideas are the durable artifact and code is the disposable one, then the way you *store* ideas matters more than it used to. Design docs, invariant lists, "why we didn't do X" notes, careful commit messages — the things a hurried team skips because "the code is the spec" — become the actual product of the engineering org. The code is just the current rendering. You could plausibly regenerate it next quarter against a better model. You cannot regenerate the reasoning about why the write path can't block on the replication ACK.

The HN thread mostly agrees, which is unusual. The dissent is worth taking seriously though: several commenters push back that "control the ideas" is a comfortable story for someone who already has thirty years of ideas in their head. For a developer three years into the industry, the code *is* how you build the ideas. Skipping the typing means skipping the education. Antirez doesn't fully address this, and it's the honest weak point of the argument. The playbook works cleanly for staff engineers with strong priors; it's genuinely dangerous advice for someone still building the mental models an LLM would let them skip.

What this means for your stack

The practical version of antirez's take, if you're shipping every day:

Before you prompt, write down what you want in words a colleague could review. Not "add caching to the user endpoint" — the invariants, the failure modes you refuse to accept, the data shape, the deploy constraint. If you can't write that paragraph, you're not ready to prompt; you're ready to think. This is where the model gives you the most leverage anyway: a tight spec produces tight code, and a vague prompt produces a diff that looks plausible and hides the bug on line 217.

Treat generated code like a contractor's work, not your own. Read every line, but more importantly read for the things the model was never told to care about — your service's specific SLOs, the shape of your on-call rotation, the migration you did last quarter that makes this "obvious" solution wrong. The model optimizes for producing code that looks like the average of its training set; your job is to know all the ways your system is not average.

And keep writing code by hand sometimes, especially the parts that carry real complexity. Not because typing has magic in it, but because if you never sit with a problem long enough to feel where it resists you, you'll stop noticing when the model's answer is subtly wrong. Antirez is explicit about this: the ideas he's telling you to control are earned by having built things, and the way you keep earning them is by not fully retreating from the code.

Looking ahead

The interesting question isn't whether antirez is right — he mostly is, for his cohort — but whether the tools will start meeting him halfway. Right now the dominant AI coding UX still treats the diff as the artifact and the intent as ephemeral chat history. The next generation of tooling that actually reflects his argument would invert that: the spec, the invariants, and the reasoning become first-class objects the model regenerates code against, and the code becomes cheap. We're not there yet, but you can see the shape of it in how the better teams are already working. The developers who thrive in the next two years won't be the fastest prompters. They'll be the ones who wrote the clearest paragraph before they opened the chat.

Hacker News 171 pts 131 comments

Control the Ideas, Not the Code

→ read on Hacker News
m_ke · Hacker News

I tried really hard to do this, but it turns out the models don't care about your ideas and want to do what's popular in their training data, so they will happily ignore anything you try to force down their throats, especially as context length grows or if you hit compaction.So to make bes

jgeada · Hacker News

Ideas are a dime a dozen. All of us have half a dozen of what appear to be good ideas every. Execution matters, testing and sanity checking matters, actual engagement with users and iteration matters.Sure, we're reducing the cost of idea -> prototype to near zero (well, as long as tokens are

danceparty · Hacker News

Very uncomfortable to read. The proposed idea of not reading the code you ostensibly wrote, doesn’t just challenge the traditional workflow or methodology, it challenges the identity of a programmer itself. For experienced, respected programmers like antirez perhaps reading and writing code truly ha

alexpotato · Hacker News

For some background on me to set the context for the following opinion:- been a SRE/DevOps at banks/hedge funds for almost 20 years- now work in L1 crypto- have been coding since I was 12 and have also been using frontier models for the past year (including running multiple agents at the s

aledevv · Hacker News

>if you control the ideas of your software, looking at the code itself is suboptimal and often pointless.This requires developers to have absolute and unconditional Trust in the LLM. It's not easy to trust it completely to the point of completely ignoring the implementation details of the co

// share this

// get daily digest

Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.