Structural Analysis
From software engineering to the liberal arts — the foundational shift of the technical profession
AI's code-writing ability has matched human top-class on public competitive-programming ratings (the Codeforces 2700 tier). It can also assemble a cyberattack autonomously — evidence of design ability. In the Mythos/Fable era AI became the strongest SIer, handling requirements, design, and build, and callable by anyone for $200 a month. The whole sub-series argues outward from that.
The most overlooked consequence of AI writing code is not faster coding; it is the structural shift of the maintenance phase itself. Because AI understands context, maintaining at the code level stops being necessary; the unit of maintenance moves from code to design, spec, and context, and the cost of reading legacy code evaporates. The shift is conditional on keeping design, spec, and context explicit and reconciled with reality; without it, AI-generated technical debt piles up fast.
The coder (the code-writing role) obviously disappears. But the subject of this chapter is what lies beyond — AI now does the software engineer's work too. Opus is a coder, Fable/Mythos software engineers; design and code are both carried by AI. What stays with humans is not designing and coding yourself, but building and operating a system in dialogue with AI — that is, the builder. What disappears is the role definition, not people.
The builder builds and runs whole systems in dialogue with AI — not the next version of the software engineer. The SE solves "narrowly closed problems" and is replaced by AI; the builder handles the "open problem" of raising what to build from reality. This chapter defines the builder as a loop — decide, build with AI, check, integrate — and, along the axis of the SE's narrowly closed problem versus the builder's open problem, shows why judgment cannot be left to AI.
The era in which customers themselves become builders. But the first move is not writing code — it is using proven OSS. Generic things use OSS first (most economical); personal things are customized on top of OSS in dialogue with AI (the worked examples are ch6–8); organizations stand up a foundation with OSS that replaces Microsoft 365, Copilot, and WordPress (the Independence part). Only the company-specific logic gets written with AI. What AI cannot do, the SIer cannot do either.
The lock-in is not weak features — it is that the layers are closed, and that the key (identity) is concentrated in someone else's hands. The Office suite and the core business systems stand on the same structure. And opening what is closed — that is AI's role. It unseals proprietary formats, reads unreadable code, and extracts imprisoned business knowledge. The Independence part, working with AI, unties the closed bundle into open OSS and moves the key to your side — auth with PocketBase, documents with OnlyOffice, code and sharing with Forgejo, mail with Stalwart, meetings and scheduling with Jitsi/Cal.com, web with Cloudflare Pages, data with PostgreSQL/SQLite/DuckDB, AI with a local LLM + RAG, core logic with FastAPI. This chapter is the map; the chapters that follow stand each one up.
The Independence part starts with the data layer everything sits on. SQLite is usually enough — a single file, no server, already built into Python. Step up to PostgreSQL only when you share and several people write at once. Enable pgvector for semantic search; analyze with columnar DuckDB and Polars — Excel stays the human's I/O while machines crunch the data behind it; pull far ahead of Power BI. The generic is already shared as OSS — you don't write it, you stand it up.
Authentication is not something each app builds on its own. It is a gate you stand up once and share. But the gate holds only the minimal common thing — identity. Authorization ("what you can do") is held by each app, each server, itself (defense in depth); the single-perimeter idea that "whoever passed the gate goes anywhere inside" is not the design. PocketBase is a single binary with email auth, OAuth2, one-time codes, MFA, an admin UI, and a REST API. Identity lives in the gate; business data lives in PostgreSQL. Step off Microsoft Entra ID's per-seat monthly bill.
A builder's work is to have AI write code, evaluate it, and integrate it. The place that code lives — the repository — gets stood up on your own side. Forgejo is a single Git forge that replaces GitHub and Azure DevOps, with Actions covering CI/CD. It rides on the PostgreSQL from 2-02 and sits behind the gate from 2-03. The local tools are Zed and Claude. Code is an asset; control of where it lives stays with you.
Word, Excel, and PowerPoint are the input/output tools people write and read with — not where the substance lives. Inside Office, AI stays a tool and you stay "the processor." So treat docx, xlsx, and pptx as formats to pass through, not to use, and take back control of the substance. Rather than add a separate storage app like Nextcloud, keep documents as plain files on your own storage, with auth from the 2-03 PocketBase and permissions (access control) in a queryable structured store (PostgreSQL or the gate's PocketBase; xattr when you want zero extra dependency), and embed OnlyOffice Docs as the editor engine only — a thin, custom document app. High-fidelity OOXML means you can still hand anyone a plain .docx. Avoid the finished DocSpace — it brings Active Directory back. The reference implementation is the public repo kura. Keep the formats; take back only control.
Mail is the record of the business itself. Stalwart is a Rust single server carrying SMTP, IMAP, JMAP, spam defense, and DKIM signing in one, replacing Exchange. It rides on the PostgreSQL from 2-02 and is read with any client like Thunderbird. But outbound deliverability is hard — so lean on an authenticated relay for sending and keep only control of the mailbox on your own side. An honest design.
Video meetings with Jitsi, booking with Cal.com, classes and webinars with BigBlueButton. Replace Teams, Zoom, Calendly, and Microsoft Bookings with your own domain on your own server. Booking rides on the PostgreSQL from 2-02 and sends confirmations through the 2-06 mail. Step off per-seat, per-minute billing and keep meeting links and records on your own side.
Publish, from your own side, the static site you built with AI in the Introduction part. Drop dynamic WordPress and put the baked HTML on Cloudflare Pages — hold no server. Leave the CDN and automatic HTTPS to Cloudflare; keep the source and build in your own hands. The crux is to separate build, verify, and deploy, keeping what you verified identical to what goes live. Internal tools stay behind the gate — borrow the window, hold the vault.
'Don't break it, don't touch it' is old advice. AI has cut the cost of rewriting a core system by 10x. Build the new AI-native system in FastAPI, run it in parallel with the old, compare outputs against reality, and when the diffs vanish, kill the old. Push business knowledge out into Markdown all at once, let the floor write the tests, and stop outsourcing. The new logic reads and writes the 2-02 PostgreSQL and verifies identity with the 2-03 gate's token. The reference implementation is kura.
Before you put AI on top, build information worth putting it on. Scattered files, paper and scanned PDFs, tacit knowledge that lives only in someone's head — move them into a written, structured state with OCR, classification, and codification. Preparation is the main body; AI is the last move. What to keep and how to structure it is a judgment only people can make, and it pays off as the end of personnel lock-in even if you never put AI on it — a no-regret investment. Put the prepared information into 2-05's files and 2-02's pgvector, and the next chapter mounts RAG on it.
The Independence part closes by laying AI on top of everything. The pgvector enabled in 2-02 finally pays off. Start by holding Cohere's open-weight coding model North Mini Code locally on Ollama (data never leaves), and load a general model and embeddings alongside for RAG. Embed your documents, code, and mail into pgvector for RAG, and use it through Open WebUI. Keep secrets and always-on processing in-house; borrow a frontier model like Claude for hard judgment — control yours, capability borrowed. Cut the Copilot dependency and close the Independence part.
Companies have not written their own code — and that was rational. In-house development was inefficient, demanding a large specialized workforce no single company could justify keeping. So companies BOUGHT packaged software for generic office work (Microsoft) and OUTSOURCED custom core systems (SIer) — two parallel, separately locked-in worlds, joined only by thin seams (auth and document sharing). That parallel split was the efficient equilibrium for decades. AI inverts the efficiency: one person plus AI now stands up both worlds on the same OSS foundation. The premise dissolves, and both vendor structures collapse together. This chapter sets the premise for the Shift part.
Until recently, Microsoft 365 was the economical and safe default — which is exactly why everyone bought it. That premise has inverted. OSS plus sovereign (self-hosted, local-weight) AI is now better on both cost AND security. The Microsoft problem — per-seat rent that only rises, data on a US company's cloud reachable under the CLOUD Act, opaque telemetry, Copilot routing content through Microsoft's models. The convenience IS the dependence. The Trump problem — depending on US Big Tech means depending on the US government's goodwill, and the Trump administration cannot be trusted not to weaponize that dependence (sanctions, cut-offs). So leaving Microsoft is no longer ideology — it is the new economic-and-security rational default. This chapter sets the premise for the Shift part's office (Microsoft) side.
Even when you outsource, the upstream judgment — improving the business operations themselves, and understanding the systems — stays with the customer. That work is not a straight line but a loop, and with AI you can run it fast in-house. And the deepest problem with commissioning is the erosion of responsibility and capability: the moment you hand it off, no one owns the result whole. For the same effort, you can build it yourself.
SIer commissioning anchors customers with three layers of lock-in (proprietary frameworks, proprietary abstractions / Ontology, human dependency). Palantir's FDE model is the extreme form — maximizing all three to sustain premium pricing in the tens of billions of yen. AI-native development, by contrast, structurally avoids lock-in: AI tends to write in standard libraries and standard formats, so another AI, another builder, or the customer themselves can take over.
In the AI-native era, the professional work — including lawyer- and doctor-level judgment — is done by AI. So the human senior builder is not a profession that sells judgment but management that makes business decisions: the CIO (Chief Information Officer). IT judgment = business judgment = management judgment, and because IT becomes the core of the business rather than a surface layer, the responsibility is heavier than today's CIO. A general-employee grade cannot accommodate this. The corporate-website case shows both the cost and the structural change.
Japan's multi-tier subcontracting structure in the SIer industry is usually treated as a barrier to transition. Dissect the structure and the conclusion reverses — because coder demand is externalized through contracts, the structure can shrink without internal lay-offs. Prime contractors can downsize by not renewing subcontractor agreements; talented subcontractor coders flow to primes, customer companies, or independence. Labor mobility is trending upward, with long-term commissions, secondment, and internal ventures absorbing the shift as transitional forms.
From AI reaching top-tier capability through coder displacement, builder demand, and SIer shrinkage, the changes chain together and the main part happens in the near future. And because the premises of economics and security have already inverted, the structure that has moved does not move back. But this "complete replacement" applies only to verifiable-correctness domains like software; in desk work, self-driving, and robotics, AI is blocked at the last 1% and complete replacement does not happen — those are productivity-gain stories. The writing of this very sub-series is itself evidence of that bound.
Align your tools with the AI era, and you become its free person.
The time freed flows into culture, science, and reality.
Explore