Companies don't write their own code.
And that was rational.

Companies have not written their own code. That was not laziness. It was the rational choice under the old cost structure. The Independence part unwound that choice one layer at a time — auth, documents, code, and mail all moved from the vendor bundle to your own side. The Shift part now examines the consequence for the industry structure.

Every one of those consequences follows from one premise: enterprise IT was split into two parallel worlds, and that parallelism is what AI dissolves.

Writing It In-House Was Inefficient

Why did companies not write their own code? Because it was inefficient.

Writing code was labor that consumed vast person-months. Building one core system required designers, coders, testers, and PMs locked in for months or years. Keeping a specialist workforce at that scale in-house did not pay off for a single company. It also had to be kept busy so the work never ran dry. For most companies that was not possible.

This must not be misread. Companies avoided in-house development neither out of technical ignorance nor out of contempt for IT. They avoided it because it was inefficient. The multi-tier subcontracting structure arose for the same reason. Writing code required a large workforce, and it had to be sourced without any one company keeping it on staff (the structure is covered in 3-07).

A rational choice not to write. This is what split enterprise IT into two worlds.

Office Was Bought, Core Was Outsourced

When you implement "don't write it yourself," the options divide in two. You buy it, or you outsource it. And enterprise IT split cleanly along exactly that line.

• Office systems — documents, spreadsheets, mail, scheduling. Nearly the same at every company; generic work. If it is generic, there is no reason to build it. So you buy a package — Microsoft Office, then Microsoft 365.
• Core systems — orders, inventory, accounting, production control. Specific to each company; the business itself. If it is specific, no off-the-shelf product fits. So you outsource it — you commission an SIer.

These two grew up as separate worlds. They were computerized in different eras, by different vendors, from different talent pools. Office was carried by global product vendors. Core was carried by the domestic SIer pyramid. Inside the same company, the two stood side by side and barely touched.

The connection was just two thin seams. As 2-01: Becoming Independent from Microsoft and Google — The Whole Map showed, they were auth (Entra ID) and document sharing (SharePoint). Those two points were all that the core-system world and the office world shared.

Because They Stood in Parallel, the Tax Was Levied Twice

That the two worlds stood in parallel means the lock-in and the rent were levied twice over.

• The Microsoft tax — in the office world. Documents, calendar, and mail were bundled into one vendor's suite, with a per-seat monthly charge levied in perpetuity.
• The SIer tax — in the core world. Proprietary frameworks, multi-year maintenance contracts, and the enclosure of business knowledge made moving to another option impossible.

These two taxes arose separately, and both were paid. Being locked to Microsoft in office and being locked to the SIer in core were distinct phenomena. Each gripped the company independently. Escape one, and the other remains.

But at the time this was not a diseconomy. It was the rational equilibrium of the old cost structure. Buying and outsourcing genuinely cost less than building. As long as writing code took person-months, buying the generic and outsourcing the specific was rational beyond dispute.

AI Inverts the Premise

That equilibrium rested on a single premise: writing code takes person-months, so in-house is inefficient. When AI takes on execution, that premise vanishes.

As the Independence part showed, one person plus AI can stand up both worlds on the same OSS foundation. Office and core are no longer something to procure from separate vendors.

• Office systems — PostgreSQL, PocketBase, AsciiDoc and Forgejo (2-03: Lay the Foundation — SQLite, PostgreSQL, pgvector, DuckDB, Polars, 2-07)
• Core systems — PostgreSQL, FastAPI, the same auth and the same sharing (2-12: Build an API — Expose Core Logic with FastAPI)

The two ride on the same data foundation, the same gatekeeper, the same code. Generic and specific alike are stood up by one person plus AI. The very premise that buying and outsourcing is cheaper is gone, *because writing it yourself is no longer inefficient*.

When the Parallelism Dissolves, Both Industries Collapse at Once

This is the heart of the chapter. When office and core ride the same foundation, the seam that separated them disappears. Auth and document sharing are no longer thin bridges between two worlds but part of one foundation (2-01's section "This foundation becomes the core systems' foundation as it is").

And from here the consequence follows. Microsoft's grip on office and the SIer's grip on core were never separate phenomena. They were the two sides of one parallel structure, both born of the single rational choice not to write it yourself.

• The rationality of buying the generic produced Microsoft's rent.
• The rationality of outsourcing the specific produced the SIer's rent.
• Both issued from the same premise: code is a large workforce's person-months.

Now that the premise is inverted, the two collapse at once. It will not be that one dissolves under AI while the other survives for some separate reason. Because the parallel structure itself dissolves, both grips come off together.

This is the premise of the whole Shift part. The chapters that follow each view this single collapse from a different face — digital sovereignty and the Microsoft problem (3-03), the uneconomy of SIer commissioning (3-04), the nature of lock-in (3-05), companies hiring builders directly (3-06), Japan's specific transition (3-07), the revolution starting from below (3-08: The AI Revolution Starts From Below), and the near-term transition and its irreversibility from inversion (3-09). Each is the same single collapse, lit from a different angle.

Rebuilding Becomes the New Default

Step back once more. Companies not writing their own code was neither laziness nor incompetence. It was rational. Buying and outsourcing genuinely cost less than writing it yourself.

That rationality has inverted. Now that AI takes on execution, the premise that buying and outsourcing is cheaper has collapsed. So rebuilding it yourself is no longer a special decision. Stand up the generic with OSS, write the specific with AI. This becomes the new rational default.

The same rationality that once steered companies away from in-house now steers them toward it. The premise changed, so of course the conclusion changes. The question is no longer whether, only when, and led by whom.

Summary

This chapter set the premise of the Shift part: the parallelism of office and core, the double tax, and AI's inversion of the premise. The chapters that follow light each of the two worlds' consequences from a different face.

Before that, one tool goes down: the practice of checking a vendor's narrative against primary sources. The next chapter sets it out, and 3-03 then applies it to the office (Microsoft) side — checking, with that practice, why OSS and sovereign AI are now better on both economics and security.

Related articles

• 2-01: Becoming Independent from Microsoft and Google — The Whole Map
• 3-04: The Structural Uneconomy of the SIer Model
• 2-04: Write the Logic — Own Your Tools with Python and Flet