Out of the Loop
**Abstract**
The cost of producing software is falling sharply for tasks within the current reach of large language models, on a timeline measured in years rather than decades, though the gains are heterogeneous and the endpoint is not yet settled empirically (Peng et al., 2023; Cui et al., 2024; Brynjolfsson, Li & Raymond, 2025). When a fundamental production cost collapses, the economic structure built on top of that cost reorganizes around whatever cost is now scarce (David, 1990; Bresnahan & Trajtenberg, 1995). This paper draws on six historical transformations — factory electrification (1880-1930), the oil economy (1900-2000), the postwar American publishing industry (1945-1980), containerization (1956-1990s), the Bessemer steel revolution (1855-1890s), and the Gutenberg printing press (1450-1530) — and identifies the structural feature each contributes to a unified prediction for the software economy over a roughly 15-year window from 2022 through the mid-to-late 2030s. The prediction has three parts. First, software production becomes a commodity utility delivered through autonomous harnesses, and the software industry as a distinct sector dissolves, with its capability absorbed into the industries it previously served — most importantly by domain experts in those industries who acquire specification literacy and become the new producer class. Second, the economic rent generated by the transformed economy concentrates at two oligopolistic layers at opposite ends of the stack: the inference-compute layer (captured by three to six vertically integrated refined-token majors whose position parallels the mid-century integrated oil majors) and the general-agent routing layer (captured by three to five entities whose routing decisions form the distribution channel for every software capability in the stack below). Third, the professional middle between these two rent layers consolidates around a small set of exception-handling roles — spec contradiction handlers, outcome-mismatch attestors, and novel-situation domain strategists — whose compensation structure follows the licensed-profession model of the mid-20th-century CPA and architect professions. The paper analyzes the consequences for three stakeholder groups — software consumers, software producers, and software practitioners — each facing a different structural position in the transition. The unifying narrative across all three parts of the prediction and all three stakeholder groups is the migration from **human-in-the-loop (HITL)** software production — where every artifact passes through human judgment before it ships — to **human-out-of-the-loop (HOTL)** software production, where humans author specifications, audit outcomes, and handle exceptions, but exit the main production path entirely. Every structural consequence developed in this paper — the rent concentrations, the industry dissolution, the exception-handler professions, the education layer, the domain-expert-as-author — follows from humans leaving the loop.
Between 2022 and 2026, the cost of producing a unit of software — measured in developer-hours per delivered feature — fell substantially for tasks within the reach of large language models. The early empirical evidence establishes a direction of large but heterogeneous gains, not a settled cost-collapse theorem. Peng et al. (2023), in a randomized controlled trial at GitHub, found that developers using GitHub Copilot completed a standardized task 55.8% faster than a control group. Cui et al. (2024), reporting three field experiments at Microsoft, Accenture, and a Fortune 100 electronics manufacturer (all using GitHub Copilot), found a 26.08% average increase in completed tasks per week among developers with Copilot access, with the largest gains concentrated in junior developers. Brynjolfsson, Li and Raymond (2025, _Quarterly Journal of Economics_), studying generative AI in customer service, found productivity gains of roughly 15% on average and 34% for novice workers. The early software-specific evidence is less uniform than the customer-service evidence: a later randomized controlled trial on experienced open-source developers reported that AI-assisted conditions slowed those developers by roughly 19% on their own repositories (METR, 2025), demonstrating that the gains from current tooling vary sharply with task type, worker experience, and codebase familiarity. These studies span only the earliest, most rudimentary application of the technology to software work; the trajectory is what matters for the argument that follows, not any single datum.
The gains are not uniform across all software work. Frontier research, novel system design, high-stakes regulated systems, and deeply idiosyncratic legacy codebases remain human-dependent for reasons I will return to. But for the bulk of the software economy — line-of-business applications, internal tooling, integrations, data transformations, ad-hoc scripts, reporting, and the long tail of capabilities that constitute most of what organizations actually consume — the production-cost trajectory points sharply downward on a timescale of years, even if the rate and end-state of the decline remain genuinely uncertain.
When a fundamental production cost collapses, the economic structure built on top of that cost does not become cheaper in place. It reorganizes. This is the governing observation of the general-purpose-technology (GPT) literature in economics (Bresnahan & Trajtenberg, 1995; Lipsey, Carlaw & Bekar, 2005). The thing that was scarce stops being scarce, and the market reorients around whatever is scarce now. Brynjolfsson, Rock and Syverson (2021) formalize this as the “Productivity J-Curve”: transformative general-purpose technologies produce an initial _decline_ in measured productivity as firms invest in complementary intangibles, followed by a steep rise once the reorganization completes. The curve is the economic signature of a production-cost collapse working its way through an economy’s institutional structure.
The scarcity that replaces software production cost is not a single thing. It is three things stacked on top of each other: the **attestation** required to know that produced software is correct — meaning the institutional act of staking professional reputation and liability on a signed claim about software, which no machine can produce because it requires an accountable human or institution with skin in the game; the **domain knowledge** required to know that the right software is being produced; and the **inference infrastructure** required to produce software at scale. Each scarcity sits in a different layer of the economy, is captured by a different kind of actor, and produces a different kind of rent. Understanding the full picture of the next 15 years of the software economy requires understanding all three.
The central through-line of this paper is the shift from human-in-the-loop (HITL) to human-out-of-the-loop (HOTL) software production. In 2022, essentially all software production is HITL: every line of code, every design decision, every deployment passes through human judgment at multiple gates, and the human gate is what the customer is paying for as much as the code itself. By the mid-to-late 2030s, on the leading edge of the transition, software production is HOTL: humans author specifications, sign attestations on outcomes, and handle exceptions the automated loop cannot resolve, but they do not review individual artifacts, write code, or gate deployments.
The right frame for that understanding is historical. Every prior production-cost collapse of comparable magnitude has left a documented record of how the affected economy reorganized. The software transition is not unprecedented. It is the latest instance of a pattern that has recurred in recent industrial history with enough regularity that its shape is predictable even when the specifics are not.
This paper draws on six historical transformations, each selected because it isolates a distinct structural feature of the current software transition: factory electrification (1880-1930), the oil economy (1900-2000), the postwar American trade publishing industry (1945-1980), containerization (1956-1990s), the Bessemer steel revolution (1855-1890s), and the Gutenberg printing press (1450-1530). Each is included because it displays one feature of the current transition more clearly than any alternative. The Bessemer case is the sharpest available example of an input-cost collapse producing its largest effects _outside_ the industry that used the input expensively — the structural shape of the software-capability migration predicted in the Software Consumers section and the industry-dissolution prediction in the 15-Year Thought Experiment. The printing press is the cleanest instance of a compression technology _creating a new producer class_ (the author) rather than merely compressing an existing one (the scribe) — load-bearing for the domain-expert-as-author prediction developed in the Software Consumers and Software Producers sections.
##### **Electrification of Factories (1880-1930)**
The electric motor was available from the 1880s, but factory productivity barely moved for roughly thirty years — electric motors accounted for under 5% of American factory mechanical drive at the turn of the century and did not reach 50% until the 1920s. The lag was organizational, not technological. Early factories replaced their central steam engine with a single large electric motor driving the same belts and shafts, saving fuel but preserving the layout. The productivity breakthrough came only when factories were physically rebuilt around individual motors at each workstation, which enabled flow-based layouts, single-story factories, and eventually the assembly line (David, 1990; Devine, 1983). Bresnahan and Trajtenberg (1995) generalized this into the modern framework of general-purpose technologies; Brynjolfsson, Rock and Syverson (2021) showed the same pattern — a productivity J-curve driven by slow accumulation of complementary intangibles — governs the current AI transition.
**The feature this isolates:** the productivity payoff from a transformative technology is gated on organizational redesign, not on adoption. The redesign takes a generation, and whoever figures out the new shape first captures disproportionate value because the rest of the economy is still running the old shape.
##### **The Oil Economy (1900-2000)**
Every major 20th-century sector — transportation, manufacturing, electricity generation, chemicals, plastics, fertilizers, agriculture — eventually cashed out as oil consumed somewhere in its supply chain (Yergin, 1991). Sectors consuming oil captured value proportional to their own productivity; the handful of vertically integrated producers who owned the wells, pipelines, and refineries captured a disproportionate share of the total rent. The barriers to entry — exploration, drilling, pipelines, refining, distribution — were so high that the number of meaningful producers stayed small throughout the century (Chandler, 1977, 1990). Concentrated rent produced concentrated political power: the Standard Oil antitrust breakup (1911), OPEC’s emergence, the oil crises of the 1970s, and the wars fought over production and distribution. The same pattern appears in steel, aluminum, chemicals, and — as argued in the Token Economy section below — inference compute.
**The feature this isolates:** when an economy consumes a single upstream commodity that is capital-intensive to produce, the rent concentrates at the upstream, the downstream captures modest per-unit value, and the political consequences of the concentration become defining features of the era.
##### **The American Trade Publishing Industry (1945-1980)**
Producing and distributing a book in the postwar American trade market required capabilities no individual could replicate: capital for advances and production runs, typesetting and printing coordination, warehousing and shipping, relationships with thousands of bookstores, credit with suppliers, editorial infrastructure, and the reputational standing to be reviewed in legitimate publications and selected by book clubs (Coser, Kadushin & Powell, 1982; Radway, 1997). An author could not self-publish into the trade market — not because the book was impossible to produce, but because this bundle was unreachable without the publisher’s institutional position. Publishers specialized by vertical — Knopf for literary fiction, Prentice Hall for textbooks, Doubleday for mass market, Farrar Straus & Giroux for European literature — because editorial judgment required domain-specific knowledge that had to be assembled inside an institution with capital to support it over long horizons. The moat was not production capacity; it was the institutionalization of scarce editorial judgment and trust around a specific domain.
**The feature this isolates:** when the valuable functions in an industry are trust, curation, and domain judgment rather than physical production, those functions bundle into vertically specialized institutions whose moat is reputational and whose product is attestation rather than goods. The modern structural parallel is audit firms, law firms, certificate authorities, and regulatory bodies — institutions that sell trust as a service.
##### **Containerization (1956-1990s)**
The shipping container did not make ships faster. It standardized the interface between transport modes — ship, rail, truck — so a sealed box could move through the entire global supply chain without being unpacked and repacked at each transition (Levinson, 2006). The transformative move was not a better component but a standard interface, driven originally by trucking entrepreneur Malcolm McLean and ratified by the ISO container standard in the 1960s. Whoever reorganized around the standard — Felixstowe, Singapore, later Shenzhen — became a new center of global logistics; whoever stayed organized around the old interface collapsed. US dockworker employment fell by roughly 75% over the two decades following widespread adoption, with the Port of New York specifically collapsing from approximately 35,000 longshoremen in the mid-1950s to roughly 3,500 by the 1990s (Talley, 2009; Levinson, 2006; Finlay, 1988) — one of the largest occupational compressions in postwar American labor history. Liverpool, San Francisco’s working waterfront, and the Brooklyn docks all collapsed as trading centers.
**The feature this isolates:** interface standardization captures more durable value than component optimization. Whoever standardizes the interface between layers of a production system captures rent from every transaction crossing the interface, and the labor organized around the old interface dissolves faster than the people involved expect.
##### **Bessemer Steel and Downstream Displacement (1855-1890s)**
Henry Bessemer’s converter, patented in 1856, reduced the cost of producing steel by approximately 80% within two decades; steel rails fell from roughly $170 per ton in 1867 to under $30 by 1895 (Temin, 1964). The direct effects on the steel industry were real — integrated mills displaced smaller forges, Carnegie assembled his empire, Pittsburgh industrialized — but they were modest compared to the indirect effects in industries that had previously been unable to afford steel at all. Skyscrapers became economically feasible; long-span bridges like the Eads (1874) and Brooklyn (1883) required steel in volumes that would have been prohibitive at pre-Bessemer prices; continental-scale railroads required cheap rails; modern ships required steel hulls; the automobile industry eventually required cheap steel in volumes only Bessemer and its open-hearth successor could supply (Condit, 1964; Misa, 1995). Each downstream transformation reorganized an entire sector — urban form, continental logistics, global shipping, mass mobility — in ways that had little to do with the steel industry itself. The steel industry captured some rent; the industries that cheap steel enabled captured vastly more.
**The feature this isolates:** when the cost of a previously expensive input collapses, the biggest economic consequences appear _outside_ the industry that used the input expensively. The software-capability analog is direct: the largest effects of collapsing software-production cost will appear not in the software industry but in the industries that can now afford software they could not previously afford.
##### **The Printing Press and Author-Class Creation (1450-1530)**
Between 1450 and 1500, European presses produced approximately 15 to 20 million incunabula — roughly equal to the total manuscript output of the previous thousand years (Buringh & van Zanden, 2009). The press did not merely compress the scribal craft, though it did — the Benedictine scriptoria that had dominated manuscript production for centuries contracted within a generation. The more consequential change was the emergence of the **author** as a recognizable economic and cultural category. Before the press, the people with ideas were bottlenecked behind the people who could reproduce them, and the cost of reaching an audience was so high that only institutionally-backed voices could bear it; after, reproduction was cheap and the scarce input became the ideas themselves. Erasmus became the first international bestselling writer; Luther reached audiences no preacher had reached before; Copernicus, Vesalius, and Galileo — the natural philosophers who became the first modern scientists — could not have had their impact without the book trade as the substrate of their circulation (Eisenstein, 1979; Febvre & Martin, 1976).
**The feature this isolates:** a compression technology does not merely eliminate an existing craft; it can produce a new producer class whose expertise was previously under-utilized because the supporting infrastructure did not exist. As the production layer commoditizes, the domain experts in every non-software industry — physicians, accountants, structural engineers, derivatives traders, agronomists, radiologists, tax strategists, industrial chemists, urban planners, and their equivalents — acquire for the first time the ability to encode their expertise directly into software without a software-industry intermediary.
##### **Why These Precedents, and What They Jointly Imply**
Each precedent isolates a distinct structural feature of the current software transition, and each feature is load-bearing for the stakeholder predictions that follow.
The six features they jointly isolate are:
- **Organizational lag** (electrification): the productivity payoff from a production-cost collapse is gated on reorganization, not on adoption, and the reorganization takes years (David, 1990; Bresnahan & Trajtenberg, 1995; Brynjolfsson, Rock & Syverson, 2021).
- **Upstream rent concentration, refined-major pattern** (oil): when a capital-intensive commodity sits upstream of an economy and its downstream products are differentiated, rent concentrates in the vertically integrated majors that own refining plus distribution, not at pure commodity extraction (Chandler, 1977, 1990; Yergin, 1991). See the Token Economy section below for the specific application to inference compute and token tiers.
- **Trust institutionalization** (publishing): when the valuable functions are judgment and attestation rather than production, those functions bundle into vertically specialized institutions whose moat is reputational (Coser, Kadushin & Powell, 1982; Tebbel, 1972-1981; Schiffrin, 2000).
- **Interface standardization** (containerization): whoever standardizes the interface between layers captures rent from every transaction crossing the interface, and labor organized around the old interface dissolves faster than expected (Levinson, 2006; Bonacich & Wilson, 2008).
- **Downstream displacement of effects** (Bessemer steel): when the cost of a previously expensive input collapses, the largest economic consequences appear outside the industry that used the input expensively, as formerly-excluded downstream industries reorganize around the newly cheap input (Temin, 1964; Misa, 1995; Condit, 1964).
- **Author-class creation** (printing press): a compression technology does not merely eliminate an existing craft; it can produce a new producer class drawn from previously under-utilized domain experts whose expertise becomes directly deployable once supporting infrastructure exists (Eisenstein, 1979; Febvre & Martin, 1976; Buringh & van Zanden, 2009).
Each feature, taken in isolation, is a well-understood economic pattern. What is novel about the current software transition is that _all six are present simultaneously_, interacting in ways not fully captured by any single precedent. The prediction developed in the following sections is that the combination produces an economic shape different from any individual precedent but recognizable as a consistent synthesis of their features.
**Phase 1 — Dismissal (2022-2024).** Production-cost collapse begins. First empirical studies of LLM coding assistance appear (Peng et al., 2023; Kalliamvakou, 2022). The institutional shape of software production remains unchanged.
**Phase 2 — Imitation and Golden Age (2024-2026).** LLM-based tools are bolted onto existing developer workflows (Cui et al., 2024; Brynjolfsson, Li & Raymond, 2025). Productivity gains on routine, well-bounded tasks are large but heterogeneous, with junior developers and greenfield work benefiting most and experienced developers on deep legacy code sometimes performing worse (METR, 2025). The electrification-on-the-old-shaft moment: real gains, capped by the old organizational layout.
**Phase 3 — Economic Crossover (2026-2028).** Unit economics flip for routine software work. Compression hits the commodity end of the services industry first. The first closed build-verify loops appear in greenfield systems, initially with human review retained as a soft gate.
**Phase 4 — Chokepoint Dissolution and Trust Institutionalization (2028-2030).** The human review chokepoint in the production pipeline dissolves into exception handling. New institutional roles crystallize around attestation, specification, and audit. First professional licensure proposals for software attestors appear in regulated sectors. Trust brands emerge as vertically specialized institutions following the 1950s publishing pattern.
**Phase 5 — UI Contraction and Agent Routing (2030-2032).** Most software loses its human-facing user interface because the primary operator is now a general-purpose agent consuming protocol endpoints. Frontend engineering contracts sharply, concentrated in creative tools, embodied interfaces, and regulated audit surfaces. The general-agent layer becomes the dominant distribution channel for software capabilities.
**Phase 6 — Utility Emergence (2032-2035).** Software is consumed as a metered utility through protocol sockets. The subscription SaaS model becomes economically unnatural. “Software company” loses meaning as a distinct business category. The vertically integrated big tech players who own inference infrastructure consolidate their position at the upstream.
**Phase 7 — Industry Dissolution and Rent Settlement (2035-2038).** The software industry as a distinct sector ends. Software capability migrates into the industries that consume it, held by in-house domain experts with specification literacy who function as a new author class in the Gutenberg sense. The economic rent settles at two oligopolistic layers: the inference-compute layer, captured by three to six vertically integrated refined-token majors whose position parallels the mid-century integrated oil majors; and the general-agent routing layer, captured by three to five entities whose routing decisions form the distribution channel for every software capability in the stack below.
_This timeline is approximate. The leading edge is earlier than the median; the regulated sectors and the long tail of legacy systems lag significantly behind. A realistic picture of 2035 contains both the frontier and the trailing edge, with the center of gravity moving steadily toward the frontier._
**The timeline as a HITL → HOTL migration.** The phases are a migration from human-in-the-loop to human-out-of-the-loop software production. Phases 1-3 (2022-2028) are purely HITL: humans are inside every production path, and LLM tooling accelerates the humans without removing them. Phase 4 (2028-2030, Chokepoint Dissolution) is the migration itself: the spec-review chokepoint dissolves, human review migrates from a full-time gating role to an on-call exception rotation, and the closed-loop architecture described in the companion paper _Software as Electricity: The Closed-Loop Attestation Architecture_ displaces the transitional HITL pipeline. Phases 5-7 (2030-2038) are progressively more HOTL: by Utility Emergence the main production loop runs without humans at all in the common case, and by Industry Dissolution the surviving human work is institutionalized in a small number of HOTL roles (spec authors, licensed attestors, constitutional auditors) whose compensation is shaped by the fact that they are the only remaining humans in a global production stack that otherwise runs autonomously.
The _loop_ this paper refers to throughout — and from which “out of the loop” takes its name — is the closed, continuously-running production cycle that becomes the dominant architecture of software production once Chokepoint Dissolution completes. The full architectural specification is the subject of the companion white paper_Wanabai: Software as Electricity_; the steady-state economics are developed in the companion article _Software as Electricity: The Closed-Loop Attestation Architecture_. The labor-market and rent-layer predictions in the sections below do not depend on the architectural detail, but they depend on three structural facts about how the loop operates. A fourth structural property — that the loop is self-hosting and self-improving, with all that implies for governance — is developed separately under The Recursive Harness Tower below. One terminological note: where _harness_ appears in this paper, it means a concrete running implementation of the loop — the loop is the architectural pattern; the harness is what runs.
**The inside is fully autonomous.** A request enters; a specifier agent emits a formal specification delta against an accumulated specification corpus; a coder agent emits code; a deterministic verification toolchain (type checkers, property-based tests, contracts, model checkers, formal proofs where applicable) gates the artifact; the verified artifact deploys into an ephemeral sandbox whose runtime mechanically enforces its declared read, write, network, resource, and effect scope; an adversarial agent ensemble exercises it against declared intent; and if every check passes the artifact is promoted to production atomically. No human gate sits between intake and production. There are no releases, no deployment windows, and no on-call rotation for individual artifacts.
**The durable artifact is the specification corpus, not the source code.** Source code is a regenerated compilation product. When requirements change, the corpus changes and the code is re-emitted; the corpus is what is version-controlled, diffed, and reasoned about. A correct implementation of the corpus can in principle be produced by any sufficiently capable coder agent — which is what makes the production layer a commodity once the loop closes.
**Humans appear only outside the loop, as standing roles and on-call exception handlers.** The standing roles are **spec authors**, who encode domain knowledge into the corpus, and **constitutional auditors**, who govern the meta-verification suite that drives the loop’s self-improvement (the self-improvement mechanism itself, and the Goodhart-drift failure mode it must be audited against, are developed under The Recursive Harness Tower below). On-call handlers respond when the loop escalates one of three classes it cannot resolve internally: **spec contradictions** the canonical-resolution rules cannot reconcile, **outcome mismatches** where observed behavior satisfies the spec but diverges from declared intent, and **novel situations** with no precedent in the corpus — handled respectively by the deep domain expert with formal-methods literacy, the licensed attestor, and the domain strategist (the full taxonomy is developed under Software Practitioners below). Every prediction in the sections that follow — the rent concentrations, the industry dissolution, the exception-handler professions, the education layer — follows from one fact about this architecture: the humans who remain are the ones outside the loop and the ones handling its exceptions, and they are vastly fewer than the humans currently inside the production paths the loop replaces.
The transition creates three distinct structural positions, each belonging to a different stakeholder group: the non-software firms that consume software, the services firms and vendors that produce it, and the individual practitioners who build it. Each faces different choices, different surviving roles, and a different action window. Each is treated in turn below.
##### **Software Consumers: Non-Software Firms**
Software consumers are the non-software companies that produce goods and services — manufacturers, logistics firms, hospitals, accounting firms, retailers, energy utilities, financial institutions outside the frontier of fintech. They are the vast majority of the economy by revenue and employment, and they are in the best structural position of any stakeholder group in the transition, though most do not yet recognize it.
Their structural advantage is that their moat is domain knowledge, and domain knowledge is precisely what the post-transition software economy needs most. The economic literature on enterprise software and the build-versus-buy decision establishes the starting point: firms adopting packaged enterprise systems (ERP, CRM, SCM) routinely discover that the software does not fit their actual operations, and they face a choice between customizing the software at high cost, customizing their operations to match the software, or accepting a permanent mismatch (Davenport, 1998; Markus & Tanis, 2000). Brynjolfsson and Hitt (2000) show that the productivity gains from IT investment depend heavily on complementary organizational change — a direct echo of the electrification lesson from the Historical Precedents. Firms that achieved the highest gains from enterprise software were those that redesigned their processes around the software’s capabilities. Firms that did not achieved only marginal gains and sometimes saw productivity decline.
In 2026, this situation is tolerated because the alternative — building bespoke software fitted exactly to the firm’s actual operations — is prohibitively expensive for most firms. The firm pays for SaaS that almost fits, distorts its operations to match, and accepts the resulting productivity loss as a cost of doing business. The aggregate cost of this misfit across the entire non-tech economy is enormous and largely invisible in firm-level accounting.
**Prediction.** In the transition, this situation inverts. As production costs fall sharply (per the trajectory in the Introduction), a mid-sized firm will be able to assemble a small team — five to fifteen people — of domain experts with specification literacy, and produce software fitted exactly to its own operations, continuously maintained by an automated harness, with trust boundaries handled by contracted attestation where liability matters. The firm’s institutional knowledge becomes directly executable. The SaaS vendors who captured the generic version of that knowledge lose their customers one by one as each customer recaptures its own operational logic in spec form.
The firms that make this transition gain significant efficiency advantages. The firms that do not become permanently dependent on SaaS vendors whose software encodes the customer’s operational logic in forms the customer cannot modify. This divergence is the single largest strategic fault line in the non-tech economy over the 2026-2032 window.
**Action for this stakeholder group in 2026:** Hire the first domain-expert-with-spec-literacy immediately, even though the role does not have an established title. Begin treating every SaaS renewal after 2028 as a buy-versus-build decision with building as the default option, not the exception. The transition is irreversible once critical operational knowledge is embedded in external software.
##### **Software Producers: Services Firms and SaaS Vendors**
Software producers are firms whose primary business is producing software for external customers — the global IT services industry, product studios, custom development shops, and SaaS companies.
**Quantitative scale.** According to NASSCOM’s Strategic Review 2024, the Indian technology industry (including hardware) reached approximately $254 billion in FY2024 revenue with a workforce of approximately 5.43 million employees; the 2025 Strategic Review and subsequent industry reporting revised FY2025 revenue upward to roughly $297 billion with a workforce of approximately 5.80 million employees (NASSCOM, 2024; NASSCOM, 2025). This is the largest single labor pool in the world directly exposed to the software-production-cost shift, though the services industries of the Philippines, Vietnam, Eastern Europe, and Latin America face similar exposure. The global SaaS segment, per Gartner’s 2024 projection, exceeds approximately $247 billion in annual end-user spending (Gartner, 2024) and employs millions more. In aggregate, the software-producer category employs tens of millions of people globally and generates hundreds of billions in annual revenue.
**The structural problem.** The business model of the services industry is labor arbitrage: charge customers for developer-hours at a markup over what developers are paid, and capture the spread as margin (Dossani & Kenney, 2007). As the marginal cost of a developer-hour compresses sharply on the routine tasks that make up the bulk of services-industry billable work, the spread narrows, and with it the industry’s economic basis. The SaaS companies face a related problem: their business model is renting software back to customers whose own business logic should have been the customers’ own asset, and that model becomes untenable when customers can produce their own software cheaply.
The recent tech layoffs documented industry-wide through 2022-2024 (Layoffs.fyi tracking, widely cited in financial press) are early warning signs, though the attribution is mixed between AI-driven productivity gains and post-pandemic normalization. Former HCL CEO Vineet Nayar publicly stated in 2024 that AI-driven automation will reduce workforce requirements for routine IT tasks, particularly coding, testing, and maintenance (as quoted in _Business Standard_ and reproduced in the Wikipedia entry on Indian IT industry). This represents a shift in leadership rhetoric that did not exist two years earlier.
**Prediction:**four survival positions. The transition offers this group four strategic positions, and each firm must choose one within the next two to three years because retraining and repositioning takes years. The positions are ordered below roughly by the size of their addressable market, not by their compensation profile — the largest market (Position 4) is not the highest-margin.
Position 1: Become a trust brand. Leverage existing reputation and scale to become an attestor — the entity that signs its name to specs and outcomes in a specific vertical, stakes professional liability on its signatures, and charges for the trust it provides. This is the 1950s publishing pattern described in the Historical Precedents (Coser, Kadushin & Powell, 1982): institutionalize scarce trust functions around a domain. It requires building formal methods capability that most current services firms do not have, and tolerance for professional liability most firms have never managed. The firms that succeed here become the audit firms of the software economy, capturing modest per-engagement margins at high volumes with durable reputational moats.
_Position 2: Become a vertical specialist._ Go deep into one domain — healthcare, finance, manufacturing, energy, logistics, legal — and become the specification-writing shop of record for that domain. Requires hiring or training deep domain experts, a fundamentally different workforce than the generalist consultants the industry currently employs.
_Position 3: Become a harness operator._ Run the commodity infrastructure — automated production loops, verification toolchains, sandboxed deployment environments. This is a real business but structurally margin-compressed, because the harness itself is commoditized by open-source alternatives. It is the Postgres position: durable, profitable, not glamorous.
_Position 4: Become the education layer._ Teach domain experts in non-software industries to acquire specification literacy — the ability to encode operational knowledge directly into the spec corpus that autonomous harnesses consume. The target population is the global pool of domain experts in every sector the software industry has historically served — physicians, accountants, structural engineers, derivatives traders, agronomists, radiologists, tax strategists, industrial chemists, urban planners, and their equivalents. Conservative estimates of the population size place it in the tens of millions globally; the upper end places it closer to 100 million. This is structurally parallel to the author-class creation described in the printing-press precedent (Eisenstein, 1979): the infrastructure now exists for domain experts to function as direct software producers, but the training pipeline that converts domain expertise into specification literacy does not. A firm that figures out how to take an accountant and produce a spec-literate accounting-software producer in six months has access to a market the current software industry has never touched. By addressable population, this is the largest of the four positions by more than an order of magnitude; by current supply, it is the thinnest, because essentially no institution is currently offering this kind of training at scale. The strategic question is whether this market is privately capturable at venture scale or whether it is absorbed primarily by universities, professional associations, and government training programs as a quasi-public good. The answer is not yet settled, and the Open Questions section treats this as an open question.
**Firms that do not choose one of these four positions likely die between 2028 and 2032.** This is not a prediction that services firms in general are doomed; it is a prediction that the _current business model_ is doomed, and only the firms that pivot deliberately to one of the four viable positions will survive in a recognizable form.
**Action for this stakeholder group in 2026:** Pick one of the four positions within twelve months. Commit capital and workforce to the pivot. Begin retraining the workforce in the direction of the chosen position.
##### **Software Practitioners: Individual Developers**
The software practitioner faces the most personal version of the transition. The generic identity of “software developer” — a stable and well-compensated professional category for roughly fifty years — is the equivalent of the scribe in 1490: the role being automated most directly, and the worst position from which to enter the next era. The scribes who survived Gutenberg’s transition were not the fastest copyists; they were those who had already moved toward editing, design, and judgment (Eisenstein, 1979; Febvre & Martin, 1976).
**Prediction:**the surviving positions. The transition for the practitioner is the HITL → HOTL migration viewed at personal scale. The _dying_ positions — the ones discussed below under Positions That Die — are the HITL positions: full-stack developer at a SaaS startup, backend CRUD engineer, dashboard frontend engineer, generic manual QA, generic devops. Each of these is a job performed _inside_ the production loop, whose value proposition is that a human is in the loop. As the loop closes, each is automated or eliminated. The _surviving_ positions — the ones discussed below under Exception-Handler Roles and Infrastructure, Bridge, and Interface Roles — are HOTL positions: the work is not inside the main production path but around it, at the points where the automated loop meets human judgment, human domain knowledge, or human professional liability.
The surviving positions fall into two families. The first family comprises **exception-handler roles**, where human judgment is load-bearing because the automated loop cannot resolve the situation it has encountered. These roles carry the highest per-person compensation in the post-transition economy because they combine domain authority, professional liability, and scarcity. The second family comprises **infrastructure, bridge, and interface roles**, where the human contribution is not judgment in the exception-handling sense but specialized production, time-bounded transition support, or domain-specific craft. The infrastructure family is larger in headcount but lower in per-role leverage. Both families are HOTL by construction: the human is no longer inside the build-verify path on each artifact.
##### **Exception-Handler Roles**
All human work that the automated loop cannot resolve falls into one of three exception classes. Each class defines a distinct role, a distinct skill mix, and a distinct compensation structure. The taxonomy is the sharpest organizing frame for the surviving professional positions and is adopted directly from the operational architecture of closed-loop production systems.
**Spec contradiction handler: the deep domain expert with formal-methods literacy.** A new change request, translated into a spec delta, contradicts the accumulated invariants of the existing spec corpus in a way that canonical resolution rules cannot handle automatically. The role that handles this is someone who can read both the new intent and the accumulated corpus, understand the domain implications of each, and decide which should win. This is closest in spirit to a senior architect today, but the skill mix is different — less coding, more specification reading, more domain judgment, more ability to navigate large formal corpora. Required fluencies are deep domain expertise in a high-stakes vertical (healthcare, derivatives settlement, aviation, pharmaceuticals, industrial control, critical infrastructure), plus formal-methods tooling fluency (TLA+, Dafny, Lean, property-based testing; see Lamport, 2002; Jackson, 2006; Leino, 2010). Compensation tracks seniority and domain specialization.
**Outcome mismatch handler: the attestor.** The deployed system satisfies the formal spec but the observed outcome diverges from the declared intent — the software does what was specified but not what was wanted. The role that handles this is the **attestor**: a professionally-licensed individual who stakes reputation and liability on the judgment that observed behavior does or does not match intended outcome. This is the single highest-compensated position in the post-transition economy. It is structurally parallel to the licensed architect in building construction or the Certified Public Accountant in financial audit — a liability-bearing professional whose signature is load-bearing in court. Professional licensure for attestors is predicted to emerge in regulated sectors (healthcare, finance, aviation, pharmaceuticals, critical infrastructure) by 2030 and generalize across most of the economy by 2035, driven not by regulation per se but by liability: courts and insurance companies will demand a licensed name when software fails, and the defense that “the harness produced it” will not be accepted. The attestor profession in 2035 probably looks like the CPA profession in 1935 — a recently-created regulatory construct, professionalized in response to a structural transformation, staffed by a small number of people with very high trust, very high compensation, and very high personal stakes. Compensation at the top of this profession will likely parallel senior partners at audit or law firms.
**Novel situation handler: the domain strategist.** The system encounters a state space with no canonical rule and no precedent in the spec corpus — a genuinely new situation that requires human judgment to establish new canonical rules on behalf of the organization. The role that handles this is a domain strategist: someone with deep domain knowledge and the authority to establish precedent. Formal-methods literacy is less critical here than in the spec-contradiction role; domain seniority and organizational authority are more important. The role is rare in stable domains and common in fast-changing ones (emerging regulation, novel product categories, unprecedented market conditions). Compensation tracks the strategic consequence of the decisions rather than the volume of them.
##### **Infrastructure, Bridge, and Interface Roles**
Several roles exist outside the exception-handler family but remain viable because the post-transition economy still requires specialized production, transition support, and human-facing craft.
**Formal methods specialist.** The production-grade formal methods community is currently small — Newcombe et al. (2015) describe Amazon’s early experience bringing TLA+ into industrial practice and note the dearth of practitioners. Demand rises as verification becomes the dominant cost center. This skill is table stakes for the next decade and supports both the spec-contradiction exception-handler role and the attestor role.
**Adversarial and security specialist.** When autonomous agents operate autonomous software through protocols, the attack surface expands in both size and novelty. Red-teaming, adversarial testing, and security verification become one of the fastest-growing sectors. The specific skills — adversarial prompt engineering, protocol fuzzing, agent manipulation, trace analysis — are mostly new, and the population currently able to perform them is small relative to 2030 demand.
**Agent engineer.** Engineers who build the general-purpose agents that mediate between humans and software. Small population, highly technical, concentrated in frontier labs. Structurally adjacent to — and in some cases overlapping with — the refined-token majors and the general-agent routing oligopoly described in the Token Economy section below.
**Protocol designer.** Engineers who shape interface standards (MCP and successors). The containerization precedent from the Historical Precedents applies directly: whoever standardizes the interface captures durable value (Levinson, 2006). The population is small but the per-individual leverage is among the highest available to an individual contributor.
**Creative-tool specialist.** For practitioners who prefer user-facing work: migrate toward domains where UIs remain valuable and are expected to grow more sophisticated rather than disappear — creative tools where the interface is the medium of work (Figma, Blender, DAWs, game engines, code editors, 3D modeling), real-time embodied interfaces (games, VR, simulators, vehicles, industrial control panels), regulated human-in-the-loop workflows where the UI is legally required as an audit surface, and human-to-human communication platforms. Generic dashboard and CRUD frontend work does not survive in recognizable form. High-craft creative-tool engineering gets smaller, deeper, and better-paid.
**Legacy archaeologist.** A bridge career open for roughly five years, approximately 2028-2033. Senior developers with deep knowledge of specific legacy systems can position themselves as the people who extract the theory of those systems (in Naur’s 1985 sense) into formal specifications that post-transition loops can work with. Demand is enormous during the window because every brownfield system needs its theory extracted before it can be fed into a closed-loop architecture; the role evaporates as legacy systems are migrated or decommissioned. For a mid-career developer with deep knowledge of a specific legacy system, this is one of the highest-leverage career bets in the transition, because the supply of people who can do this work is small, the demand is concentrated, and the window is explicitly time-bounded.
**Harness operator.** Unglamorous but durable, structurally similar to the people who operate the electrical grid — a real career, not glamorous, not compressed by further automation because the operations require domain-specific continuity.
##### **Positions That Die**
For clarity about the falsifiable side of the prediction: the positions that do _not_ survive in recognizable form by 2032 include generic full-stack development at SaaS startups, backend CRUD development, dashboard and reporting frontend work, generic manual QA, generic devops, and anything that competes primarily on coding throughput. The core logic is the electrification lesson from the Historical Precedents applied to career choice: being the best at the thing being automated is the worst possible position (David, 1990; Brynjolfsson, Rock & Syverson, 2021). The compression hits generic production roles earliest and hardest; it leaves judgment, liability, domain depth, and high-craft interface work largely alone or expanding.
**Action for this stakeholder group in 2026:** Pick one of the surviving positions within the next year, with strong preference for an exception-handler role where the individual has the domain depth and liability tolerance to enter it. Commit two years of deliberate practice. Work in public throughout the transition — the 2029 professional categories are being shaped now, and public visibility is how an individual claims one of the new titles before it solidifies.
The deepest and least-discussed prediction in this paper is about where the economic rent generated by the transformed software economy ultimately concentrates. This prediction is grounded in the oil precedent from the Historical Precedents, but the specific structural parallel is the **integrated oil major** — the refining-plus-distribution pattern — rather than pure commodity upstream extraction. This distinction matters for correctly locating the rent and predicting the market structure that stabilizes around it.
**Why the refined-oil framing, not crude.** Tokens are not a uniform commodity priced against a single benchmark, and a framing that treats them as one is wrong in a structurally important way. Crude oil is largely fungible at the benchmark level — a barrel of Brent is substitutable with another barrel of Brent, and the market prices them against a single reference. Tokens are not fungible in this sense. A token produced by a frontier reasoning model, a token produced by a fast inference-optimized model, and a token produced by an open-weight model are priced independently, optimized for different uses, and are not substitutable for each other at any uniform rate. The pricing structure is closer to refined petroleum products — gasoline versus diesel versus jet fuel, premium versus regular gasoline, high-sulfur versus low-sulfur diesel — than to crude.
**The refined-oil mapping.** The production stack for inference has the same shape as