Posts

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?

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.

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.

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.

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.

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?

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.

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.

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.

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.