Most of the alternatives are a stack you have to stitch together: one tool for creative, another for search, another for social, a TV vendor, and a dashboard whose numbers don’t match your bank account. You either do that yourself after hours or hand it to an agency and hope. Waverunner is one product instead.

You start with a URL. It reads the site, proposes customer personas you can edit, and generates image ads, social video, and TV spots from your brand, with video from Wavemaker. Refine anything in chat before money hits the media. Fund a prepaid wallet, set a daily budget, and launch. That daily budget is a ceiling across every channel. No subscriptions, no contracts, no percentage-of-spend fees. Campaigns pause when the wallet runs dry.

Results come from a tag on your site, not invented dashboard numbers. Autopilot keeps tuning from that data and logs what it changes. When return on ad spend isn’t measurable yet, the dashboard says so instead of making something up.

Adwave started by making TV advertising accessible to businesses that could never afford an agency. Waverunner is that idea across every channel at once.

Try it: waverunner.adwave.com. Longer writeup on Adwave: Introducing Waverunner.

Related: What Used to Take a Team.

It came directly out of the work we were doing on Adwave’s TV ad creative. Once we had the pieces in place to spin up broadcast-quality commercials from a website URL, it was clear the same engine could make YouTube, TikTok, and Instagram videos for anyone, not only businesses running TV campaigns. So we pulled it out as its own product.

It has kept growing since launch. Beyond video, it generates platform-sized static image ads, and it can take long-form video you already have and cut it into vertical clips. For developers there’s a REST API, an MCP server, and a CLI, so the whole pipeline is scriptable.

It now lives at wavemaker.io. I also wrote it up on Adwave as Introducing Wavemaker.

Related: What Used to Take a Team.

That’s the pattern I want to end on, because it turns the whole series from a set of claims about the past into a question about the present, and it’s the question I actually care about.

Walk back through what the four pillars, taken at their strongest, would mean. If the solution is latent in scale, if systems self-organize toward the regime where computation happens, if independent searches converge on the same architectures, if a blind process already built components a thousand times denser than ours, then intelligence is not something we author. It’s something we cultivate, that arrives on its own timeline from arrangements we set up but don’t control. Gardeners, not sculptors. And a gardener doesn’t decide the morning the seed becomes a sprout. The plant decides. The gardener finds out.

Now stack three facts about our own situation on top of that, and the discomfort becomes specific. We didn’t design the capabilities, we specified an architecture and an objective and a pile of data, and the behaviors fell out. We can’t inspect the result, interpretability is real work by serious people and it is nowhere close to reading a large model the way you’d read a program. And we only ever named the last emergence in hindsight. Three for three, the recognition came after the fact, from systems we didn’t build in the usual sense and can’t open up to check.

So here is the finale’s actual question, and it isn’t whether intelligence emerges from networks. Suppose it does. Suppose everything in this series is more right than wrong. Would we recognize the next one arriving? We didn’t design it, so we have no blueprint that says “here’s the part where it starts reasoning.” We can’t inspect it, so we can’t watch the transition happen from the inside. And history says we name these things only once they’re finished. Put those together and you get a genuinely unsettling possibility: that a threshold could be crossed, in a system running in a data center, and the first solid evidence we’d have is the behavior on the far side, the way the first solid evidence of the last emergence was us, standing around eventually able to ask the question.

Let me argue the other side, because there’s a real one, and it’s the reason I’m not writing this in a panic. Capabilities are behaviors, and behaviors can be tested. We are not actually blind. We measure these systems constantly, we run evaluations, we probe them, and when a model crosses from can’t to can on some task, we usually do notice, sometimes within days, because someone tried the thing and it worked. The doom version of my question, that a mind could switch on unseen, leans on treating the system as a sealed box, and it isn’t sealed. It’s the most scrutinized artifact in the history of engineering. So the honest correction to my own unease is that recognition isn’t hopeless. It’s partial, laggy, and better than the gardener metaphor suggests.

