Sam Zoloth

Essay / Part 5 of 5

The Work

Software was always a proxy for the work it automates. When code gets cheap, the work itself is what gets sold.

Sam Zoloth

Pencil sketch of the same factory conveyor belt as the previous cover, now running off the right edge of the frame. The belt is empty. At its start, a green text box with only a cursor in it feeds the line, and dashed outlines show output that hasn't been made. Title: The Work.

Stripe merges over 1,300 agent-written PRs a week. But Stripe sells payments, not pull requests. The product is the work those PRs enable: moving money, reconciling accounts, catching fraud. The pull request is overhead.

Julien Bek at Sequoia published a piece in March, "Services: The New Software," arguing that the next trillion-dollar company will be a software company masquerading as a services firm. That company sells the work instead of the tool. I've been writing about what happens when code gets cheap. Bek is writing about what happens next: the work itself gets cheap enough to sell directly.

What software was for

This series has been tracking a single thread. Features commoditize. Teams reorganize around factory infrastructure. The individual role compresses to judgment. The factory arrives. Each article followed the same force one layer deeper into how software gets built.

But software was always a proxy. Nobody buys Salesforce because they love databases. They buy it because managing customer relationships by hand is slow and error-prone. The software automates the work. What happens when AI can do the work without the software? That's the next domino. The factory stops producing software-as-product and starts doing the work that software was built to enable. The production line turns outward.

Copilots and autopilots

Bek draws a clean line. A copilot sells the tool. An autopilot sells the work.

Harvey sells AI to law firms. The lawyers use it, the lawyers take responsibility, the lawyers bill the client. That's a copilot. Crosby drafts NDAs for the company that needs them, not for outside counsel. WithCoverage sells insurance to the CFO, not to the broker. The professional stops being the customer and becomes the cost being removed.

By Bek's estimate, for every dollar companies spend on software tools, they spend six on services, which pay for the people doing the work the tools were supposed to make easier. Copilots capture the tool budget. Autopilots capture the work budget, which is six times bigger.

A diagram with two rows. In the copilot row, an AI company sells a tool to a law firm, which does the work for its client. In the autopilot row, an AI company sells the work directly to the company, and its arrow routes around a dashed box labeled outside counsel, captioned "The professional is the cost being removed." Below, one square marks $1 of tool budget and six green squares mark $6 of services budget.

I spent three months onboarding people to AI tools across two companies. That's copilot work. I teach someone to use Claude Code, they get faster, they own the output. The autopilot is what happens when the customer never touches the tool. They're buying the outcome.

The wedge is outsourcing. If a task is already outsourced, the buyer has already accepted three things: the work can be done externally, there's a budget line for it, and they're purchasing an outcome. Replacing an outsourced vendor with an AI-native service is a vendor swap. Replacing headcount is a reorg. Vendor swaps are easier. That's where autopilots start.

The addressable markets are in the hundreds of billions (insurance brokerage, accounting, healthcare billing, IT managed services), and those are just the categories where the outsourcing wedge already exists.

Intelligence and judgment

Bek splits work into intelligence and judgment. Intelligence is rule-following at scale: translating a spec into code, coding clinical notes into ICD-10 categories, filling out insurance applications. The rules are complex, but they are rules. Judgment is knowing which spec to write, which diagnosis matters, whether the policy actually fits the client's risk profile. It comes from experience and taste built over years.

Think about the defensibility matrix from The End of Features. Intelligence work lives in the upper-left quadrant: digital, copyable, commodity. Judgment work lives on the right: built on accumulated experience, embedded in relationships, resistant to replication. It's the stuff you can't paste into a prompt.

The higher the intelligence ratio in any field, the sooner autopilots win. Software engineering got there first. By Bek's count, software engineering accounts for over half of all AI tool usage across professions, and every other category is still in single digits. That's why the factory exists in our industry before it exists anywhere else.

The factory is excellent at intelligence work. An agent can write correct code, pass tests, ship a PR. The gap between "agent writes correct code" and "agent knows what the customer actually needs" is the judgment gap.

I've seen this in every onboarding session I've run. The primary blocker is never model quality or cost. It's what I've started calling the blank input problem: people stare at an empty chat and freeze. They don't know what to ask. A PM with access to the best tools in the world sits there with a blinking cursor because specifying intent — knowing what you actually want, clearly enough for a machine to do it — is judgment work. The tools can do the work. The bottleneck is knowing what work to hand them.

Inside one company, that's an onboarding problem. For an autopilot company it's existential, because it has to solve the blank input problem for every customer in its domain. It has to encode enough judgment about what "good" looks like that the customer can say "close the books" and walk away. That's a harder problem than building the agent.

As Bek puts it, "Today's judgement will become tomorrow's intelligence." He expects autopilots to accumulate proprietary data about what good work looks like in their domain. That's exactly the data flywheel I described in the first article. Crosby reviewed over a thousand contracts in its first months. Each one teaches the system what "good" looks like for that contract type, that industry, that jurisdiction. Code is commodity. The autopilot becomes defensible through accumulated judgment-data, the same way Google's search quality compounds through usage data. That's the right-hand column of the matrix, built one transaction at a time.

Innovator's dilemma for copilots

The copilot companies face a classic problem. Harvey sells to lawyers. Rogo sells to investment banks. Their customers are the professionals. To become an autopilot means selling the work directly to the company, which means the professional, your current customer, is now your competitor. You're cutting them out.

Bek names the dilemma directly. He wrote that the fastest-growing AI companies in 2025 were copilots, and that in 2026 many would try to become autopilots. They have the product knowledge and the customer relationships. But the transition means cannibalizing the people who pay you.

The professionals using copilots are the steersmen of their industries, still steering, still reviewing, still signing off. The autopilot is what comes after the steersman.

Bek calls this "the opening for pure-play autopilots," companies that start by selling the work from day one without a copilot customer base to protect. They don't face the dilemma because they never had the professional as a customer in the first place. Crosby didn't start by selling to law firms and then pivot to selling to companies. They went straight to the company. WithCoverage sells to the CFO and takes the broker's place.

What the factory changes

This series tracked what AI does to products, teams, individuals, and production. The business model is the last domino.

Beyond how software gets built, the factory changes what software companies are. The $1T outcome Sequoia is betting on is a software company that looks like a services firm: AI-native infrastructure doing the work that armies of professionals used to do, priced on outcomes, not seats. My series explains why the timing works. The factory makes code free. Free code makes features free. Free features make the tool layer commoditize. And when the tool layer commoditizes, the value migrates to the work the tools were supposed to enable.

Four dominoes on a line, three falling and one still standing in green. The labels read: the factory makes code free, free code makes features free, free features commoditize the tool layer, and value migrates to the work.

The uncertainty is the judgment question. Bek's entire framework rests on the intelligence/judgment split holding long enough for autopilots to accumulate the data that lets them handle judgment too. I've argued throughout this series that the layers keep collapsing. Problem selection, constraint definition, and drift correction were each supposed to be durably human. Each is partially automating. If judgment automates faster than expected, the autopilot replaces more than the outsourced worker. It replaces the firm that replaced them. And then it replaces whatever replaced that.

The factory made the guns faster. Now it's aiming them for you.