Michael Heilemann, The Norseman / The Viking
At the end of my last post, I said that AI isn't the first technology to make one step of working with information dramatically cheaper. The same thing has happened before, and the pattern is worth looking at. This is that post, and it really is the last one from me on AI. I promise.
In the first three blogs I wrote about how I work with AI: treating it like a chess opponent where I think while it moves, accepting that it's a good programmer but not a software engineer, and watching the cost of trying an idea fall far enough to change which ideas I pursue. This post asks whether any of that is new. My answer is that the details are new, but the shape of it is very old.
-=[ Three Steps: Production, Duplication, and Distribution ]=-
Working with information comes down to three broadly defined steps: creating it, copying it, and getting it to the people who want it.
For most of history, the most expensive of those steps set the pace. When a technology made that step dramatically cheaper, the effects went well beyond that step. They changed who could take part, what was worth doing, and what people tried that they never would have before.
I see three big transformations in how we work with information. Two have already played out over history, and the third, production, is happening now. They're not completely separate: each affects the others. But each time, one step becomes dramatically cheaper, and the effects ripple outward.
-=[ Duplication: The Printing Press ]=-
Before Gutenberg, a book was a copy made by hand, one at a time. A scribe could spend months on a single volume, and books were priced and guarded accordingly. The ideas in them existed, and what was scarce was copies of those ideas.
The press didn't decide what was worth printing or what the books should say. It took the copying step and made it cheap. The effects went well beyond printing itself.
The photocopier put the press in every office, and cassettes and VCRs put it in the living room. Digital files finished the job, because a digital copy can be identical to the original and costs almost nothing to reproduce, that's why I can make this article available to anyone with an internet connection.
I run into this every time I capture an Apple II floppy. A .DSK file is a duplicate of a physical object, and as long as the capture is good, it never wears out. Disks I would have had to treat as one-of-a-kind artifacts can now be copied a thousand times, and that's the reason any of this preservation work is possible. I can also take that same captured DSK file and write it back in its original form on new media.
-=[ Distribution: The Internet ]=-
Once copies were cheap, the bottleneck moved. A printed book still had to be shipped, stocked, and found, and a good idea could sit in a warehouse for years without reaching the person who needed it.
The telegraph cut the delay for news from days to minutes. Radio and television let one source reach millions at once. But the internet took the cost of reaching someone close to zero, and it did it for anyone, not just for publishers.
Social media pushed it even further. Anyone can publish something and potentially reach thousands or millions of people without a press, a publisher, an advertising budget, or even their own website. It also exposes the problem that comes after distribution gets cheap: curation.
When publishing was expensive, there was a built-in filter. Editors and publishers decided what was worth spending money to distribute. That filter was far from perfect, and it certainly didn't mean everything that got through was true or good, but there was at least a cost associated with getting something in front of a large audience.
The internet removed most of that cost. That's fantastic when you have something useful to say, but it also means misinformation, bad journalism, conspiracy theories, spam and just plain nonsense can be distributed just as easily as something valuable.
The technology didn't make people better at judging information. It just made information easier to get.
And that brings us back to the idea that every time you make one step cheap, you create a new bottleneck.
Repair DSK is one example. It searches online archives for images of the same disks so it can help recreate bad data. That only works because other people captured those disks and shared them where I could find them. Nobody coordinated that, and nobody had to. Cheap distribution made it possible for strangers to help each other preserve software from the 1980s.
-=[ Production: AI ]=-
That brings us to the third step: production. Actually making the thing has been the slow part for as long as I've been programming. It's what post 3 was about. The idea was never the expensive part, turning it into something I could try was.
The 80/20 rule is a good description of this problem. You can get most of the way to something relatively quickly, and then spend a disproportionate amount of your time getting the last part working properly.
This has happened to production before. Compilers did it for programming, and nobody writes machine code by hand anymore. As I said in the first post, though, a compiler doesn't decide what algorithm your program should use. It takes what you wrote and makes it executable. VisiCalc did it for financial calculations, letting one person do work that used to need a room full of people with calculators. It ran on the Apple ][.
Photography is another interesting example. For most of its history, taking a photograph involved relatively expensive equipment, film, processing and printing. You didn't casually take a hundred photographs because you weren't sure which one would turn out. You took the photograph you thought was worth taking and you didn't know if it was good until much later.
Digital photography changed that completely. Once the marginal cost of taking another photograph became effectively zero, people started taking photographs of everything. Most of them are terrible and are never looked at again. But the cost of experimentation collapsed, and so did the barrier to producing something genuinely good.
AI does something similar for software. It takes the stretch between "I wonder if this would work" and "here it is, try it" and makes that stretch dramatically cheaper. Where a compiler translates my decisions, AI also makes some of its own, which is its strength and its weakness, but it's still the production step that got cheaper.
Just look at what happened each time a step got easier. People didn't just do the same things faster. They did different things.
When copying got cheap, people stopped being careful about what deserved to be copied. Pamphlets, broadsheets, newspapers and cheap novels showed up, and most of what was printed wasn't very good, but some of it changed the world.
When distribution got cheap, people published things that would never have justified printing and mailing. My norsewanderer.com hobby site about the Apple ][ computer is a perfect example. No publisher would have touched it, and it exists because it costs almost nothing to put online.
I think production is doing the same thing now. The ideas that used to fail the "is this worth several weeks?" test are getting tried. Most of them won't matter. Some will be things nobody would have built otherwise, because the cost of finding out was too high.
That's exactly what I described in the last post. Repair DSK started as a simple batch tool, and it grew because each new idea cost little enough to try. The embedded emulator wasn't in the original design. It happened because I could afford to find out if it was a good idea, and because I was interested in using it myself.
Another example is something I built today. Unlike Repair DSK, this one wouldn't have existed at all without AI. I got tired of constantly going into Claude, opening Settings, and navigating to Usage just to see how much of my session I'd used. So I spent a few hours and built a small Windows application called Claude Usage Monitor.
It puts the session usage and other usage information I wanted in one place and has no external dependencies. Claude already provides this information, but getting to it was more cumbersome than I wanted.
A few years ago, I probably wouldn't have built it. I would have thought, "That's annoying, but it's not annoying enough to spend a day or two building a solution." Today I thought, "I can probably make that in a few hours," and I was right. I put it up on GitHub here if you are interested https://github.com/mheilemann/ClaudeUsageMonitor.
That's the change I'm talking about. The idea didn't become more valuable. The cost of acting on the idea became smaller.
-=[ Each Fix Exposes the Next Problem ]=-
There's another pattern in this history. Every time one step got cheap, the bottleneck didn't go away. It moved. Cheap copies made distribution the problem, and cheap distribution made production the problem.
So what moves next, now that production is getting cheaper?
I think the answer is curation and discovery. When anyone can produce almost anything, the challenge becomes finding the things worth paying attention to, separating the good from the bad, and getting the right creations in front of the people who will value them. Judgment still matters, but it only gets you so far if you can't discover what's out there.
That matches what I've seen. The AI chose plenty of implementation details for Repair DSK, some well and some poorly. It didn't decide the tool should exist, that comparing multiple captures was the right way to fix bad bits, or that running things in parallel was worth the trouble. In post 2 I called that the difference between a programmer and an engineer, and I think the engineer's part is the part that grows.
The time and focus spent learning how to get things right doesn't become less valuable when production gets cheap. It becomes more valuable. Experience, domain knowledge, and debugging instincts help you recognize which solutions actually work. But judgment alone isn't enough. When the number of possible solutions grows dramatically, we also need better ways to discover the ones worth using and get them in front of the people who need them.
-=[ The Wrong Thing First ]=-
This is also why the last line of my previous post matters. Sometimes the only way to discover what you really want to build is to build the wrong thing first.
That has always been true, but it used to be an expensive way to learn, because the wrong thing cost weeks or months. So we planned carefully, specified everything up front, and avoided experiments we couldn't afford.
When production is cheap, building the wrong thing first stops being a mistake to avoid and becomes how you learn what the right thing is.
I think of it as the same shift the press made. The press made it cheap to be wrong in print. The internet made it cheap to be wrong in public. AI makes it cheap to be wrong in code, and you find out faster, learn more, and end up with something better.
-=[ The Case of Software Engineering ]=-
Software engineering is not an ancient industry being slowly automated. It's a new industry.
I started programming more than thirty-five years ago, and even then the profession was still young. The term "software engineering" was coined in the 1960s, the personal computer was still new when I started, and the Web didn't exist yet. In roughly one human career, programming grew from a specialized discipline into an enormous industry, with software spreading into almost every other industry. Now AI is attacking the production cost of software itself.
It means the economics change. When the cost of producing software falls far enough, one engineer may be able to build things that previously required a team. Small companies may be able to attempt things that previously required venture capital. And software that wasn't worth building at all may suddenly become worth building.
But there's an obvious consequence on the other side of that equation. If dramatically fewer people are required to produce the same amount of software, the industry may not need as many programmers as it does today. We've already seen major technology companies reduce their engineering workforces, although there are many reasons for those layoffs, and it's difficult to separate the effects of AI from the rest of the industry's economic cycle.
It isn't just that programmers have a new tool. The thing the tool makes cheaper is the thing programmers are paid to produce. That is a very different kind of change.
I don't think the answer is simply "AI replaces programmers." The more interesting question is what happens when the cost of producing software falls so far that the limiting factor is no longer the ability to write it.
-=[ Where That Leaves Us ]=-
The printing press, the internet, and AI each took one step in working with information and made it dramatically cheaper, and each one changed who could take part.
The press let more people read. The internet let more people publish. I think AI will let more people create.
I'm not claiming this is all upside. Cheap production will mean plenty of low-quality output, just as cheap printing and cheap publishing did. The challenge is deciding what's worth making, finding what's worth keeping, and getting it to the people who need it.
But the history is encouraging. Each time, the people who benefited most were the ones with a real problem and the patience to work on it.
Prepare ye to plunder!
Michael Heilemann - The Norseman/The Viking