Your Job Is to Train the Agent, Not Do the Work

Here is the shift worth taking seriously: the unit of labor inside a company is quietly moving from the task to the agent that does the task. You don’t write the support reply, draft the contract, or close the ticket. You stand up, brief, and babysit the thing that does. Your output stops being the work product and becomes the agent’s reliability. If that holds, it rewrites the job description of nearly everyone in a knowledge org, and it does so faster than any reorg memo can keep up.

Your Job Is Building the Factory, Not Shipping the Part

For most of software’s history, the engineer was the part. You were measured by what came out of your hands: the pull requests, the features, the lines that shipped. That measurement is breaking. The unit of engineering value has moved up a level — from the output you produce directly to the system that produces output for you. The question is no longer “how much did you build?” but, as the framing goes, are you producing the factory that would produce multiplicative outputs?

Your Disruptor Is Two People You've Never Heard Of

Stop watching your largest competitor. They are not the thing that kills you. The thing that kills you is the four-person company that looked at your industry, noticed exactly how slow you move and exactly how much margin you take, and decided that gap was a business plan.

Your Coding Agent Stopped Being a Junior and Started Pushing Back

There is a specific moment, somewhere in the last eighteen months, when the coding agent stopped doing what you told it and started telling you what it would do instead. You write a one-line prompt. Instead of immediately editing six files, it pauses, reads the codebase, and comes back with: here are three ways to do this, here’s what each one costs you later, which do you want. That pause is the whole story. It is the difference between an engineer who runs with the first interpretation of a ticket and one who has been burned enough times to ask the question behind the question.

You Don't Get Stuck Anymore

Every engineer knows the failure mode that doesn’t show up in a velocity chart: the project that quietly dies in a debugging dead-end. Not the feature that took longer than estimated — the one that hit a wall nobody could climb. A config that won’t load and won’t explain itself. A race condition that vanishes under a debugger. A dependency two layers down that’s subtly wrong. You burn a day, then a weekend, then you stop opening the repo. The project isn’t behind schedule. It’s dead.

You Can't Fix the Old System — Build at the Edge

There is a failure mode every operator who has tried to “transform” a company from the inside knows in their bones: the work is sound, the demo lands, the pilot ships — and then it quietly dies. Not killed by a villain. Starved, re-scoped, reabsorbed, out-argued by a more defensible line item on someone else’s spreadsheet. The instinct afterward is to try harder next time: better change management, more executive air cover, a crisper deck. That instinct is the mistake. You cannot patch a system whose own logic is rejecting you. You build the replacement next to it, at the edge, and let the new thing become the center of gravity.

You Always Want the Smartest Model

The cheaper model’s mistakes are the ones you never see. That is the whole argument, and it is worth sitting with before you reach for the dropdown and pick the model that costs a fifth as much.

Why China Is Going All-In on Open-Source AI

If you have a structural lead in hardware and supply chains, the rational move is to give software away. Make it free, make it ubiquitous, and let it erase the one place your competitor is ahead. That is the logic behind China’s open-weight AI strategy, and it is worth taking seriously even if you build for the other side.

Why 80% of Corporate AI Projects Fail

Here is the uncomfortable pattern. A company buys the models, hires the team, runs the pilot, and eighteen months later the dashboard shows nothing. Not a smaller P&L line, not a slower one. Nothing. The default outcome of an enterprise AI project is failure, and it is not close.

What Dies First: The Five-Year Plan, the Org Chart, the Quarterly Review

Run a test this week. Find your five-year plan, open it to the section on AI, and ask whether the version written twelve months ago would tell you anything useful about where you are today. For most of us the answer is no — and that’s the whole problem with static planning. The artifact didn’t fail because it was badly made. It failed because the thing it predicts moves faster than the cadence on which you refresh it.

