The Entropy Shift: Software Engineering’s Second Half
Author: Zhang Qi
(A fresh graduate engineer based in China)
For decades, the evolution of software engineering has revolved around one core constraint: the productivity of code.
From Assembly to High-Level Languages, from Waterfall to Agile, and from Stack Overflow to GitHub Copilot, every iteration of tools has aimed to solve the same problem: reducing the friction cost of converting human intent into machine instructions. This has worked. Software ate the world, internet applications exploded, and programmers became the digital architects of modern society.
Behind these historic milestones lay a fundamental axiom of the "First Half" of software engineering: Code is a scarce asset, and writing code is the primary path to creating value.
So, what has changed?
In three words: The marginal cost of intelligence has hit zero.
More accurately, the marginal cost of syntactically correct logic generation has hit zero. With the maturation of models like the o-series and Claude, we have finally found a recipe to generate logically self-consistent code at a near-infinite rate. Just two years ago, if you told most tech leads that a junior engineer could generate an entire microservice module with a single prompt, they would have called it not just impossible, but irresponsible.
Yet, here we are.
What happens next? The "Second Half" of software engineering—starting now—will shift focus from Production to Governance. In this new era, Reviewing outweighs Writing. We no longer ask, "Can we build this feature?" We ask, "How do we prove this AI-generated code will converge in production?"
To succeed in the Second Half, we need to introduce first principles from Physics, Information Theory, and Institutional Economics to redefine the value anchor of an engineer.
The First Half: Scarcity and Apprenticeship
To understand the First Half, look at its organizational structure.
For the past thirty years, tech companies have maintained a classic "Pyramid" structure: a massive base of junior engineers, a middle layer of seniors, and a peak of architects. This defined the rules of the game: Apprenticeship.
Why? Because in the First Half, converting intent to code was a high-friction process.
For a junior engineer to write a usable CRUD interface, they needed to understand syntax, frameworks, and business logic. This was a slow accumulation of "Explicit Knowledge." Companies were willing to pay juniors to "practice," tolerating their inefficient code because it was the only way to transform manpower into productivity.
In this paradigm, code was viewed as an Asset. If you could write more features, you created more value. Engineer output was often correlated with Lines of Code (LoC) or feature points delivered.
This game lasted for decades, until LLMs learned not just to autocomplete code, but to reason.
Variable 1: Thermodynamics — Code as a Liability
Why are the rules changing? Because "Code Production" is no longer the bottleneck. "System Entropy" is.
We must introduce the first principle of Thermodynamics: A software system is essentially an evolving complex system whose natural tendency is toward disorder (Entropy).
In the First Half, because the speed of human coding was limited by physical time (thinking, typing, debugging), the rate of entropy increase was linear and manageable by human effort.
In the Second Half, the recipe has changed. AI is a hyper-pressurized Entropy Accelerator. It can generate a volume of code in minutes that would take humans weeks to write. This creates the illusion known as "Vibe-coding": it looks like we are building faster.
But from a physics perspective: Code that is not reviewed and understood is not an asset; it is pure Technical Debt.
Every line of code generated by AI but not fully comprehended by a human is a "Black Box" injected into the system. If engineers lose control over context boundaries, these black boxes accumulate. When errors inevitably occur, the cost of remediation rises exponentially.
Therefore, the engineer's duty shifts fundamentally: from a "Producer of Code" to a "Suppressor of Entropy."
Variable 2: Information Theory — The SNR Flip
In Information Theory, value depends on Scarcity and the Signal-to-Noise Ratio (SNR).
- First Half: Code was Signal. Because writing was hard, high-quality code was scarce.
- Second Half: Code is flooding the market. AI has turned code into "Noise."
When GitHub is flooded with mediocre, redundant, or subtly hallucinated code generated by AI, the true scarce resource is no longer the "ability to generate content," but the "ability to discern truth."
This explains why we are seeing a "Thumbtack-shaped" talent structure forming:
The vast execution layer at the bottom is being replaced by AI Agents (because their signal can be replicated at low cost), leaving only a very narrow channel for promotion (reserved for the highly disciplined "monks" who master underlying principles), and a "Super Individual" class at the top.
The high salaries of these Super Individuals are essentially pricing for high "Cognitive Bandwidth"—the ability to precisely filter valid business logic from the massive noise generated by AI.
Variable 3: Institutional Economics — Pricing Liability
Some argue that as AI improves, we can eventually offload reviewing to AI (AI Reviewing AI).
In Institutional Economics, this doesn't work. Transaction is not just about exchanging information; it is about exchanging Liability.
1. The Closed-Loop Hallucination & Polanyi's Paradox
If a system is entirely generated by AI and verified by AI, it loses "Ground Truth." As Michael Polanyi said, "We can know more than we can tell."
Software engineering contains vast amounts of Tacit Knowledge—unspoken business rules, legacy compromises, political trade-offs between upstream and downstream. These are contexts missing from AI training data. Only human engineers can act as translators between the "Real World" and "Digital Logic," breaking this closed-loop hallucination.
2. The Value of the "Sign-off"
AI has no legal personhood. AI cannot go to jail. AI cannot be held accountable for a P0 incident.
In the Second Half, the $70k+ (or much higher) salary companies pay to senior engineers is no longer buying "labor"; it is buying "Liability Insurance."
When a production system faces collapse, or a decision must be made that could incur millions in losses, a carbon-based organism must push the button. This "Sign-off Right" is the hard currency that AI can never replace.
The Second Half: From Builder to Auditor
The recipe is fundamentally changing the nature of the game. Recap the First Half:
- We learned syntax, frameworks, and design patterns.
- We improved proficiency by writing more code.
- We got promoted by delivering features.
This game is being upended. The new rules for the Second Half are:
- Code Deflation, Trust Inflation: Those who only know how to write code will see their value approach zero; those who can guarantee code reliability will see their value soar.
- The Physical Death of Apprenticeship: Companies will no longer provide training grounds. Newcomers must cross the chasm from "Zero" to "One" through high-intensity self-training (simulated reviews, reading source code, refactoring AI code) before entering the workforce.
- A New Paradigm of Symbiosis: It is not "Human + AI" doing the same thing. It is "AI handles Tactical Execution (Generation), Human handles Strategic Decision (Review)."
Conclusion
Welcome to the Second Half.
The rules here are crueler, but also purer. Players in the First Half won by memory and typing speed; players in the Second Half win by controlling entropy and establishing trust.
This is no longer a game of "who writes faster," but a game of "who understands the system better." For new entrants, if you cannot logically dominate the AI, if you cannot point out the AI's fallacies during a review, you will not get a ticket to the Second Half.
Code is dead. Long live Engineering.
Author Bio: Zhang Qi is a fresh graduate software engineer based in China. Navigating the shifting landscape of the AI era, he secured a top-tier offer by redefining the role of the engineer from a code generator to an architect of AI governance.
Top comments (0)