On Friday, a developer named Rafał Cymerys published a short post on his personal site titled “I’m Becoming AI-Blind.” By the time it reached the front page of Hacker News — 284 points, 301 comments — it had named something a lot of people in software have been feeling but couldn’t quite articulate. Cymerys isn’t worried that AI-generated code is indistinguishable from human code. He’s worried about the opposite: that it’s distinguishable in a way that makes it nearly impossible to read.

The post is short and specific. AI-generated code comments, Cymerys writes, have a structure he can no longer parse. Not that they’re wrong. That they’re unreadable. One commenter on the thread described the same experience with Claude’s pull-request comments: the sentences are fluent, the grammar is perfect, and yet the meaning doesn’t land. It’s the reading equivalent of a face that’s almost but not quite human — close enough to recognize, wrong enough to unsettle.

Throughput Is a Soviet Metric

The AI productivity story is being sold on throughput. Lines of code. Pull requests merged. Features shipped per sprint. Every vendor deck, every earnings call, every “developer productivity” benchmark leans on the same number: how much more code gets produced when the machine is doing the typing.

But code is read far more often than it’s written — that’s one of the oldest maxims in software engineering, and it hasn’t been repealed by a chatbot. The cost of a line of code isn’t paid when it’s written. It’s paid every time someone has to read it, understand it, debug it, extend it, or explain it in a code review. And if AI-generated code is harder to read — not because it’s wrong, but because it’s structured in a way that defeats human parsing — then the productivity gains are being silently eaten by a comprehension tax that no dashboard measures.

This is the part the AI boosters don’t want to talk about. Measuring developer productivity by output volume is what Soviet factories did with tonnage: it rewards the production of things, not the production of things anyone can use. A steel plant that ships ten thousand tons of rebar that no builder can bend has not made anyone more productive. It has made a number go up. The 301 comments on Friday’s thread are full of people describing the same experience from the inside.

Fluent, Complete, and Oddly Frictionless

The interesting question is why AI-generated text is hard to read in the first place. It’s not that it’s bad. It’s that it’s optimized for the wrong thing.

Human code comments are written by someone who was confused, or annoyed, or trying to warn the next person about a trap. They have a shape that comes from a specific mind at a specific moment. AI-generated comments are written to be correct. They’re fluent, complete, and oddly frictionless — every sentence resolves, every ambiguity is smoothed over, and nothing is left for the reader to grab onto. Reading them is like trying to climb a wall with no handholds.

Cymerys’s word for it is “AI-blind.” It’s not that he can’t tell the difference between human and machine text. It’s that the machine text has started to feel like a language he no longer speaks. The grammar is familiar. The meaning doesn’t arrive.

Who Pays the Reading Tax

Here’s the part that should make engineering managers uncomfortable. The people who benefit from AI code generation are not the people who pay the cost of reading it.

The engineer who prompts an AI to generate a thousand lines of code gets credit for a thousand lines of code. The engineer who has to review that code, maintain it, and debug it six months from now pays the tax. And the tax is progressive: it falls hardest on the most junior people, the ones who haven’t yet built the pattern-matching instincts to spot when fluent code is quietly wrong.

“I don’t know if this code is wrong or if I’m just tired,” one junior engineer on a payments team wrote in a Slack DM this week, “and that’s the problem.”

That’s the problem, all right. Not that AI writes bad code. That it writes code that erodes the reader’s confidence in their own judgment. And confidence in your own judgment is the one thing a code review can’t be automated away.

The uncomfortable conclusion is that the AI productivity boom may be real and still not worth what it’s costing. Not because the machines are coming for the jobs. Because the jobs that remain — reading, reviewing, maintaining, understanding — just got harder, and nobody is measuring that.

Sources