AI and the Means of Attention

This is an early draft I’m sharing for feedback. Please don’t share widely, and hit me with your thoughts!

There’s a lot of foam on the water right now. AI is remaking how software gets built, and our whole industry is metabolizing the change in public. Maintainers are overwhelmed! Systems thinkers are drawing new diagrams! Individual developers are writing about how their own workflows feel different in ways they can’t quite name! Is it a tailspin? An ouroboros of navel-gazing, the discourse eating its own tail? Or are we in a chrysalis, goo right now but about to emerge reformed and beautiful? So many takes! So many emotions! And rightly so. There’s a lot to figure out.

All of which leaves a body looking for anchor points. Navigation buoys on the salty seas. Fundamentals that were always there and hold true even when everything on the surface is churning.

Here’s one that’s helped me: the economy of attention.

Not “the attention economy” — that’s the demand-side concept, who can capture your eyeballs. This is the supply side. Attention as a scarce resource that has to be spent to produce anything of value. Think of it as a conservation law: the attention required to produce correct, understood software can’t be created or destroyed, only moved around. If less is spent in one place, more has to be spent somewhere else.

AI has made generating code almost free. It has not made understanding code any cheaper. That gap is the source of almost everything we’re all feeling right now.

Dead Attention

Here’s an old idea in new clothes: a software system is accumulated attention, crystallized into something useful.

Not lines of code. Not person-hours. Not story points. Attention. Someone had to understand a problem deeply enough to encode a solution, and then someone else had to understand that solution deeply enough to trust it, and then someone else had to understand the system deeply enough to change it without breaking what came before. Every layer of that understanding is attention, spent and compounded.

Marx would recognize this immediately. His labor theory of value says the value of a commodity isn’t the materials: it’s the socially necessary labor time embedded in it. Software is the same, with a substitution. The value isn’t the text of the code, it’s the comprehension-labor embedded in it. A codebase is dead labor: past understanding, crystallized.

There’s even a hilariously literal version of this in software economics. The COCOMO model estimates a codebase’s “value” by computing the person-hours it would take to reproduce, then multiplying by a blended labor rate. It’s crude. It’s also accidentally Marxist. It was groping toward this truth: the value is the embedded attention. The hours were always just a proxy.

And here’s why this matters now: the whole point of building software is to create an attention surplus for the people who use it. We spend attention building the thing so that users don’t have to spend attention doing the thing the hard way. Technology is an attention transformer. Attention in on the building side, attention savings out on the usage side. The measure of a useful piece of software is that multiplier: how much attention was spent building it versus how much attention it saves across everyone who uses it.

The best software has a spectacular ratio. Years of focused human comprehension on the building side, millions of hours of saved effort on the usage side. That’s the whole game. That’s why we do this.

Through the Lens

Once you see software as an attention economy with a conservation law, a lot of the current discourse snaps into focus. I’ve been reading a stack of recent posts that are all circling the same set of concerns from different angles, and I think they’re all describing the same underlying phenomenon.

The Maintainer’s Burden

A Django maintainer recently wrote “Give Django your time and money, not your tokens”, a post that nails the problem from the receiving end. Open source maintainers are getting flooded with AI-generated contributions that cost the submitter almost nothing to produce and cost the reviewer everything to evaluate.

The old implicit contract was roughly balanced. Writing a patch took effort. Submitting it meant you’d probably tested it, probably understood the codebase at least locally, probably cared enough to engage in review. The cost of producing the contribution was a natural filter for its quality, and — just as importantly — a signal of good faith. You’d spent attention. That meant something.

Now you can generate a plausible-looking patch in thirty seconds. The code might be correct. It might even be good. But the reviewer has no way to know that without spending their own attention, and their attention hasn’t gotten any cheaper.

The conservation law is doing its thing. The attention cost of a correct patch didn’t go down; it got transferred from the submitter to the reviewer. In Marxist terms, this is a classic move: the labor didn’t disappear, it was displaced onto someone with less power in the transaction. The maintainer now does the comprehension-work the submitter skipped. (It’s telling that people are already building explicit trust systems to replace the implicit filter that effort used to provide.)

The Review Bottleneck

There’s a common observation making the rounds lately (one recent version is sharp on the diagnosis, though its conclusions are questionable): every layer of review approval makes a process roughly 10x slower. AI makes generation faster, but generation was never the bottleneck. Review is the bottleneck. And review is slow because it’s attention-intensive: someone has to actually understand what changed and why.

