Julien Bek's Services: The New Software (Sequoia, March 2026) has become the dominant lens for thinking about applied AI this year, and for good reason. The framing is sharp: for every dollar spent on software, six are spent on the services around it. The next trillion-dollar company will not sell the tool. It will sell the work.
Bek's argument is hard to disagree with. Copilots assist humans. Autopilots replace them. A company spends ten thousand a year on QuickBooks and a hundred and twenty thousand on the accountant who actually closes the books. The next legendary company simply closes the books. Multiply that pattern across insurance brokerage, claims adjusting, tax advisory, medical coding, legal review, IT managed services, procurement, recruiting, consulting - and the addressable surface is staggering. Nine verticals, each worth between twenty billion and four hundred billion dollars.
The piece is correct. It is also incomplete.
The question Bek did not ask
Bek's nine verticals will not be won by nine companies. The work inside each one fragments into hundreds of niches. Commercial-lines brokerage is not the same business as marine cargo brokerage. Multi-jurisdiction VAT compliance is not the same as US sales tax. Medical coding for radiology is not the same as for oncology. Each niche has its own regulations, its own counterparties, its own data formats, its own definition of "done."
The operators who understand these niches are not in Silicon Valley. They are the ex-broker who spent fifteen years writing commercial liability policies. The ex-CPA who built a practice serving Nordic family offices. The compliance lead who lived through CSRD and now sees what is coming with the Digital Product Passport regulation. They know exactly what an autopilot in their domain would need to do, what it would need to integrate with, and what the failure modes look like.
They cannot build it.
This is the gap Bek's framework names but does not address. The autopilot economy he describes assumes the autopilots will exist. The question of who builds them, with what tools, on what timeline, is left to a sentence about engineering being hard. In practice, that sentence is the whole game.
Code generation is not the bottleneck
The obvious response is that AI now writes code, so the bottleneck has moved. This is half true and misleading.
A non-technical operator typing "build me an insurance brokerage autopilot" into a code-generation tool produces a demo, not a business. The demo does not have authentication. It does not have a database with row-level security. It does not have OAuth into the carrier APIs. It does not have a credit-metering layer for the LLM calls it makes on behalf of customers. It does not have multi-tenancy so that broker A and broker B cannot see each other's books. It does not have the orchestration logic that decides when to ask the human and when to act. It does not handle the case where the model returns nonsense and the system needs to fall back gracefully without leaking a 500 error to a customer.
Each of those layers is hard. Together they are why autopilots take engineering teams a year to build, not a weekend. Code generation collapses one of those layers. The others remain.
This is also why Bek's warning - "if you sell the tool, you are in a race against the model" - applies to thin tools and not to thick ones. A model can generate a React component. It cannot, by itself, generate a multi-tenant production system with deployment, integrations, runtime decisioning, and per-tenant data isolation. Those are orchestration problems, not code problems. They get harder as models get better, not easier, because the model now needs somewhere to run, something to integrate with, and a safe way to act on behalf of a customer.
The layer Bek skipped
The trillion-dollar opportunity Bek describes has a precondition: a way for domain operators to ship autopilots without an engineering team. Not a code generator. A production layer. Something that takes a brief in plain English and produces a working multi-tenant system with the integrations, runtime, deployment, and data isolation already wired in. Something the ex-broker and the ex-CPA can actually use.
This is the layer yellow3 is building. naffe.ai is a production platform for the autopilot economy. Domain operators write the brief; the platform produces the working system, including the parts that take engineering teams the most time. PassportHQ - a Digital Product Passport platform for EU SMBs targeting the September 2026 ECGT deadline - was built this way, in a single intensive session, end-to-end. It is a textbook Bek-style autopilot: outsourced today, intelligence-heavy, regulation-driven, hard deadline. It exists because the production layer existed.
The interesting consequence: every improvement in the underlying models makes naffe.ai outputs better automatically. The compounding logic Bek attributes to autopilots applies to the layer that produces them. The model improves; the production layer improves; the autopilots shipped on top improve. That is not a race against the model. That is the same wave.
What Bek named, and what comes next
Bek named the prize correctly. The trillion-dollar company will sell the work. But the question of who builds the autopilots that sell the work, and how, and how fast - that question matters more than the framework suggests. Most of the value will be captured by domain operators with deep vertical knowledge. They will not write code. They will write briefs.
The companies that give them the production layer will not be in the same race Bek describes. They will be one layer underneath it, and the position is excellent.