But notice what that correction actually says, because it’s the whole point and it connects this series to nearly everything else I write. Recognition doesn’t come free with the emergence. The intelligence emerges on its own. The noticing does not. Someone has to run the probe, read the result, and have the judgment to see that this number crossing this line means the thing is now categorically different, not incrementally better. That act, catching the arrival and knowing what it means, is not itself an emergent property of scale. It stays exactly as scarce as it ever was. The capability gets cheaper every year. The judgment to recognize what a capability is, and what it’s now good enough to do, and whether the ground just shifted, does not get cheaper. If anything it gets rarer and more valuable, because there’s more emergence to keep up with and the same short supply of people paying the right kind of attention.

That’s the thread running under this whole site. When a resource gets abundant, scarcity moves to judgment and taste. It’s true of code, where execution went cheap and knowing what to build became the constraint. It’s true of capital, where money chases the conviction to recognize a thing before it’s obvious. And it turns out to be true of emergence itself, the biggest abundance of all. Intelligence may well arrive on its own, from networks we grew rather than built. What won’t arrive on its own is the recognition of what arrived. I’ve argued elsewhere that taste is the last thing the machines take, and this is the cosmological version of that claim: in a world where intelligence emerges whether we understand it or not, the scarce thing is the judgment to see it clearly, and that judgment is still, stubbornly, ours to supply or fail to.

So I’ll end where the honest version has to end, without the bow. We only named the last emergence after it had finished happening. We’re now growing systems whose capabilities we didn’t design and can’t fully inspect, and telling ourselves we’ll know the next threshold when we see it. Maybe we will. We’re watching closely, and watching counts for something. But the whole argument of this series is that the intelligence doesn’t wait for our understanding to catch up, and the whole argument of this last post is that catching up is the one job that was never going to be automated. Which leaves me with a question I can hold but not close: if the recognition is the scarce thing, and it’s on us, are we actually paying the kind of attention that would let us notice, or just the kind that lets us say afterward that we were watching?

Run the thesis through every domain this site has touched and it’s the same mechanism each time.

Code. Execution is abundant now. A model writes the endpoint faster than a team, and roughly as well for the intern as for the architect. The constraint moved to knowing what to build, which of five working versions to keep, and recognizing slop when it compiles. The way I work now, one person’s judgment amplified by abundant execution, is this thesis practiced daily.

Capital. Opinions about companies are abundant and costless. Every investor has one, and the no costs its holder a calendar slot. Conviction, judgment you pay to hold, stays scarce, and telling it from delusion is the founder’s actual job. The money was never the scarce input. The willingness to be accountably wrong was.

Media. Content is going abundant, video last of all, and the business is repricing around what can’t be generated: attention, trust, and curation. The editor’s judgment outlives the editor’s toolchain.

And intelligence itself. As raw capability commoditizes across model providers, every one of them selling roughly the same tokens at collapsing prices, the premium moves to knowing what to ask, what to accept, and what to want. The judgment layer sits above every model and ships with none of them.

So the definitional question can’t stay soft: what is judgment, exactly? Not intelligence. The models have that, in the measurable senses, and more arriving quarterly. Not information, which is abundant to the point of being the problem. Not confidence, which is worthless as signal, since the deluded and the visionary report identical certainty. Judgment is accountable choice under uncertainty. Deciding with stakes, owning outcomes, updating on consequences. The accountability isn’t decoration. It may be the load-bearing part. A model can rank options. It cannot own one.

The steelman deserves its own section, because it’s the whole ballgame: maybe judgment is only the last human job so far. Every “AI can’t do X” claim has had a shelf life, and models already critique, rank, and choose plausibly. Why should this capability be the one that holds?

I know two honest responses, and neither fully reassures me. The first is the accountability argument: judgment without ownership of consequences is just ranking, and ownership is a social fact about persons, not a capability. We hold people accountable because they can be harmed, praised, fired, jailed. That holds right up until society decides to assign ownership to systems, which is a choice, not a law of nature, and choices get made badly all the time. The second is the regress argument: even a world of superb machine judgment needs someone to decide which judgments to delegate, and that deciding is itself judgment. That holds until it too gets delegated, at which point the question stops being economic and becomes something older.