Deming saw this decades ago in manufacturing. Adding QA inspection layers reduces individual accountability. When everyone knows there’s another check downstream, they stop checking their own work. The layers don’t compound quality; they dilute responsibility. Nobody feels like quality is their job.

Through the lens: review layers are attention-routing systems, and badly designed ones leak. When you add a QA layer, you’re not adding attention to the system. You’re spreading the same attention thinner across more people, each of whom feels less ownership. The total attention spent might even go down. Marx saw the same thing in the factory: subdividing labor increases throughput but alienates the worker from the product. Quality suffers because nobody holds the whole thing in their head anymore.

The Spec Shell Game

Gabriella Gonzalez (creator of Dhall) wrote “A sufficiently detailed spec is code”, a clean, almost mathematical observation. If you write a specification precise enough for an AI to generate correct code from it, you’ve already done the hard work. You’ve spent the attention. The spec didn’t save you anything; it just moved where the attention went.

This is attention laundering. You can shuffle the apparent cost around: write a spec instead of code, generate a PR instead of typing it, use a framework that hides the complexity. But the actual attention required to produce something correct and understood doesn’t compress.

The Slot Machine

A designer-developer wrote about AI coding feeling like gambling. You pull the lever, you get a result, you pull again. It’s “preposterously addicting” precisely because it removes the cognitive burden. But the work feels hollow. You’re spending your time “mopping up how poorly things have been connected” rather than actually solving problems.

This is what attention debt feels like from the inside. And Marx has a word for it: alienation. The worker separated from the product of their labor. When you vibe-code, you produce artifacts you don’t understand. The hollow feeling is the experience of being alienated from your own output. The slot machine gives you the dopamine of production without the satisfaction of comprehension.

This is why “vibe coding” works for prototypes and breaks for production systems. A prototype has low attention stakes: nobody else depends on it, nobody has to review it, nobody has to maintain it. The economy balances even with minimal attention spent. But a production system that other people rely on is a shared attention budget, and withdrawals without deposits are felt by everyone downstream.

The Spice Shaker

There’s a pitch being made right now, by the frontier model companies, by the LinkedIn-consultant-CEO-AI-booster class, by a thousand breathless threads. It goes something like this: the LLMs have ingested a hyperdimensional superset of all the attention ever paid into their massive training corpora. All that accumulated human comprehension, distilled into an API. Shake the shaker, get the flavor. Pay by the token for the privilege.

And in a way, from a certain angle, they kinda do? LLMs really have encoded patterns from an unfathomable volume of human thought. The model really can produce things that look like the output of comprehension. The spice shaker genuinely tastes like something.

But what comes out is the surface form of attention, not attention itself. A statistical echo of comprehension. It can reproduce the shape of understanding without anyone in the loop actually understanding anything. The flavor without the nutrition.

Marx would call this commodity fetishism: mistaking the product for the labor that produced it. The pitch collapses the distinction between “pattern-matched against a corpus of human comprehension” and “comprehended.” Those are not the same thing. One is a product. The other is a process. The product can be bought and sold. The process has to be lived through.

The logical extreme of this pitch is the SaaSpocalypse, the market-level panic that every SaaS product is just one .md file away from being replaced by a Claude skill. Nearly a trillion dollars in software market cap wiped out on the premise that all the accumulated attention baked into these products can be reproduced by shaking the shaker hard enough.

There’s a site called Death by Clawd that’s savage, funny, and — intentionally or not — a perfect satire of the hysteria. You feed it a company URL and it generates a fake death certificate, a Bloomberg-terminal-style crash graphic, and a replacement SKILL.md file that purports to do everything your product does in 31 lines of markdown. Replacement cost: ~$0.003 per run. Cause of death: “Claude learned to write Terraform faster than your dashboard could load.”

I ran it on Miren, the infrastructure platform I work on. It gave us a 38/100 survival score, a eulogy that begins “Dearly beloved, we gather here to remember Miren — a platform that dared to ask, ‘What if Heroku, but again, but this time we call it modern?’” and a 31-line SKILL.md that generates Dockerfiles and Terraform configs. Estimated time until death: 2-3 years.

It’s hilarious. It’s also commodity fetishism in action. The 31-line file reproduces the shape of what Miren does: it can generate the same kinds of config files. What it can’t reproduce is two years of accumulated attention from people who understand the actual problem. Why that networking edge case breaks three different cloud providers in three different ways. How you make rollbacks safe. What to do when nothing in the logs explains what just happened. The SKILL.md gives you the shape. The product is the understanding.