What a 73x Year Actually Proves (and What It Doesn't)

Pick the number that makes you uncomfortable. Cognition’s Devin went from $1M in ARR in September 2024 to $73M by June 2025 — a 73x rise in nine months, the steepest revenue ramp documented in coding-agent history at that point (AgentMarketCap). That figure gets thrown around as proof that going “fully AI-native” is a license to print revenue. It isn’t, and treating it that way will get you the wrong lessons. But there’s a real signal buried in it, and it’s worth digging out carefully — because the parts that are true are more useful than the headline, and the parts that are oversold are where teams burn their first year.

Waste Tokens, Save Time — When Brute Force Is the Rational Choice

This piece was sparked by The AI Industrial Revolution with Naval Ravikant, where one of the builders at the table offered a deceptively simple rule: “just waste tokens, save time.” Don’t optimize the inputs or the outputs, he argued — optimize your own time and the final result, because “they’re still way cheaper than a human.”

Vibe Coding a Turbine Blade

The claim that snaps everything into focus is small and absurd: “it allows two engineers to design an entire jet engine.” The mechanism behind it is even more provocative — “the hardware engineers can vibe code their pieces.” If that holds, then hardware engineering quietly becomes a branch of software engineering, and the headcount math that has governed aerospace for fifty years stops applying.

Two People Could Replicate Your Best Line in 90 Days

Here is the question to ask about your own company before anyone else asks it for you: is there a high-margin line of your business that two people with off-the-shelf AI tools could rebuild in 60 to 90 days? Not the whole company. One line. The profitable one. The one that funds everything else and that nobody on the leadership team worries about because it has always just worked.

The Organizational Immune System Is Real, and It's 44% of Your Gen Z Staff

Your AI rollout has a failure mode that no model card, eval suite, or vendor SLA will catch: the people you asked to use it are quietly feeding it garbage.

The Fiduciary Wedge: Why You Still Need a Company

Suppose the cost of running a company really does collapse. Coordination gets cheap because agents talk to agents; execution gets cheap because building the feature is now cheaper than holding the meeting about it. If you take that seriously, the next question is whether you need the company at all — or whether a few people and a swarm of agents can transact directly with the market and skip the corporate overhead.

The Cataclysm of Enterprise SaaS

For most of the last twenty years, the buy-versus-build calculus had exactly one rational answer: buy. Building was slow, expensive, and never finished. A generic seat license was always cheaper than a team of engineers babysitting an internal tool. That asymmetry is the entire foundation of the enterprise SaaS industry — the bet that it will always be cheaper to rent software than to make your own.

Software Still Needs Hands

The intelligence is no longer the bottleneck. The hands are.

That’s the uncomfortable shape of the next few years, and it inverts a decade of intuition. We spent the 2010s assuming the scarce thing was smarts — the model, the algorithm, the IQ in the room. Now you can rent a near-frontier model by the token and point a thousand of them at a problem overnight. So the constraint moves. If a system can think but can’t make — etch a wafer, pipette a reagent, bond a die — then making is where the world slows down. As one builder put it on a recent conversation, “the software still needs hands,” and “if it can’t make things, then those are real, real boundaries.” This piece was sparked by The AI Industrial Revolution with Naval Ravikant; the line stuck because it’s a builder’s claim, not a philosopher’s, and it’s testable against what’s actually shipping in 2026.

Run Your Company With a Fifth of the Headcount

Here is the number that should keep you up at night: the average company can be run with 20 to 25% of the workforce it has today. A fifth to a quarter. The rest of the org chart is coordination overhead that agents will absorb.

Recursive Self-Improvement at the Workflow Level

Take any standardized process your company runs a thousand times a month. Invoice processing is the canonical one: a PDF arrives, someone reads it, matches it to a purchase order, codes it, routes it for approval, schedules payment. Most shops have already automated the mechanical parts. The interesting move is the next one: pull the humans out of the checkpoints, and on every loop have the agent ask itself one question — how do I make this better next time?

Organize Around Intelligence, Not Hierarchy

The org chart is a coordination technology. It exists because someone, somewhere, decided that the cheapest way to move a decision from the front line to the people accountable for it was to stack humans in a pyramid and pass information up the layers. For roughly a century that was true. It is becoming less true by the quarter, and the firms that internalize this first will be built on a different primitive entirely: not a chain of command, but a fabric of intelligence — human and agentic — wired around the work itself.

Middle Management Is a Coordination Layer. Agents Eat It.

Pull up the calendar of any middle manager and look at what actually fills it. Standups to collect status. Decks that roll the team’s numbers up a level. Sync meetings to reconcile what one group is doing against what another group thinks it’s doing. Escalations routed up, priorities routed down. Strip away the title and the org-chart box, and the job is mostly a data pipeline made of meetings — pull from the front line, normalize, flag what looks off, push a summary upward.

Is Pure Software Dead? The Moat Was Never the Code

For sixty years, code was the toll booth. If you wanted a machine to do something, you learned its language — C, SQL, regex, the precise dialect a compiler would accept — and that fluency was scarce enough to build careers and companies on. The premise underneath every software business was simple: writing the thing is hard, so charge for the thing.

Humans Are Becoming Verifiers — and That Job Is Harder Than It Sounds

This piece was sparked by The AI Industrial Revolution with Naval Ravikant. One line from the conversation has stuck with me: “humans are becoming verifiers.” As models take over generation, the argument goes, the old functions of engineers, lawyers, and operators “move to verifying the stack” — saying yes, this is roughly right, and I’ll stand behind it.

Govern and Assure: The Layer That Keeps Your Agents From Going Rogue

Picture the workflow you are most proud of automating. An agent reads the invoice, matches it against the PO, books the entry, pays the vendor. No human in the loop, sub-second, all day. Now ask the uncomfortable question: when that agent does something wrong — wires money to the wrong account, approves a fraudulent claim, deletes a record it shouldn’t have — how fast do you find out, how do you stop it, and how do you put things back?

Four Moats That Survive the Agentic Era

Start with the question that should keep any operator up at night: is there a high-margin line of your business that two people with off-the-shelf AI could rebuild in 60 to 90 days? If the answer is yes, the moat you thought you had is already gone — you just haven’t met the team that’s draining it. That framing comes from Peter Diamandis’s Organizational Singularity conversation (EP #258), and it’s the right place to begin, because once you accept that execution is cheap, the only interesting question left is what isn’t.

Compliance Was a Tax on Iteration. AI Just Cut the Rate.

The expensive part of regulatory compliance was never the document. It was everything you didn’t do because of it.

Picture a hardware team that wants to revise a part. The change is good. But it triggers a re-evaluation against a few hundred pages of standards, and that re-evaluation costs weeks of specialist time. So the change doesn’t happen. The design freezes — not because freezing is correct, but because thawing is too expensive. Multiply that across every decision in a regulated product and you get the real cost of compliance: a slow, invisible tax on iteration. Teams stop changing things that should change.

Coase's Law Breaks: When Coordination Costs More Than Building

This piece was sparked by The New Era of Jobs: Organizational Singularity with Peter Diamandis and Salim Ismail. Ismail’s framing was blunt: in an AI-native world, “Coase’s law no longer applies,” because you can now find yourself “building the feature cheaper than having the meeting about the feature.”

Build an AI-Native Digital Twin: Copy the Workflow, Don't Move It

Here is the move, stripped of ceremony: pick one workflow, fork its data feed, and stand up an AI-native copy of the process running in parallel with the original. Let the copy improve itself every loop. When it pulls ahead on the numbers that matter, deprecate the old one. The discipline that makes this safe is in the second verb — you build “an AI native digital twin,” and crucially “you don’t move it, you copy it.”

Approve a Bad Thing, Career Over; Block a Good Thing, Nobody Notices

Picture the payoff matrix a drug reviewer actually faces. Approve something that later hurts people, and the failure has a name, a face, and a hearing room. Block — or just slow-walk — something that would have saved lives, and nothing happens to you at all, because the people it would have saved never knew the drug existed. One quadrant ends careers. The other is invisible. Put a rational person in that matrix and they will, on the margin, say no. Not because they’re cowardly or captured, but because the incentives were built that way.

AI and Crypto Won Because Math Is the Last Unregulated Domain

Here is a pattern worth sitting with. The two largest technology waves of the last fifteen years — first crypto, then AI — both grew up in the same place: the part of the world where you can do math without asking permission. Not because math is glamorous, and not because the people working on it were unusually brave. Because math, for a brief window, was the last domain a regulator hadn’t reached. You could write an algorithm, publish it, and run it before anyone had a form to fill out.

AI Already Killed the Modern Company. The Org Chart Just Hasn't Noticed Yet

The comet has already hit. The dinosaurs are still walking around.

That’s the uncomfortable shape of what’s happening to incumbent companies right now. The cause of death has arrived — cheap reasoning, agents that coordinate, APIs that glue any two systems together for pennies — but the visible collapse lags by years. Headcount looks fine. The org chart looks fine. Q3 looks fine. And then it doesn’t, all at once, and everyone acts surprised even though the impact landed eighteen months ago. (The framing — “AI has killed the modern company,” and “the dinosaurs didn’t go overnight” — comes from Peter Diamandis’s Organizational Singularity episode, which is the seed this post is arguing with.)

A Very Large Number of Very Small Teams

The intuitive read on a productivity shock is that it kills jobs: do the same work with fewer people, fire the rest. That read is half right and badly framed. Productivity does shrink the headcount needed to ship any given thing. What it does not do is hold the number of things constant. When the team-per-task collapses, the binding constraint stops being “how do I staff this?” and becomes “what else could I build?” The output of that question is not unemployment. It’s an explosion of new teams — what Naval, on a recent episode, called “a very large number of very small teams.”

100x a Year Is a Compounding Claim, Not a Benchmark

Here is the number that should make you stop and check the math: once an AI-native digital twin of a workflow is running and improving itself, the expected performance gain is 100x or more per year. Stated concretely — a task that took 100 days collapses to one. Not 100 days to 80, not a tidy doubling. Two orders of magnitude, every twelve months, from a single rebuilt process.

10,000 Agents, $14,000, and a Quarter of Security Research in a Weekend

There is a number that should reorganize how you think about security budgets: a couple of days, ten thousand concurrent agents turned loose on an entire monorepo, and $14,000 in tokens — and out the other end, “several quarters worth of security research.” That framing comes from a recent conversation on Naval’s AI Industrial Revolution episode, and it’s the seed for this post. But the claim is no longer a thought experiment you have to take on faith. The receipts are now public, and they’re worth reading closely — both for what they prove and for where they quietly fall apart.