I’m not going to resolve that here, because I can’t, and pretending otherwise would be exactly the confident forecast I distrust. The optimism I’ve argued for elsewhere, that we can craft our future rather than be subjected to it, enters here as a stance rather than a proof. Judgment remains ours as long as we insist on keeping it, and the insisting is itself the job.

Every prior technology ate a human task and left the deciding to us, and each time, the deciding got promoted to being called the real work. Farming, typesetting, spreadsheets, chess. Maybe judgment is genuinely different, the thing that was always underneath all of it. Or maybe this essay reads in ten years the way “computers will never play chess” reads now.

Judgment is the last human job today. We don’t get to know for how long. What we build in the meantime is the answer we’re giving.

Strikes worked because factories stopped without workers. Collective bargaining worked because employers needed employees. The weekend, labor law, the expansion of the franchise, all of it flowed at least partly from the fact that ordinary people could withhold something the system required. And the violent fallback, revolution, worked when rulers couldn’t maintain control against enough motivated opposition.

AI threatens both levers at once. If the factory runs itself, walking off the job withdraws nothing. And organized resistance gets structurally harder in a world where communication can be monitored at scale, gatherings predicted, and potential organizers identified early. I want to be careful with that second half, because it’s speculation about capabilities that don’t fully exist yet, and the gap between what surveillance can do and what the extrapolation says it will do is still wide.

But if the premises hold, the conclusion is uncomfortable: whatever social contract exists when human labor stops being necessary is roughly the contract we keep. After that point, nobody outside the ownership class has standing to renegotiate. Not moral standing. Standing in the older sense, the kind backed by the ability to withhold something. Which means the terms of the post-labor settlement are being set right now, while human work still has leverage, by people who mostly aren’t thinking about it in those terms.

And the race dynamics guarantee the inattention. Any company that pauses to design the settlement falls behind companies that don’t. Any country that regulates carefully loses ground to countries that won’t. The window isn’t being ignored because nobody sees it. It’s being ignored because defection pays.

The strongest objection is that this whole argument assumes a discontinuity, and reality is gradual and uneven. Displacement will take decades. The physical trades lag. Partial leverage persists for a long time, and political power was never purely economic anyway. States need legitimacy, elites need compliant consumers and taxpayers, and mass movements have won concessions without withholding labor. Closing-window arguments also have a poor track record; the same structure was deployed about nuclear weapons and about globalization, and institutions muddled through both. I give that history real weight.

Here’s the counter that I think is the actual heart of this: gradual is worse, not better. A discontinuity would trigger a coordinated response. Whole industries displaced in a year would put the question on every front page and force a settlement while workers still mattered. A slow leak of leverage, industry by industry, profession by profession, never presents a single moment where anyone’s alarm goes off. Each individual displacement is absorbable, explainable, someone else’s problem. The frog-boil isn’t a flaw in the window argument. It’s the mechanism by which the window closes unnoticed.

I laid out the possible ownership structures in the previous post, and the honest summary is that the good outcomes all require deliberate action taken before the leverage runs out. That’s the part I keep circling without resolving, and I’m not going to fake a resolution here. Even if the window is real and closing, it isn’t obvious what using it looks like for any individual. I run a tiny AI-powered shop; I am, at micro scale, part of the trend I’m describing. Voting happens on a four-year cadence against a technology moving on a four-month one. The people with the most leverage right now, the ones whose work trains and steers these systems, are the ones with the least incentive to spend it. I don’t have a move to recommend. I have a clock, and the observation that nobody’s watching it.

If AI ends up doing most economically valuable work, the thing that decides everything is who owns the systems doing it. Income in that world is a policy choice made by whoever owns the machines. It can be generous. It can be revoked. Either way it isn’t leverage. A UBI granted by the ownership class isn’t sharing the abundance; it’s a rancher feeding horses he no longer needs. The horses don’t get a vote on the feed budget.

I’ve written about what abundance does to money and what it does to stored wealth. Both of those posts quietly assumed the ownership question away. This one puts it in the middle of the table and maps the possibility space, because “we’ll figure it out” is not a plan, and the options are countable. I only find five.

