We've Become Write-Only Memory

If you’d asked me a few years ago what I actually loved about this job, I’d have told you it was the creating. Take an idea, take a genuinely hard problem, crack it open, and write the code that makes it real. That’s the hit. Taking something that didn’t exist and willing it into being — that’s most of why I became a software engineer in the first place, and I doubt I’m unusual there.

There’s a quieter version of the same thing, too: building something just to understand it. You crack open the internals of a system by reimplementing it yourself, and you come out the other side with a kind of visceral, load-bearing understanding you can’t get any other way. That’s its own reward.

Lately I’ve been struggling to find either of those, and I think I’ve figured out why. I have Claude open in three terminals.

Don’t get me wrong — Claude Code, Codex, the whole class of AI coding agents are genuinely great. They’ve unlocked paradigms that didn’t exist, collapsed work that used to take days, and there’s a mountain of tedious, trivial stuff that should absolutely be offloaded to them. I’m not here to yell at the cloud.

But something feels off, and from talking to people in my circle, I don’t think I’m the only one feeling it. It’s a creeping lack of agency — which is darkly funny, given that “agents” are the thing everyone is building and shipping right now. The mechanistic act of sitting down and writing the code is gone. So is the act of pulling up a meaty technical article, or a conference talk, and actually sitting with it. Pen and paper, drawing the flow out, struggling with it until it clicks.

This isn’t a “good old days” argument

I want to head off the obvious reading of this, because I’d be suspicious of it too. This is not “things were better before” and I am not being a troglodyte about new technology. The opposite, really: I’m all the way in. I use coding agents every single day, I write my own agents, and if I’m honest I’d put myself somewhere in the power-user bucket for AI-assisted coding and LLMs generally. I’m not writing this from the sidelines.

And it’s because I’m in this deep that I think the question is worth asking. Being a power user shouldn’t disqualify you from noticing that something feels different and wanting to know why. Why does it make me feel this way? Is anyone else feeling it? What, specifically, am I trading away — and is there a better paradigm for using this stuff than the one I’ve fallen into by default? Loving the tool and interrogating what it’s doing to you are not in conflict. If anything, the people deepest in it are the ones who should be asking.

Write-only memory

So here’s the phrase that keeps circling back. I first reached for read-only — we’ve become read-only devices — but that’s backwards from where I actually sit. I’m not the one doing the reading. I’m the thing being written to.

There’s an old hardware in-joke about write-only memory: a chip you can write to all day long but can never read back from. A perfectly useless component, which is exactly what makes it funny. And it’s a disturbingly good description of what these sessions do to me. The data goes in at full line rate — but because I never did the work to consolidate any of it, almost none of it can be read back out later. It’s in there. I just can’t retrieve it.

I’m talking to Claude in three windows, on three different projects, and it’s firing information at me faster than I can metabolize it. I’ll be reading a response, hit a concept I don’t fully know, and start to go look it up — and before I can, another terminal has finished and is waiting with ten new things to process. I jump to it. Then the third one has ten more. It’s write, write, write, write into the brain, and almost no read ever comes back out.

Yes, the speed went up. But it’s all intake. I’m not writing my own code. I’m not filling a page with diagrams and wrong turns and crossings-out. I’m not struggling, because there’s this absurdly capable thing in front of me that will do nearly anything the moment I say I wish it were so.

The database-shaped part of my brain has a cleaner way to put it. Every system gets tuned for a certain ratio of reads to writes. Coding with agents takes that ratio and makes it violently lopsided — almost pure write-in, at high throughput and massive parallelism. Everyone I know is running three to five agent windows at once, fanning out across concepts and projects simultaneously, all of them streaming into the same overloaded buffer.

(Which way the labels point depends entirely on where you stand. From the agent’s seat it’s reading my intent and writing code. From inside my own head it’s the reverse: the firehose writes into me, and the read — the part where I pull something back out and do something with it — is the operation that’s gone missing. I’ve made my peace with the inversion; the missing half of the loop is the same either way.)

The part where writing code was secretly doing something

A friend of mine — a senior engineer at Stripe — said something that stuck with me. The act of writing code, after you’ve brainstormed and formed a hypothesis and chewed on the problem, gives your brain a kind of rest. It drops into a background mode while your hands do the typing and your mouth does the explaining, and in that background it’s still turning the problem over, looking at it from angles you weren’t consciously aiming at.

