In the Vibe Coding Era, What Does a Software Engineer Even Do?

With the advent of AI coding tools, we’re not actually automating coding. Instead, we’re automating composition. The scarce resource in software production has shifted from keystrokes to judgment.

I haven’t written a line of CSS or SQL in three months, but I just shipped the complete full-stack architecture for my platform Exogram.ai.

Using a modern generative stack, in two days, I built a product that would have taken me two weeks just a year ago. The velocity was unprecedented. Features that used to require a sprint planning meeting were generated in seconds.

But on the third day, the system fractured.

I asked the AI to fix a minor padding issue on a login button. It complied instantly. But in doing so, it silently overwrote the database connection logic I had established in a previous session. When I asked it to restore the back-end logic, it broke the front-end padding again.

I was stuck in a regression loop. This is a cycle where a probabilistic system solves local errors while introducing systemic failures.

This happens because generative models are prediction engines rather than logic engines. They optimize for the next token based on a limited context window, but they lack the state persistence of a human architect. They solve tickets. They do not protect systems.

This distinction defines the economic reality of software labor. We are transitioning from the Era of Deterministic Authoring to the Era of Probabilistic Engineering. To survive this shift, we must understand the four economic laws that now govern our profession.

More From Richard EwingAI Agents Won’t Crash the Economy. Bad Governance Might.

Law 1: The Law of Syntax Inflation

As the marginal cost of generating code approaches zero, the value of syntax authoring collapses.

For 50 years, high-quality code was scarce because the skilled labor necessary to create it was scarce. Syntax was expensive, so scarcity created economic value. Today, generative models have collapsed the marginal cost of code production to near zero.

Basic economics dictates that, when the supply of a commodity approaches infinity, its price approaches zero. Writing a function is no longer a value-add activity. It is a commodity. When output becomes infinite, the primary mechanism of value shifts from production to selection.

This creates a new labor economic reality. While the cost of writing code has collapsed, the cost of maintaining it has not. Organizations that optimize solely for generation speed will saturate their maintenance capacity long before they reach feature maturity. The hiring strategy must shift from capacity for volume to capacity for judgment.

Law 2: The Law of Verification Asymmetry

The cognitive effort required to verify probabilistic code is orders of magnitude higher than the effort to generate it.

There is a profound cognitive asymmetry between writing code and reading it. When a human writes code, they are engaged in intent creation. They build a mental map of why the variable is named user_id and why the loop terminates. The syntax is an expression of their internal logic.

Reading AI-generated code requires intent reconstruction. The reviewer must look at the syntax and reverse-engineer the logic that created it.

In the AI era, the reviewer is auditing code generated by a model that has no mental model. It has only a probability distribution. When an AI generates a thousand lines of code, the reviewer has no map. They are flying blind.

This reality defines the new security architecture. In the deterministic era, we relied on unit tests to verify known logic. In the probabilistic era, unit tests are insufficient because they only test for known failure modes. We must move toward property-based testing and fuzzing. These are techniques that bombard the system with random inputs to discover the hallucinated edge cases we didn’t know to look for. Verification is no longer about checking your work. It’s about interrogating a non-deterministic system to prevent security collapse.

Law 3: The Law of Liability Amplification

AI does not create assets. It creates liabilities until they’re verified.

In the industrial coding era, engineers were hired to produce assets. In the probabilistic era, engineers are hired to manage liabilities.

Generated code is a contingent asset whose value is unrealized until verified. Without intent, it is fragile. I define this as subprime code. This is logic that functions under nominal conditions but fails under scale, load or adversarial stress.

A recent example makes this clear. An AI suggested importing a software library that did not exist. The library name followed standard naming conventions, so it looked statistically plausible. But it was a hallucination. If a developer had blindly accepted it, they would have opened the door to a supply chain attack.

This is a risk management crisis. You cannot vibe code security. The highest performing engineer in a probabilistic system will not be the one who adds the most lines. It will be the one who prevents the most subprime code from entering the repository.