The first is the default, the one that happens if nobody does anything deliberate: techno-feudalism. A small class owns the AI infrastructure, everyone else exists at their discretion, and the arrangement is stable the way feudalism was stable, which is to say for centuries, because the lords never needed the peasants happy. Just compliant. The modern version comes with better entertainment, and a comfortable cage with AI-generated content piped in is still a cage. What makes this the default isn’t anyone’s malice. It’s that ownership is already concentrated in the handful of companies that can fund frontier training runs, and every year that passes without a deliberate alternative deepens the groove.

The second is state ownership. The twentieth century ran this experiment and the results were bad, but the standard explanation for why, the socialist calculation problem, the impossibility of central planners processing enough information to run an economy, is exactly the kind of problem AI plausibly solves. Which makes the political problem worse, not better. Central planning failed partly because it was incompetent, and the incompetence was a kind of safety rail. A planner that is economically competent and politically unaccountable is scarier than one that’s merely corrupt.

The third is the one I want to work: distributed ownership. Not universal basic income but universal basic capital, every citizen a shareholder in the productive base. Alaska has run a small version for decades with its Permanent Fund, oil wealth paying an annual dividend to every resident. Scale that structure to the machine economy and the horses own part of the ranch. The problems are real, though. Ownership concentrates over time; that’s practically what ownership means. Shares you can’t sell aren’t quite ownership, and shares you can sell get bought, and a few decades of buying puts you back at option one with extra steps.

The fourth is competitive fragmentation: different polities try different models and people sort themselves. It has the virtue of hedging, and the vice that selection pressure between systems favors the ruthless ones. The polity that spends its machine surplus on its citizens grows slower than the polity that reinvests it in more machines.

The fifth is AI-mediated governance, humans setting values and machines implementing them. Depending on the day I think this is either governance that finally works or value lock-in forever, and there’s something almost religious about building a god and hoping you specified it correctly.

Now the objection that deserves the floor, because it might dissolve the whole post: this could be premature by a century. Every automation panic so far ended with humans doing new work the panickers couldn’t imagine, and if human earning persists, AI ownership matters the way tractor ownership mattered. A lot, but not everything-deciding. There’s also a version where the premise fails from the other side. I’ve argued that frontier capability leaks and commoditizes, that the labs can’t keep what they sell. If intelligence gets cheap and ubiquitous, ownership concentrates far less than the feudal scenario assumes. The doom case requires AI that is both all-capable and enclosable, and so far those two properties have pulled against each other. I take real comfort in that. Not full comfort, because the compute and the distribution and the data centers enclose just fine even when the weights don’t.

What I can’t find anywhere in the five options is a mechanism that picks the good one. Which of these we get won’t be chosen by voters weighing the alternatives or philosophers refining them. It gets chosen by defaults, by whatever ownership structure exists at the moment the machines stop needing us, and the default is the first one. The window where that could still change is the subject of its own post, and it isn’t a comfortable one either.

The standard I keep coming back to is the signature. You don’t merge what you can’t explain. Not reproduce, explain, line by line if someone asks. The test for whether you own a diff is whether you could defend it with the model turned off. That sounds obvious until you’re twelve merges deep on a Tuesday and the code works and the explanation would take an hour you don’t have. The discipline is exactly as boring as every other discipline that matters, which is to say it’s a habit, not a principle, and habits are built on the days you don’t feel like it.

Review is the second piece, and it moves in the opposite direction from what people expect. It doesn’t relax because a model wrote the code. It tightens, for two reasons. Volume went up, so more code is arriving at the gate per unit of scrutiny. And the thing under review changed: it’s no longer the syntax, which the model gets right with annoying consistency. It’s the author’s understanding. A review comment like “walk me through why this lock is safe” used to be pedantry. Now it’s the entire point.

The third piece is blame, and I mean that word without drama. When AI-written code takes down production, the postmortem should name a person, and everyone should have known whose name it would be before the incident, not after. Accountability assigned after the fact is theater. Assigned in advance, it changes behavior on the way in, which is the only time behavior can change.

I run the solo version of all this, which is both harder and more honest. There’s no team to insist on the standard, so the insisting is self-imposed.

