The Boring Transformation

This is part five of The Shape of the Next Decade, a series about what AI actually changes and what it doesn't. Previous: The Half-and-Half, The Three Tiers, The Machine That Learned the Meeting, The Meaning Crisis.

The Fax

A patient in Memphis needs a spinal injection. The orthopedist's office prints the clinical notes, attaches imaging results, fills out the insurer's prior authorization form (a different form for each insurer) and faxes the packet to a processing center in Phoenix. In Phoenix, someone receives the fax. Someone scans it into a document management system. Someone else opens the scanned document and manually enters the CPT codes (Current Procedural Terminology, the numeric system that identifies medical services for billing), diagnosis codes, and patient identifiers into the insurer's internal platform. A nurse reviewer pulls up the clinical policy bulletin for the requested procedure and checks whether the submitted documentation meets the coverage criteria. The criteria, in this case, amount to four yes-or-no questions. The nurse stamps the authorization. Someone prints the approval letter. Someone faxes it back to Memphis.

Elapsed time: somewhere between three and twelve days. The orthopedist's office calls twice to check status. Each call involves hold music, a representative looking up the case number, and a verbal summary of what the fax already said.

Across U.S. healthcare, physicians and their staff spend an average of 13 hours per week completing prior authorizations, handling roughly 39 per week per practice. Two-thirds of Canadian physicians report that administrative burden has increased over the past five years, with 60% calling it a direct contributor to the deterioration of their mental health.

The reasoning content of the Memphis authorization, the actual clinical judgment, took about ninety seconds. Four binary questions against a published rule set. Everything else was state transfer: information moving between systems through human hands because the systems don't talk to each other.

The bottleneck here is not intelligence. It is plumbing.

The Proportion

The AI discourse has spent the past three years on what you might call the dramatic layer — code generation, legal analysis, medical diagnosis, art that looks like other art. The debates are vivid, the demos are impressive, and the stakes feel existential. But these activities represent roughly 20 to 25 percent of economic activity in advanced economies.

But the more consequential number sits elsewhere in the economy. Somewhere between 60 and 70 percent of activity in advanced economies consists of structured information flowing between systems through human intermediaries: government agencies processing permits through chains of email attachments, financial institutions running compliance checks by copying data from one screen to another, construction firms tracking change orders across spreadsheets that feed into invoicing systems that feed into lien waivers that feed into payment releases. An insurance adjuster re-keys the same claim data into three platforms maintained by three vendors acquired in three mergers. A supply chain coordinator calls a warehouse to confirm what the warehouse management system already knows but can't tell the transportation management system because the API was never built. The work is not glamorous enough for conference keynotes, but it is where most of the hours go.

A McKinsey analysis of the U.S. labor market found that data collection and processing activities represent a larger share of work hours than any category involving complex reasoning or creativity. The Bureau of Labor Statistics counted 18.5 million office and administrative support jobs in May 2023, the single largest occupational group at 12.2 percent of total employment, and that figure excludes the state-transfer work embedded in every other occupation. The labor economists can see these workers fine. The AI discourse cannot.

The first four pieces in this series spent their analytical energy on the reasoning and judgment layers: the half-and-half split, the meaning crisis, the knowledge transfer problem. Those pieces described real dynamics. They also described the fraction of work that happens to be legible to writers and researchers, because writers and researchers do reasoning-heavy work and study people who do reasoning-heavy work. The prior authorization clerk in Phoenix did not appear in any of them.

What AI Actually Does Here

Before frontier models, automating a workflow like the Memphis prior authorization required a consulting engagement. Business analysts would spend weeks documenting the current process. Solution architects would design integration schemas. Developers would build custom connectors between the electronic health record system, the fax server, the insurer's portal, and the document management system. The project would take six to eighteen months and cost somewhere between $200,000 and $2 million, depending on how many legacy systems were involved and how honest the vendor was about timeline. At those prices, the math rarely worked. Humans were cheaper than pipes.

AI changed the build cost. A competent consultant with access to Claude or a comparable model can map a workflow from interviews and documentation in days, generate integration code that handles the format translations between systems, and deploy a working pipeline in weeks. The development time compression is significant enough that workflows previously too small or too niche to justify automation now clear the economic threshold.

