I read Nolan Lawson’s “We mourn our craft” and my first reaction was not grief. It was something closer to impatience: the same impatience I imagine a monk might have reserved for his peers when the printing press showed up. You’re calling this tragedy? Not because the feeling isn’t real, but because the framing is so familiar. Guilds always narrate their loss of monopoly as the death of quality. They mourn the dignity of the old process. They defend the rituals that used to gatekeep participation. And they treat the new tool like it’s an insult, because it collapses the cost of something they had to suffer for. There’s a version of this reaction that’s understandable. There’s also a version that’s just status preservation wearing a black turtleneck.

I’m a craft-heavy designer. I’m not saying this as someone who doesn’t care about the seam. I care about the seam. I care about the invisible decision that makes a product feel inevitable. But I also don’t have rose-tinted glasses about the way this stuff used to be done. “Craft” was not synonymous with “good process.” Plenty of the old workflow was theater: polished artifacts masquerading as truth, handoffs that pretended to be collaboration, decisions laundered through decks until nobody could name who actually believed what. And on the other side of that theater was a more practical problem: iteration was expensive. Another pass meant another meeting, another spec, another rewrite, another set of compromises. The cost of revision was high enough that we’d settle early and call the settling “taste.”

This is the first place LLMs felt less like magic and more like a structural shift: iteration suddenly got cheap. Not the kind of cheap where you stop caring—cheap in the way that makes you more exacting, because you can afford another pass. The craft part was never typing. The craft part is revision. It’s pushing the same idea through enough iterations that the unnecessary parts fall off. It’s finding the version that lands without your audience doing extra work. It’s deleting the clever thing because it makes the product worse. For most of my career, I’ve had ideas that were right but sounded wrong—half-formed in the way all real ideas are when they’re still alive. The problem wasn’t that I didn’t understand them; it was that I couldn’t always sequence them. I couldn’t always pick the starting point that would make the rest feel obvious. When you don’t land sequencing, people don’t say, “your framing could be clearer.” They say, in their own polite ways, “I don’t think you know what you’re talking about.” Once I had tools that could help reorganize and clarify what I meant—without changing the underlying idea—I watched the same concepts suddenly resonate. Not because the idea got smarter, but because it finally arrived in a form other humans could receive.

One of the strangest effects of this technology is that it changes the texture of the world at the same time it changes the texture of your own thinking. You’re supposed to be excited about leverage, and you are, sometimes; you’re supposed to be grateful for drudgery getting outsourced, and you are, occasionally. But then you look around and notice an inflation of language, of certainty, of output—and it’s like moving to a city where the air is technically breathable but permanently smoky. Everything is smoother and more confident. The sentences are shaped correctly. The answers arrive instantly. The code compiles more often than it deserves to. Surface plausibility becomes its own anesthetic, and you start to read with your guard up—not because you’re a cynic, but because you’ve learned that the new baseline is “presentable.” Presentable isn’t a synonym for true. It isn’t even a synonym for useful. It’s a synonym for passable at a glance, which means it’s optimized for the cheapest kind of attention: the skim.

If LLMs feel “good enough” for design right now, it’s only because we’ve spent the last decade acclimating the world to mediocrity. We industrialized the learning of craft through the bootcamp system—pumping out a generation that was taught the syntax of Figma but none of the soul of the work. They shoveled out just enough template-driven, plausible garbage that the baseline for “professional” dropped until a machine could finally clear it. The machine isn’t catching up to the masters; it’s catching up to the graduates. In a world where output gets cheap, the rare thing doesn’t become less valuable. It becomes easier to see, because it has to compete with a flood of things that look finished but aren’t authored.

The comforting story people tell themselves in moments like this is that “handmade” used to mean “flawless.” Before mass production, things were better. Before factories, there was craftsmanship. Before the machine, there was truth. The tech version of this story is the fantasy that “handwritten code” was a moral category: careful, correct, dignified. The myth is that the machine has introduced error where there used to be certainty. This is laughable to anyone who has ever shipped software. Before the first prompt was ever written, we were already drowning in massive backlogs, ridiculous “MVP” thin-slicing, and compromises left and right. We settled for mediocrity because the cost of excellence was a tax we couldn’t afford to pay.

People mock the output of LLMs today without realizing the irony: they’re mocking their own reflection. The machine isn’t introducing the rot. It’s just automating the same compromises we’ve been making in the dark for years. Scarcity doesn’t prevent mistakes so much as it hides them. If reproduction is slow, correction is slower. Authority can attach itself to a thing simply because it’s expensive to argue with.

The printing press didn’t arrive and purify language. It arrived and collapsed the cost of producing a page. That was the revolution. And when you collapse the cost of producing a page, the constraint moves. The problem stops being “can we make a copy?” It becomes: “which copies do we trust?” “Who gets to publish?” And “how do we correct mistakes when they can spread faster than any single person can refute?” We like to remember the printing press as a story about enlightenment, literacy, the spread of knowledge, and it was those things, partly. It was also pamphlets, propaganda, censorship, institutions built around credibility, and a long, messy reorganization of what counted as legitimate. The printing press didn’t make writing obsolete. It made writing abundant, and abundance forced society to invent new ways to separate signal from noise.

LLMs are closer to the printing press than they are to the scribe, but the analogy only becomes useful when you respect the differences. A printing press replicates. LLMs mutate. A printing press can scale the same misprint across thousands of identical copies. An LLM can scale a mistake across a million contexts with just enough variation to evade pattern-matching and shame. The bug is never exactly the same bug twice. The confident sentence isn’t repeated verbatim; it’s remixed. This is why the moment feels so uncanny: it’s not just that there’s more text, it’s that there’s more certainty-shaped text. It’s the feeling of being surrounded by people who speak in complete paragraphs about things they haven’t lived.