The taxonomy of survivors and casualties is telling, too. The companies that score well are the ones where the accumulated attention is deeply embedded: physical infrastructure, regulatory knowledge, things you can’t pattern-match your way through. The ones sweating are workflow abstractions where the attention was always thinner, always closer to the shape that an LLM can reproduce.

But here’s the thing — and I think the Marxist in me has to say it — some of that sweating is deserved. If your business model was milking a fat margin off a sliver of information asymmetry, if the “value” you provided was mostly gatekeeping knowledge that’s now freely accessible, then the conservation law is telling you something you maybe didn’t want to hear: you never had that much accumulated attention in the first place. Your moat was opacity, not depth. The spice shaker can reproduce thin attention. That’s not a bug in the model. That’s the forces of production disrupting the relations of production. That’s how it’s supposed to work.

If LLMs democratize knowledge and capability, if they make it so a solo developer or a tiny team can do things that used to require an enterprise sales call, I’m all for it. That’s the world I’m helping build toward at work anyway. Shake that shaker. Disrupt away.

The Multiplier

But you can use the product to accelerate the process without substituting one for the other. And this is where the frame gets practical. If AI helps you skip attention, if nobody actually understands the thing that shipped, the product degrades. Buggy, confusing, unreliable software doesn’t save user attention. It costs user attention. The multiplier inverts. You’ve produced something that consumes more attention than it saves, and at that point it’s not really technology in any meaningful sense. It’s just generated stuff that someone downstream has to deal with.

But if AI helps you spend attention more effectively, automating the mechanical work so you can focus your comprehension on the parts that matter, the multiplier improves. More attention-saving delivered to users per unit of attention spent building. That’s genuinely good. That’s technology doing what technology is supposed to do.

The distinction isn’t whether AI was involved. It’s whether the humans in the loop spent enough attention to ensure the output is understood, not just functional. The socially necessary attention, in Marx’s framing, for the thing to have real use-value.

The Heuristic

If the frame is useful, it should produce a simple rule of thumb. Here’s mine: did you spend at least as much attention as you’re asking someone else to spend?

This works across the whole spectrum of trust contexts. On a high-trust team where you’ve built up a long history of deposits into the shared attention budget, the dials can be set differently. Your teammates know you. They’ve seen your judgment. When you say “Claude and I looked into this and here’s what we found,” that’s a meaningful signal because they trust that you actually spent the attention, regardless of who typed the characters. The AI is a tool in the hands of someone they trust.

First-time open source contributions are on the opposite end of the trust spectrum. You have no history. No deposits. The only signal the maintainer has is the contribution itself and the interaction around it. An AI-generated PR with a generated description is asking someone to spend scarce attention evaluating work that appears to have cost you nothing. Even if you actually spent thirty minutes in a careful back-and-forth with an AI, the artifact doesn’t show that. The economy doesn’t balance from the reviewer’s perspective.

This isn’t about whether AI touched the code. It’s about whether a human spent sufficient attention. And “sufficient” is relative to how much attention you’re asking from others.

Who Owns the Means of Attention

The big question isn’t whether the conservation law holds. It’s who controls the infrastructure that attention flows through.

Right now, the frontier models are controlled by a handful of companies, and the per-token pricing model is — if we’re being honest about it — a new form of rent extraction. The entire corpus of human attention, scraped and compressed, sold back to us at metered rates. The landlord changed, but the structure is familiar. Marx would recognize this one too: enclosure of the commons, dressed up as democratization.

I don’t think this is the permanent state of things, but I’m not going to pretend the arc bends inevitably toward openness, either. The cloud era was supposed to democratize infrastructure, and what it actually produced was vast accumulations of capital into a handful of billionaire-controlled conglomerates. We’re all still pining for the web we lost, the one that got enclosed by the other attention economy, the demand-side one, the one that figured out how to monetize eyeballs and strip-mined the commons in the process.

So I hold the hope honestly but not naively: that the spirit of open source and the DIY ethos that built the internet will have its counterpunch here. The big corporate models are truly frontier now, but not forever. Hardware gets cheaper. Training techniques get more efficient. Community datasets get built with consent and transparency.

The version I want to believe in — and want to help build — is the one where the tools of attention-amplification are collectively owned. Transparent models, trained on community data by community resources, runnable on commodity hardware. Not because the conservation law stops applying, but because the gains from better attention-tooling should flow to the people spending the attention, not to the platform extracting rent on every token.

We’ll see. The substructure holds either way. But the superstructure, who benefits, who pays, who decides, that part is still being written. And that’s the part worth paying attention to.