Now the objection worth sitting in, because it’s better than it first sounds: maybe authorship-based accountability is the wrong frame entirely. We don’t ask a construction foreman to explain every weld. We hold them to outcomes and inspections. Aviation holds a pilot-in-command responsible without expecting them to machine the turbine blades. Maybe software is maturing into that, and demanding line-level understanding is nostalgia for a craft phase that’s ending. I think that’s right for some layers of the stack and catastrophic for others, security and data handling being the obvious ones. A foreman who can’t explain the welds is fine. A foreman who can’t explain the load calculations is a collapse waiting for a date. The interesting question is where that line sits in software, and I don’t fully trust anyone’s answer yet, including mine.

Which leaves the unresolved part. This discipline only works if someone insists on it, and the insisting used to come from the social layer AI removed: the reviewer, the team, the culture that made “I don’t know, the model wrote it” an unacceptable sentence. A solo dev holding himself accountable is either the purest version of ownership or the least verifiable one. Probably both.

Every company paying for a frontier model is making the same wager: that the best model is worth a premium. It’s a reasonable wager right up until you notice how strange a thing “the best” is to pay for. You don’t pay extra for the best hammer once the cheaper one drives the nail. Capability has a ceiling defined not by the model but by the task, and for most tasks that ceiling arrived a while ago.

Here’s the part of that instinct the numbers back up. Epoch AI tracks how far open-weight models trail the closed frontier, and as of mid-2026 the gap is about four months, and it’s asymmetric. On hard reasoning, the closed labs still hold a real lead. On coding and agentic work, the gap has effectively closed. You can run an open model and not feel the difference on most of what you ship. Open weights aren’t the budget option anymore, they’re the volume leaders. Chinese open-weight providers now push close to half the tokens flowing through aggregators like OpenRouter, a share that sat near zero a year ago. And they do it for somewhere between a thirtieth and a fiftieth of the frontier price.

So the question is the right one: when the model already does everything you need, what exactly are you buying with the premium? A number you can’t feel?

But the case is harder than “open will catch up,” and harder in a way that should worry the labs more than any benchmark could.

You can’t sell the teacher without making the student

There’s a technique called distillation. You take a strong model, the teacher, feed it a large volume of carefully built prompts, capture its outputs, and train a smaller, cheaper model, the student, on those outputs until the student behaves like the teacher at a fraction of the cost. The crucial detail, in one lawyer’s framing of the recent disputes, is that it turns a public inference service into a training corpus for a rival. You don’t need the weights. You don’t need to break anything. Selling API access is enough to hand over the training signal.

This isn’t theoretical. In February, Anthropic accused three Chinese labs, DeepSeek, Moonshot, and MiniMax, of industrial-scale distillation: roughly 16 million exchanges across some 24,000 accounts, aimed at reasoning, agentic tool use, and coding. OpenAI leveled similar accusations at DeepSeek a year earlier. The companies named dispute the characterization, and you can argue about any single case. What you can’t argue is the economics underneath. Berkeley researchers recreated a reasoning model for $450 in a day. A Stanford and UW group did a version for under fifty dollars. Databricks’ CEO put it plainly: the technique is extremely powerful, extremely cheap, and available to anyone.

Sit with what that means for the business. A frontier lab’s product is access to the teacher. The act of selling that access is the act of distributing the training signal for the teacher’s replacement. You are, structurally, in the business of seeding your own competition, and the better your model, the more valuable the thing you hand out with every call.

The labs know it, and the tell is in how they’ve responded. OpenAI has said it now runs “a careful process for which frontier capabilities to include in released models.” That sentence is doing a lot of quiet work: the leading lab is deliberately holding some of its best work back from the product to keep it from leaking. When the defense becomes “don’t ship the full capability,” the product and the moat are already in tension.

The prices weren’t the whole story

Set distillation aside for a second. The prices you’re comparing aren’t the full cost picture.

Frontier inference is being sold somewhere between ten and twenty times below what it costs to serve, propped up by venture capital and hyperscaler cross-subsidy. The labs whose numbers went public this year were spending two to three times their revenue; compute, not salaries, is the dominant line. By several accounts the largest player loses money on every dollar of revenue it books. None of this is a scandal. It’s a land grab, the oldest playbook in software. But land grabs end.