The analogy that landed for me was REM sleep. There’s an awake, effortful mode — researching, surveying the state of the art, probing for the edges and constraints. And then there’s the consolidating mode: writing the code, talking it through, sketching it on a whiteboard. That second mode looks passive but isn’t. It’s where the thing actually gets filed away into something you own.

When every problem gets answered before I’ve written anything, I skip the consolidation step entirely. The information gets written into me at high throughput, but I never read it back out, never generate anything from it, never run the background process. The buffer fills; nothing ever drains it into something I own.

So is this just nostalgia? I went looking.

I was fully prepared for this to be old-man-yells-at-compiler stuff. It mostly isn’t. The research that maps onto this is older and sturdier than the current AI panic, and some of it is uncomfortably specific.

Generating beats reading — this has been settled since 1978. The generation effect (Slamecka & Graf, 1978) is one of the most replicated findings in memory research: information you produce yourself is remembered far better than the identical information you merely read. Reading Claude’s explanation and generating that explanation yourself are not the same operation, and your brain has always known it.

The struggle is the feature, not the bug. Robert Bjork’s desirable difficulties framework makes the point that the effortful parts of learning — retrieval, generation, wrestling with something just past your reach — are precisely what produce durable skill. AI is extraordinarily good at removing exactly those difficulties. Which means it’s good at removing exactly the thing that was building the skill.

There’s now an EEG study with my name on it, basically. MIT Media Lab’s Your Brain on ChatGPT split people into LLM, search-engine, and brain-only groups for a writing task and measured brain connectivity. The brain-only group showed the strongest, most distributed neural networks; the LLM group the weakest — some metrics down by more than half. They call the result cognitive debt: outsource the mental effort and the learning quietly doesn’t happen. (Caveat: small sample, one task, educational setting — but the direction is hard to wave away.)

Knowledge workers already report this about themselves. A Microsoft Research / Carnegie Mellon survey of 319 knowledge workers (CHI 2025) found people reporting much less cognitive effort across comprehension, synthesis, and evaluation when using GenAI. The sharpest line in the whole thing: the more you trust the tool, the less critical thinking you do; the more you trust yourself, the more you do. The work shifts from producing the answer to verifying the AI’s — from author to editor.

We’ve done a gentler version of this before. The Google effect (Sparrow et al., 2011) showed that when we expect to be able to look something up later, we remember where it lives instead of what it is. That’s the extended mind — we’ve always offloaded cognition into notebooks and calculators and search bars. The difference now is what’s being offloaded. It used to be storage and retrieval. With agents, it’s the reasoning itself.

And the kicker, for anyone leaning on “but I’m so much faster now”:

The speedup might be partly a feeling. METR ran a randomized controlled trial with experienced open-source developers working in repos they knew deeply. With AI tools, they were 19% slower — and they believed they’d been about 20% faster. The perception and the reality pointed in opposite directions. So part of what I’m trading my write-cycles for may not even be the throughput I think it is.

Draining the buffer

None of this is an argument to close the terminals. The tools are too good and the leverage is real. It’s an argument that the read/write ratio is a thing I have to manage on purpose now, because the default has swung all the way toward write-in and the cost is invisible until it isn’t.

A few reads — operations that pull something back out of my own head — I’m trying to schedule in:

• Reintroduce the pen and paper. Before I prompt, draw the problem out by hand. The point isn’t the diagram; it’s forcing a generation step before the firehose opens.
• Build-to-understand stays manual. If the reason I’m writing something is to understand it, handing it to an agent defeats the entire purpose. Speed is the wrong metric there.
• Use the agent for inquiry, not just generation. “Help me reason about the tradeoffs here” keeps me in the loop. “Write this for me” takes me out of it. The research suggests that distinction is most of the ballgame.
• Kill the parallelism. Three windows isn’t 3x throughput; it’s a guarantee that I never finish a thought before the next interrupt. One problem, one window, sometimes.
• Write it down after. Teach it, blog it, rubber-duck it — anything that makes me read back out of my own head instead of just accepting the change log.

So, the tagline. Read-only device was my first reach, but it points the wrong way — I’m not the reader, I’m the thing being written to. Write-only memory is the one that fits: a buffer you can pour data into forever and never read back. The good news about a buffer, though, is that it can be drained. You just have to do the work that turns what’s been written into you into something you can actually read back out — and stop being write-only.

I’m going to go write some code. By hand. Slowly.