In software, the mutation shows up in a familiar scene: the PR that “looks right.” It compiles. It passes the existing tests. The variable names are clean. The comments are polite. The whole thing reads like an eager intern who learned how to sound senior by studying the cadence of senior engineers. And yet you can feel, in your teeth, that something is off. Not because the code is necessarily wrong, but because it isn’t grounded. It doesn’t seem to have an author in the old sense—someone who made the hard tradeoffs, who can explain the why, who can say I rejected three approaches because they would have boxed us in later. The change is plausible, but it isn’t published. It hasn’t been forced through the tunnel where you have to confront edge cases, simplify the design, delete your favorite idea, or accept that the system can’t do everything at once. It’s not that machines can’t help with those things. It’s that they don’t feel the social cost of getting them wrong.

The complaint about “craft” is really a complaint about that tunnel being skipped—and about what happens when incentives reward skipping.

If you want a more honest lens for what happens next, don’t look at software first. Look at any market where abundance and taste coexist. Mass production doesn’t erase craftsmanship; it clarifies it. It lowers the value of the average unit while raising the value of what’s hard to scale: selection, proportion, finish, the refusal to compromise, the ability to say no. People don’t pay a premium for “more material.” They pay for the invisible part: a mind, a discipline, a coherent point of view—plus the comfort that someone will still be there when it breaks.

Software is going to split the same way. Not into “good code” and “bad code,” because that’s not how people experience products. It will split into commodity and couture—into software that is abundant and software that is authored. The commodity tier will be competent more often than it used to be, which is genuinely a gift. The couture tier will not be about more features. It will be about coherence, sharp defaults, performance that feels intentional, privacy that isn’t negotiable, reliability that is boring in the best way, and—most importantly—stewardship. It will be about the feeling that someone is responsible for this thing continuing to be itself over time. Which brings us to the real premium product that will emerge in an LLM world: not syntax, not speed, not even raw correctness, but named accountability.

People talk about provenance like it’s a technical feature, like it’s a checkbox. Provenance is not a checkbox. Provenance is an imprint. It’s the simple, powerful claim that says: this came from here; it was made by these people; they believe these things; and if it breaks, they will feel it. In a flood of plausible artifacts, the imprint becomes the thing you pay for, the thing you trust, the thing you choose when the cost of being wrong is real. You can already see the outline of this emerging: products differentiating on the presence of a maintainer, on the legibility of decisions, on the taste and speed of fixes, on whether the team has the courage to say no. In an abundant world, “taste” stops being a decorative word and becomes an operational one. Taste is just values expressed consistently across a thousand decisions. Accountability is those values being expensive to betray.

If that sounds like what senior engineers were “always” paid for, it’s because it is. The best engineers were never valuable because they could type faster or write flawless code. Code was never flawless. The leverage was in architecture and problem-solving—seeing the shape of the system, choosing constraints, navigating tradeoffs, and making the few decisions that prevent a thousand future decisions. The best product designers operate the same way when they’re at their best: not pushing pixels for the sake of pushing pixels, but deciding what matters, what doesn’t, and what the product is willing to be. That kind of craft doesn’t disappear when syntax gets cheap. If anything, it gets exposed, because you can no longer hide behind output as proof of value.

This is where the pessimism belongs, because the short-term is not the couture world. The short-term is the flood. Incentives will reward the flood. Companies will forget what good products feel like the way organizations always do: slowly at first, then suddenly, as the people with taste are pushed out of the room and the people with dashboards take over. Marketing expands, product shrinks, and the org starts optimizing for numbers that move rather than truths that endure. LLMs don’t create these incentives, but they are gasoline. They make it easier to satisfy the incentive without doing the hard part, which is choosing the right problem and caring about the answer. They let you generate a thousand “solutions” while avoiding the humiliating work of discovery: talking to users, confronting constraints, admitting you were wrong, deleting your favorite idea, shipping less.

But long-term, I think there’s a more hopeful trajectory hiding under the garbage. Lowering the cost of development doesn’t just get you more junk. It gets you more attempts. It gets you more weird ideas. It gets you more niche software. It gets you more tools built by people who actually feel a problem in their bones but previously couldn’t justify the cost to explore it. They couldn’t afford the team. They couldn’t afford the calendar time. They couldn’t pay the syntax tax. Now they can. And when the barrier to entry is lower, idealism can flow through product design again—not because everyone becomes a genius, but because more people can try without permission.

This is what I mean by the new maker class. Not “everyone becomes a great builder.” That’s not how humans work. The world does not converge to one uniform quality level. It becomes more variable. Drafts become cheap. Attempts become cheap. And in that variance, singular vision becomes more visible, not less, because it’s the scarce part. The premium returns to the people who can do what machines don’t reliably do on their own: decide what matters, choose constraints, reject the plausible nonsense, and stand behind the result. And for the rest of us, the de-skilling of syntax is not a tragedy so much as a liberation. If you’ve ever felt the frustration of knowing exactly what the system should be, and being stuck behind the chore of getting the incantations right, you know what a waste that can feel like. Offloading syntax can create cognitive space for exploration, for iteration, for actually thinking.

We keep asking the wrong question about this moment. The question isn’t “can AI build software?” It can, in the way a printing press can produce pages: quickly, cheaply, and without judgment. The real question is what becomes valuable when production is abundant. My bet is that the craft migrates downstream. The craft becomes editing. Verification. Judgment. Stewardship. The ability to look at something plausible and insist on something publishable. And, quietly, the return of a very old economic truth: when the world can generate infinite pages, the premium belongs to the people who can decide which pages deserve to exist—and who are willing to put their names where the colophon goes.