And here’s the cruel geometry: as the subsidy unwinds, frontier prices are going up. The race to zero is happening on the open-weight side. The closed labs are adding capability and raising prices at the same time. Enterprises are already feeling it: companies burning through annual AI budgets in a single quarter, capping per-employee spend, standing up dashboards to meter token usage like electricity. The widely shared forecast is another 30 to 50 percent on frontier API prices inside two years as the economics normalize.

So the premium you’re choosing not to feel today gets more expensive at exactly the moment the free alternative gets good enough to make the comparison awkward. That’s not a gap. That’s a vise.

Where the doom case gets too clean

If I stopped here I’d be writing the same triumphant “open wins, pay nothing” post that’s all over the timeline, and I don’t believe that one, because two things complicate it badly.

First: the gap isn’t closing. It’s holding. Four months behind in mid-2026, slightly wider than the three-month average of the prior two years. “Open catches up” is the wrong tense. The accurate version is “open stays roughly a season behind, permanently, because the frontier keeps moving.” And whether a season behind is fine depends entirely on the job. For drafting an email, last season’s model is fine forever. For an agent acting unsupervised against a production system, the last few points of reliability are the difference between something that needs a human watching it and something you can trust to run, and that difference is worth a fortune the benchmark can’t show you, because value in that regime is non-linear. Eight points of capability can be the whole ballgame.

Second: the labs aren’t really selling models anymore. They’re racing to sell the layer above the model: agents, memory, tool use, integrations, the reliability and the product and the distribution. The base model is becoming a component. Watch the market sort itself out: even the open champions are bifurcating, splitting off closed premium tiers while keeping a free base a generation behind. Everyone is converging on the same shape, a paid frontier sitting on top of a commoditized floor.

Which is why “frontier models are doomed” is the wrong sentence. The model commoditizes; that part is happening and won’t stop. What’s under pressure is the specific bet: spend a fortune to train the smartest model and rent access to it as the product, full stop. Linux didn’t kill software. It moved the money up the stack and sideways into service, and the companies that read the shift early did fine. The frontier labs are trying to make that same move, from “we sell the smartest model” to “we sell the system you build on it,” before their core asset becomes free. Some will manage it. The pure token-vendor play is the one that looks hardest to defend.

The part that keeps me up

Here’s the knot I can’t untie, and I’d rather leave it honest than pretend I’ve solved it.

The open-weight ecosystem doesn’t replace the frontier. It feeds on it. Distillation needs a teacher. A model that’s four months behind is four months behind something. The cheap, good-enough, fifty-times-cheaper models that make the doom case so persuasive are, every one of them, chasing a frontier that someone else paid to discover.

So follow the doom case all the way down. If the frontier can’t be monetized, because the moment it’s sold it’s copied, and because its unsubsidized price is one most buyers won’t pay when good enough costs a fiftieth as much, then who funds the next ten-figure training run? The ending isn’t “the labs lose and we all get cheap intelligence forever.” The ending is that the engine everyone’s been distilling runs out of fuel, and the field settles into a permanent plateau a season behind a frontier that stopped advancing. The open models would be mortgaging a future they don’t generate.

I don’t know how that resolves, and I’m suspicious of anyone who says they do. What I know is that I route my own work the way most builders do now: open weights for the bulk of it, the frontier held back for the handful of jobs where the gap is the point. Which puts me on both sides of my own thesis: the person proving it, because I won’t pay the premium for most of what I do, and the person it would strand, because I still need a frontier to exist for the work that matters. Those two facts don’t reconcile. I’ve stopped expecting them to.

AI just automated the tuition away.

It does the grunt work better than a junior does, which makes not hiring the junior the economically rational move, and companies are making that move right now. Look at any team’s hiring this year: senior head-count holding, entry-level quietly gone. Each individual decision is defensible. Why pay a first-year to write the endpoint the model writes faster and cleaner? But stack the decisions up and the industry has done something strange: we kept the seniors and deleted the process that makes them.

Nobody decided this. That’s what makes it interesting. It’s what happens when every company optimizes for this quarter’s output, because every one of them is defecting against the industry’s supply of next decade’s judgment. A classic commons problem, and there is no one whose job it is to fix it. The senior shortage of 2035 is being manufactured right now, one rational hiring freeze at a time.