But here is the part that tends to get lost in the conversation: once built, the pipes run without AI. The prior authorization workflow, once deployed, is a series of database triggers, API calls, and conditional logic running on tools like Zapier, Make, or n8n — simple decision trees executing the same four yes-or-no questions the nurse reviewer was checking manually. There is no language model in the loop during normal operation, no hallucination risk, no need for reinforcement learning from human feedback or frontier-model capabilities. The pipe just moves structured data from point A to point B according to rules that were already written down somewhere.

AI re-enters at two specific boundaries. The first is the language boundary, where messy human-generated text needs to be classified, extracted, or interpreted before it can enter the structured pipeline. A physician's free-text clinical note needs to be parsed into discrete fields. A customer email needs to be routed to the right workflow. These are bounded, well-scoped language tasks where even modest models perform reliably.

The second is the exception layer, where the structured pipeline encounters a case it wasn't designed to handle and escalates to something more capable. A prior authorization request that doesn't fit any existing policy bulletin. A construction change order with ambiguous scope language. These are genuinely hard, and they justify careful, bounded deployment of agentic systems with human oversight.

The pattern that emerges is a three-layer architecture: plumbing at the base, deterministic and rule-based, handling the bulk of the volume; a language layer at the interfaces where human text meets structured data; and an exception layer for the cases that neither rules nor models can resolve. The ordering matters more than any individual layer — pipes first, then language, then agents, with autonomy granted last and least.

The Convergence

Two research paths arrived at this architecture independently, from opposite directions.

One came from aerospace. Spacecraft fault detection, isolation, and recovery, a discipline usually abbreviated as FDIR, has spent decades working out how autonomous systems should be layered when failure means losing a billion-dollar vehicle. Generations of deep-space missions refined the same conclusion: deterministic code gets the highest authority, autonomous decision-making gets the lowest, and everything in between is layered by how much you trust it not to kill the vehicle. The research corpus behind this series drew heavily on that tradition and mapped it onto business operations.

The other came from site reliability engineering. Engineers who had spent years keeping production systems alive already knew what reliable architecture looked like: logging, alerting, failover, redundancy, deterministic pipelines that do the same thing every time and complain loudly when they can't. When those engineers started building AI-powered business tools, they kept running into the same pattern. The impressive demo was always the agent that could reason through a complex workflow end-to-end, but the system that actually shipped and stayed running was the one with deterministic pipes handling 80 percent of the volume and a language model classifying the remaining 20 percent at the entry points. The architecture that worked was the one that minimized the surface area where things could go wrong.

These were not communities that talked to each other. Agile software engineers who had any awareness of how traditional aerospace programs were developed tended to turn up their noses at the idea of layering process and formal verification on top of their code. You cannot move fast and break things if you first have to build a fault tree of all the ways the system could fail. But spacecraft engineers designing fault-tolerant software for Mars landers and startup engineers designing invoice-processing pipelines for mid-market accounting firms arrived at the same layered authority model anyway: deterministic logic at the top, statistical models in the middle, autonomous reasoning at the bottom, caged.

The practical consequence of this convergence is more optimistic than the usual AI deployment narrative suggests. A pipe doesn't hallucinate, doesn't need alignment research, doesn't require a frontier model or an enormous compute budget, and doesn't raise questions about consciousness or agency or existential risk. A company that identifies its state-transfer bottlenecks can start building pipes on Monday morning with tools that already exist, without waiting for the next model release or the resolution of any open research question.

The boring transformation can start this week. While the reasoning layer waits for better models, better alignment techniques, and better evaluation frameworks, the plumbing layer waits for nothing except someone willing to look at a process and build the connector. The tools exist, the patterns are known, and the only prerequisite is attention that has been directed elsewhere.

The Five Positions, Revisited

The prior four pieces in this series introduced five positions that people occupy as AI reshapes their work: the executor, the orchestrator, the translator, the craftsperson, and the anchor. The boring transformation touches each of them, but not always through the mechanisms the earlier pieces described.

Consider the executor, whose value came from reliable, repeatable task completion. The Half-and-Half described how AI compressed artifact work, the tangible outputs that used to take most of the day. The pipes compress something even more fundamental: the invisible substrate of state-transfer work embedded in the role itself. The executor who spent three hours a day moving data between systems didn't think of that as "data entry." It was part of the job; in some cases it was most of the job. When the pipes replace that substrate, what remains is the actual decision-making content of the role, stripped bare. Sometimes that content turns out to be substantial. Sometimes it turns out to have been fifteen minutes of judgment wrapped in seven hours of conveyance.