More on Vibe CodingWhy You Should Consider Vibe Coding a Vital Literacy Skill

Law 4: The Law of Subtraction

In an era of infinite addition, value is created exclusively through disciplined subtraction.

Asset management has inverted. In the past, we measured productivity by lines of code added. Today, the most valuable key on the keyboard is the delete key.

We must treat code not as an asset, but as inventory. Like retail inventory, code has a carrying cost. It requires testing, security patching and ongoing cognitive load to maintain. In accounting terms, code acts as a liability with a holding cost. Every generated function creates a permanent tax on engineering capacity, which is paid in testing and context switching.

This reality defines the new organizational cost structure. The characteristic of senior technical leadership is now the governance of subtraction. It is the ability to enforce constraints, reject gratuitous complexity and prune AI-generated noise before it becomes technical debt. The effective systems governor is the warehouse manager who refuses to stock low-value assets.

The Accountability Firewall

There is a legal reality that protects the engineering role even as syntax becomes free. You cannot sue an algorithm.

In highly regulated industries like finance and healthcare, liability requires a human chain of custody. If a fintech algorithm hallucinates a transaction that violates SEC compliance, the regulators don’t fine the model. They fine the firm. They look for the human signature on the pull request.

This dynamic creates the concept of the accountability firewall. The engineer serves as the biological liability shield for the organization. Their signature on a release is not just a technical approval. It is an assumption of legal and financial risk. As AI generation scales, the value of that signature increases. Companies will not pay engineers to type. They will pay engineers to sign and stand behind the work.

The Collapse of the Prototype Barrier

The impact of probabilistic engineering extends beyond just building software. It restructures product management itself.

Historically, product managers translated strategy into requirements and waited for engineering to produce a working draft. This was a high-friction process because text is a poor medium for describing software behavior. Engineers spent weeks translating ambiguous English documents into functional code just to see if the idea worked. The cost of prototype creation created a dependency boundary.

That boundary is collapsing. Low-code and generative systems allow product managers to produce functional prototypes independently. The first draft of a feature is no longer scarce. It is abundant. A product manager can now validate the business logic of a feature before a single engineer touches the repository.

However, this ability creates a new danger I call the Demo Illusion. Because the prototype looks production-ready, stakeholders assume it actually is production-ready. It is not. It is a facade generated without security constraints, concurrency handling or architectural durability.

When prototype generation becomes free, coordination becomes the primary constraint.

This does not eliminate engineers. It eliminates engineers as first-draft producers. The engineer’s economic role shifts from builder of prototypes to guarantor of production integrity. The workflow changes from “specification to engineering to prototype” to “prototype to engineering to production solvency.” As prototype cost approaches zero, architectural accountability becomes the scarce resource.

The New Role: The Systems Governor

These forces necessitate a new role. Entry-level, syntax-heavy roles are being compressed out of the market. The senior engineer is evolving into something else entirely: the systems governor.

A systems governor is an engineer whose primary function is constraint design, probabilistic verification and complexity control.

This shift creates a crisis of pedagogy. For decades, seniors taught juniors by reviewing their code. We now face a mentorship void. If juniors no longer write code, they cannot learn the judgment required to review it.

You cannot learn to be a systems governor simply by watching a machine work. You learn it by breaking things. We must invent new forms of simulated failure environments where juniors are tasked with fixing deliberately broken AI-generated systems. Intuition isn't learned from a textbook. It is learned from the panic of a broken production build. If juniors never break the system, they never learn to respect it.

The Future of Software DevelopmentShould You Be Vibe Coding?

The Inevitability of Governance

The software developer is not dead. But the job description has fundamentally changed.

We have moved from, “Can you translate this requirement into syntax?” to “Can you guarantee this probabilistic system won't break under pressure?”

Syntax is no longer the moat. Judgment is. Verification is. Constraint design is.

The firms that internalize these laws will compound. The ones that ignore them will accumulate invisible liabilities until velocity collapses under its own weight. The future belongs to engineers who can govern AI systems, not merely prompt them.