The counterargument deserves a full hearing, because it might be right. Maybe the apprenticeship was always an inefficient hazing ritual, and we’re nostalgic for it the way people get nostalgic for hard winters. A junior with an infinitely patient tutor that explains every mistake the moment it happens might learn faster than one waiting a week for a grumpy senior to get to their branch. Under that reading, AI didn’t delete the tuition. It cut the price and improved the instruction, and the juniors who do get hired will grow faster than we did.

The counter to the counter, and the crux of the whole question: explanation is not experience. You don’t learn why the abstraction was wrong by being told. You learn it by living inside the consequences of the wrong abstraction for six months, by being the person paged when it breaks. Whether AI-compressed learning transfers judgment, or only transfers knowledge, is genuinely open. I’d write both sides at full strength because I don’t know which one wins, and neither does anyone selling you certainty about it.

There’s a personal version of this question I can’t dodge: would I hire a junior today, for my own products? The honest answer is: not for the grunt work that used to be the job description. Maybe for judgment under supervision, if I can define what that looks like when the model already writes the endpoint. I don’t have a clean hiring plan that solves the commons problem. I have a worry that the path I took is closing behind me.

And there’s an uncomfortable connection to my own situation that I’d rather name than have pointed out. The solo-with-AI model I run works because I already have twenty years of judgment to spend. The tools multiply what the years built. That path isn’t available to someone starting now: the work that would build the judgment is exactly the work the tools absorbed. I argued in Taste Is the Last Moat that judgment is the durable asset. This is the other half: we may have dismantled the factory. I could be wrong that nothing replaces it. I hope I am.

The generation that benefits most from AI may be the last one trained without it.

For most of my career, the edge was execution. Moats were built out of headcount and velocity, the ability to ship the thing before someone else could. I built companies on that premise. Hire well, move fast, out-produce. AI hands execution to everyone at the same time, and an advantage everyone has is not an advantage. On most tasks, the code the intern gets back is roughly the code I get back. The gap that used to be typing speed and syntax is mostly gone. What’s left is everything upstream of the prompt.

What’s left is the string of decisions the model can’t make for you. Which problem is worth solving. Which of five working implementations is the right one. When “done” is done. What to refuse to build at all.

I keep calling this taste, and I want to be precise about what I mean, because it isn’t aesthetic preference. Taste is compressed judgment. It’s years of watching things fail, packed down into a reflex that fires before you can explain it. You look at a working implementation and something in you says no, and the reasons arrive afterward, if they arrive at all. The model has seen everything and judged nothing. It can hand you a thousand competent options, and it will hand them to you with total indifference about which one matters.

Now the objection I have to take seriously, and not wave off in a sentence: maybe taste is trainable too. Models already critique code, rank designs, and flag slop, and they’re not bad at it. If judgment is pattern-matching over outcomes, it’s next on the commoditization list, and this post becomes a comfort blanket with a two-year shelf life. I’ve sat with that one, because the history of “the machines will never do X” is a history of embarrassment.

I don’t think the honest answer is “models will never have taste.” I think it’s that taste is tangled up with accountability and context: knowing what this user, this business, this month requires, and being the one who answers for the call. A model can rank five implementations against a rubric. It can’t know that the second-best one on the rubric is the right one because the team that maintains it quits in March, or because the customer who asked for it doesn’t understand what they asked for. That last mile may compress far more slowly than code generation did. May. I’d rather admit the uncertainty than pretend the question is settled.

There’s a version of this argument that’s pure self-soothing, and the way to tell them apart is whether the writer concedes what taste costs. Mine cost twenty years, a lot of them spent shipping things that turned out to be the wrong things. That’s the part that unsettles me more than the trainability question, because if taste is compressed experience, and AI is removing the experiences that used to compress it, then the moat is inheritable but maybe not renewable. The people with taste today earned it the old way, writing the code themselves, being wrong in slow motion. The people starting today won’t get that route.

So the moat holds, for now, for the people already standing inside it. Where the next generation’s taste comes from is a different question, and a worse one, and it gets its own post.