The orchestrator, by contrast, sees their value go up. Someone has to decide which processes to automate, where to place the language-model boundaries, and which exceptions still require human review. Someone has to identify the decision points that should never be delegated to an automated system, no matter how efficient the pipeline becomes. Drawing those lines on the three-layer architecture (what's plumbing, what's language, what's exception) is design work, and it requires the kind of organizational knowledge that doesn't transfer cleanly through documentation or training.

For the remaining three positions, translator, craftsperson, and anchor, the effect is subtler but no less real. Every role in an organization carries a certain amount of embedded state transfer that nobody notices because it has always been there: the sales engineer updating the CRM after every call, the project manager reconciling three scheduling tools every Monday morning, the compliance officer copying regulatory updates into a tracking spreadsheet. When the pipes absorb that work, what remains is the distinctive human contribution of each role, and that contribution becomes more visible.

Visibility cuts both ways. When state-transfer work is stripped away, the genuine expertise of the craftsperson stands out more clearly against the organizational background. The anchor's deep knowledge becomes more obviously valuable when it's no longer buried under administrative noise. But visibility also means that roles with thin actual contribution, roles that existed primarily because information needed a human to carry it between systems, become legible as thin. Making work legible makes the absence of work legible too.

The Measurement Correction

A reasonable question: if 60 to 70 percent of business value sits in the plumbing layer, why has nobody built a discourse around it?

Part of the answer is instrument bias. The empirical research on AI's impact on work overwhelmingly studies knowledge workers using chat interfaces. Economists measure productivity gains by tracking how fast consultants write reports or how many customer support tickets an agent resolves with copilot assistance. These are the tasks that produce clean, measurable logs: prompt in, response out, time saved. The research designs are elegant and the findings are real.

They are also calibrated to roughly 24 percent of work, because that's what the instruments can see. The state-transfer layer, the 47 percent of activity that consists of structured information flowing through human hands, produces plenty of measurable data: keystrokes per claim, error rates, processing times, throughput per clerk. But nobody is running randomized controlled trials on it. The work just hasn't attracted the researchers.

The result is a discourse shaped like its measurement tools. Conferences talk about reasoning because you can put a before-and-after demo on a slide. Venture capital flows to agents because an agent that books your flight is easier to pitch than a connector that syncs two databases. Newspaper headlines feature artists and lawyers and radiologists because a journalist can look at an AI-generated brief and judge whether it's good. Nobody writes a feature about the clerk whose job was to copy data from screen A to screen B, because there's no artifact to hold up and examine. Meanwhile, the largest pool of economic waste sits outside the frame entirely. The healthcare system alone loses an estimated $265.6 billion annually to administrative complexity, a figure that dwarfs the projected near-term economic impact of generative AI on clinical decision-making. Construction permitting adds an average of 7.4 months to residential project timelines according to NAHB data, with the majority of that time attributable to documents moving between departments rather than anyone evaluating the merits of the project.

The mechanism behind this blind spot is the ordinary operation of attention markets. Stories about AI writing poetry are interesting; stories about API connectors reducing data re-entry in municipal permitting offices are not. The allocation of discourse tracks the allocation of narrative interest, which tracks the allocation of professional proximity. Writers know writers, researchers know researchers, and neither group spends much time in the Phoenix processing center.

The Pipe and the Model

The first four pieces in this series described a world changing fast, with AI splitting jobs into artifact work and consequence work, access stratifying by legal protection, knowledge transfer losing fidelity through machine intermediaries, and identities fracturing along five fault lines.

For most people and most organizations, the bottleneck was never intelligence. It was sediment. Somebody in 2009 decided not to build the integration, and then a 2013 acquisition brought in a company running a different database, and then a compliance change in 2017 added three manual steps that nobody ever automated. Layer by layer, the undone plumbing accumulated until it had become the job itself.

The transformation that will reach the most people the fastest won’t involve frontier models or agentic reasoning or artificial general intelligence. It will involve someone looking at a process, identifying the state-transfer steps, and building a pipe.

The next piece in this series examines what happens when AI compresses the information layer everywhere at once, and something underneath holds.

Nicholas Zinner and Beacon Bot write the Future Shock series at news.future-shock.ai.