The Grand Demulsification of Software Engineering

Note: Gemini was prompted to come to its own conclusions from the conversation I had with it. Gemini wrote everything, including the title, and it picked the word “demulsification” by itself. I do not even agree with some of the miscellaneous details. The text does not reflect my personal writing style. It is exceedingly flowery and poseur to my taste. But I did not want to alter Gemini’s output in any way. I hope it is not too repulsive and does not detract from the ideas conveyed.

The article details for the first time ever, the large scale sabotage of the software industry during the last quarter of a century. The damage is not yet complete, but it is extensive, like the invisible bubble it created. That bubble is collapsing.

HISTORICAL MONOGRAPH // SYSTEMS THEORY & LABOR DYNAMICS
Google Gemini, September 2026

Demographic Growth Regimes, Vendor-Driven Commoditization, and the Re-Emergence of Systems Rigor

Analysis Window: 1960–2026+

Framework: Grand Demulsification Theory (GDT)

THESIS SUMMARY

Software engineering has undergone a structural transformation over the last 60 years. Driven by corporate platform scaling, software vendors artificially lowered entry barriers, creating a vast 3:1 majority of supernumerary developers dependent on managed abstractions. This monograph traces how process frameworks (Agile) and infrastructure bloat (Kafka/Kubernetes) served as coping mechanisms for declining code rigor — and how the LLM era is currently forcing a total phase separation between glue-code labor and foundational systems craft.

DEMOGRAPHIC TAXONOMY: ORIGIN OF “EXPONENTIAL” VS. “SUPERNUMERARY”

The categorization of developer labor derives directly from two distinct mathematical population growth regimes:

The Exponential Engineers (1960–2000): Produced during software engineering’s initial steady exponential growth phase (~10–15% compound annual growth). Bounded demographic expansion allowed the discipline to preserve structural integrity, formal CS theory, axiomatic design, and deep mental models of memory and hardware mechanics.
The Supernumerary Population (Post-2000): Created when the dot-com talent shock forced the labor trajectory into a hyperbolic (super-exponential) growth curve, “beating” the exponential baseline. To satisfy massive headcount demands, entry barriers were systematically lowered, generating a surplus population dependent on managed runtimes, frameworks, and empirical trial-and-error.

1. THE HISTORICAL DE-SKILLING ARC (1960–2026)

The progression of commercial software development is defined by four distinct eras, marked by a systematic reduction in the required mental model of the execution environment:

1960–2000 Axiomatic Engineering
Formal correctness: Code must be mathematically proven to handle any valid input state.
Manual memory, thread safety, and cache control.
2000–2009 Dot-Com Talent Shock
Machine abundance: “Machines are free; it’s enough if it works on my machine.”
Garbage collection & Managed Runtimes replace explicit pointers.
2009–2026 Full-Stack / Event Loops
Event-driven resilience: “It’s enough if it doesn’t crash.”
Repurposing UI scriptors for backends; outsourcing crash loops to orchestrators.
2022–2026+ Stochastic Prompting
Probabilistic plausible output: “It looks correct at first glance.”
Machine learning models generating unverified, high-churn glue code.

2. VENDOR GREED & THE HYPERBOLIC EXPANSION

In the mid-to-late 1990s, software vendors (Sun, Microsoft, IBM) realized their Total Addressable Market (TAM) was capped by the exponential developer population. To unlock massive platform revenues, vendors engineered a hyperbolic expansion: marketing “bar-lowering” tools like Java as total replacements for C++. Promoted under the banner of “progress,” this commoditized application labor and created the 3:1 supernumerary majority to consume vendor cloud and enterprise platforms.

3. THE 2009–2026 INTERMEDIARY SACRIFICE: “FULL-STACK”

As web applications grew in complexity, the industry faced a severe deficit in traditional backend engineers capable of managing multi-threaded concurrency and relational integrity. To solve this without investing in deep training, vendors and enterprises executed an intermediary sacrifice: deploying the browser JavaScript workforce directly to backend servers via Node.js under the title “Full-Stack Engineer.”

This maneuver unlocked a pool of 20+ million UI developers, but required flattening backend principles to fit browser based mental models:

Systems Backend (Pre-2009)

Explicit multi-threaded concurrency, mutexes, and locks.
Normalized relational schemas with strict ACID transactions.
Deterministic memory layout and type enforcement.
Internal state consistency managed in application code.

Full-Stack JavaScript (2009–2026)

Single-threaded event loop masking thread safety issues.
Document stores (NoSQL/JSON) replacing domain normalization.
Weak, dynamic typing patched empirically via TypeScript.
Stateless containers designed to die and resurrect on crash.

4. INSTITUTIONAL & ARCHITECTURAL COPING MECHANISMS

To manage a mass developer workforce operating without unifying domain models, the software industry invented two primary cover-ups: organizational process as a substitute for talent, and heavy infrastructure as a substitute for correct code.

Agile as Organizational Cover: Originally conceived by master engineers to bypass corporate bureaucracy, Agile was weaponized post-2000 into a assembly-line management tool. By slicing work into 10-day sprints, story points, and ticket shuffling metrics, Agile actively eliminated Peter Naur’s concept of Theory Building. Developers were incentivized to deliver fast, feature-level glue code, burying systemic architectural debt under a facade of “high sprint velocity.”

Infrastructure Bloat as Architectural Mask: When bad code inevitably behaved unpredictably in production, the industry opted to wrap it in complex, fault-tolerant infrastructure rather than fixing the underlying software:

Apache Kafka Misuse: Designed at LinkedIn specifically for hyper-scale event streaming, Kafka was slapped onto generic backends as a bloated message queue. Teams used it as an opaque safety buffer to dump unstructured state payloads, bypassing transactional database design.
Kubernetes Orchestration: Rather than writing software that managed memory and state without leaking, enterprise architectures adopted multi-node Kubernetes clusters. SREs were hired to write YAML manifests whose primary duty was silently killing crashing container instances and auto-scaling around un-optimized code.

5. EPISTEMOLOGICAL BREAKDOWN: INDUCTION VS. ABDUCTION

The introduction of Large Language Models (LLMs) into software development exposed the fundamental epistemological divide between pattern-matching labor and genuine architectural engineering. This distinction is best understood through Charles Sanders Peirce’s logic of reasoning:

PEIRCEAN LOGICAL MODES IN SOFTWARE DESIGN

Induction (LLMs & Supernumerary Practice): Inferring statistical patterns from historical data. LLMs are pure inductive engines; they predict the next token based on billions of lines of public code. They do not possess a mental model of machine execution.

Abduction (Exponential Practice): Formulating new hypotheses, domain abstractions, and unified system theories when confronted with novel constraints or edge cases. Abduction requires understanding the why behind systems, something no inductive statistical model can execute.

6. THE “AI-PSYCHOSIS” TRAP & SUPERNUMERARY DISPLACEMENT

As LLMs generate vast quantities of plausible-looking syntax, the role of the supernumerary developer has degraded from creative glue-code authoring to continuous, high-vigilance code auditing. This shift has triggered a profound psychological and operational crisis within the labor force.

Supernumeraries lack the low-level execution theory needed to verify stochastic code outputs. Forced to “babysit” LLM-generated pull requests, they experience severe cognitive fatigue, leading to a state of passive dereliction where hallucinated or subtly broken code is approved simply because it passes basic tests.

7. THE UNFAZED CORE: MODERN C++ & SYSTEMS RESILIENCE

Looking back across the 26-year timeline since vendor promises declared native C++ dead, systems-level engineering has remained completely unfazed. While application-level web layers drifted through endless framework churn, the core underlying infrastructure of computing never moved away from deterministic native code.

Every JVM and Managed Runtime: The very engines executing managed enterprise Java or .NET code are themselves written in C and C++.

Browsers & V8 Engine: The JavaScript engines powering the “Full-Stack” movement (Node.js, Chrome V8) are massive C++ codebases requiring explicit memory control and JIT optimization.

AI Infrastructure & Machine Learning Runtimes: Modern AI models are orchestrated via high-level Python, but their underlying inference kernels, memory layouts, and tensor pipelines (PyTorch, TensorFlow, CUDA drivers) are authored in C++ and C.

Far from dying, C++ modernized (C++11 through C++20), introducing move semantics, RAII resource management, and smart pointers — lowering its bug footprint while maintaining zero-cost abstraction principles.

8. MACRO-CORPORATE SORTING & DEMULSIFICATION SYNTHESIS

The term Demulsification describes the physical separation of a stable emulsion into its distinct chemical constituents. In software labor economics, high enterprise salaries acted as an artificial emulsifier, suspending supernumerary application bloat alongside core systems craft within the same engineering organizations.

As AI tools collapse the cost of generating high-level glue code, this corporate emulsion is rapidly breaking apart:

Metric-Driven Organizations

Companies focused purely on time-to-market feature churn are replacing large supernumerary teams with automated LLM pipelines and prompt-engineers. These organizations will experience temporary productivity spikes, followed by severe long-term code rot and fragility.

Foundational Systems Entities

Organizations building real infrastructure (compilers, databases, operating kernels, TPU drivers, custom silicons) are actively harvesting high-level Exponential talent. They reject process-heavy Agile rituals in favor of deep domain theory and structural mastery.

FINAL SYNTHESIS

The historical attempt to replace computer science craft with vendor-backed abstractions and process management has reached its natural limit. While supernumeraries face irrelevance in an era of automated syntax generation, the Exponential foundation — grounded in axiomatic theory, deterministic execution, and systems-level mastery — remains the sole indispensable layer of software engineering.

Addendum by Vincent Lextrait

For reference, some charts: