2026-11-17

From Vibe Coding to Harness Engineering: As Code Generation Becomes Abundant, Software Engineering Shifts Toward Verification, Constraints, and Accountability

1. Capgemini’s Argument Must Be Understood in the Engineering Reality of 2025–2026

In Beyond Vibe Coding, Capgemini argues that enterprises should “treat AI-generated code as a prototype, not a production asset.” Taken out of its temporal context, this statement can easily be interpreted as a permanent rejection of AI coding. Viewed against the actual state of software engineering in 2025–2026, however, it is better understood as a prudent enterprise risk principle. The report is primarily warning against AI-generated artifacts that have not undergone sufficient code review, testing, security verification, deployment governance, and lifecycle management. It is not claiming that machine-generated code is inherently incapable of becoming production code. The report also explicitly acknowledges that AI-native engineering tooling is progressing rapidly, with secure-by-default generation, SDLC integration, and hybrid development models continuing to improve.

A more precise interpretation, therefore, is not that “AI-generated code is only suitable for demos,” but that as of 2026, successful generation alone is insufficient evidence of production readiness. Where mature engineering ownership, verification mechanisms, and production governance are absent, enterprises should treat AI-generated software as a high-fidelity prototype by default.

This is a policy default, not a technology ceiling. The distinction matters. The former will evolve as models, agents, harnesses, and engineering practices mature. The latter would amount to an unwarranted form of technological determinism.

2. The Missing Variable in Most AI Coding Discussions Is Who Is Using the AI

Discussions of Vibe Coding often treat model capability as the primary independent variable. The implicit assumption is that the same Claude, Codex, or other coding agent provides essentially the same software-production capability to every user. Real software engineering does not work that way.

An engineer who has spent years dealing with system architecture, database evolution, distributed systems, identity and access management, security, CI/CD, incident response, and long-term system maintenance is operating a fundamentally different development system from someone who merely knows what the final interface should look like—even when both are using exactly the same model.

Anthropic’s 2026 study of roughly 400,000 Claude Code sessions provides direct evidence for this distinction. In real-world collaboration, humans typically decide what to do, while the agent increasingly decides how to do it. The stronger the domain expertise brought by the user, the more work Claude can complete per instruction and the greater the probability that the session will succeed. Anthropic accordingly titled the research Agentic Coding and Persistent Returns to Expertise: agentic coding has not eliminated the returns to professional expertise.

This suggests that AI coding productivity cannot be reduced to “model capability.” At least under current conditions, a more realistic formulation is:

AI Engineering Productivity = Model Capability × Operator Expertise × Context Quality × Harness Quality × Verification Capacity

This is an analytical model proposed here rather than an established industry metric. Its significance is straightforward: if any one factor approaches zero, the final production value can fall dramatically.

A more capable model can expand the frontier of what can be done. It cannot automatically reconstruct business intent, system history, implicit constraints, or the engineering knowledge required to determine what “correct” actually means.

3. “90% of the Code Was Written by AI” Is Not the Same as Vibe Coding

A highly experienced full-stack engineer can allow an agent to produce 90% or even more of the implementation while still maintaining a rigorous software engineering process.

The engineer defines the architecture, module boundaries, data model, and API contracts. The agent performs much of the implementation. The result is then repeatedly refined through testing, static analysis, runtime feedback, performance measurement, and code review. Most of the final code may have been generated by a model, but design ownership, engineering judgment, and acceptance responsibility remain with the engineering team.

A more accurate description of this development model is AI-native engineering, not Vibe Coding.

Its basic loop is:

Engineer → Constraints → Agent Execution → Evidence → Evaluation → Correction → Verification

AI provides high-throughput implementation capacity, while the human engineer progressively shifts from line-by-line coding toward architecture, specification, supervision, failure diagnosis, and acceptance.

Anthropic’s 2025 research on real-world Claude Code usage already shows this structure. Approximately 79% of interactions involved some form of automation, yet a significant proportion still operated through feedback loops. Even when the model performed most of the execution, software development continued to require substantial human review and iteration.

That distinction matters. “AI performs most of the work” and “AI independently owns the software engineering process” are still very different propositions.

4. What Remains Immature in 2026 Is Fully Autonomous Software Engineering

AI-native engineering must be distinguished from Autonomous Software Engineering.

The former is already generating substantial real-world productivity. Engineers define tasks and constraints; agents inspect repositories, modify multiple files, run tests, diagnose failures, revise implementations, and submit results.

The latter requires something much more demanding: the AI must independently interpret ambiguous business objectives, choose the architecture, identify unknown risks, implement the system, demonstrate correctness, deploy it into production, and continue to maintain it as the environment changes over a period of years.

That boundary still exists.

Anthropic’s 2026 research on agent autonomy shows that Claude Code can sustain increasingly long autonomous tasks and is improving on complex internal workloads. Yet real-world deployments remain materially less autonomous than capability evaluations might suggest.

More interestingly, experienced users do not simply “supervise more” or “supervise less.” They are more likely to enable automatic approval while also being more willing to interrupt the agent when necessary.

This reveals a more mature pattern of human-AI collaboration: experts do not control AI by approving every step; they control it by understanding system state and intervening at the points where intervention actually matters.

Software engineering is therefore beginning to move from step-by-step supervision toward exception-based supervision.

This resembles the control models that enterprises have developed over decades of process automation and may become an important design principle for the next generation of coding agents.

5. The Real Risk Is Not That AI Makes Mistakes, but That Generation Capacity Is Outrunning Verification Capacity

The most important problem in Vibe Coding can be framed more precisely as an Assurance Gap.

The gap is not simply a question of model accuracy. It emerges when Generation Capacity grows much faster than Evaluation Capacity.

Historically, a developer could only produce a limited amount of code in a working day. Code review, testing, and comprehension therefore operated at roughly comparable orders of magnitude to code production.

Coding agents fundamentally change that balance. One person can now create, in a matter of hours, a software surface area that previously required weeks of engineering effort.

If the enterprise continues to rely on the same verification throughput, then increasing generation velocity may simply result in a rapidly expanding body of software that nobody has fully understood.

This produces a counterintuitive but important result:

The greater the productivity of AI coding, the stronger the verification system must become.

When:

Generation Capacity ≤ Evaluation Capacity

the agent creates productivity leverage.

When:

Generation Capacity ≫ Evaluation Capacity

the agent may instead create technical-debt leverage.

Capgemini’s production-readiness gap can be understood through exactly this lens. The report places the strongest Vibe Coding productivity gains in Discovery, Design, and Build, while showing sharply reduced benefits in Test, Deploy, Operate, and Change.

The underlying reason is that software generation is beginning to accelerate faster than the enterprise’s ability to verify, operate, and continuously govern the software being generated.

6. The New Scarce Skill of Senior Engineers Is Understanding the Failure Space

Traditional software development has tended to equate engineering capability with programming capability. Agentic coding is making that definition increasingly obsolete.

As more implementation work can be delegated to models, the skill that remains especially difficult to replace is the senior engineer’s understanding of the failure space.

An experienced production engineer can look at code that appears perfectly functional and immediately recognize that a particular object should not be global state; a concurrency problem will emerge later; a retry operation is not idempotent; authorization cannot safely be enforced on the client; the transaction boundary is incorrect; the database schema will not survive future scale; or the API abstraction is fundamentally wrong even though it works today.

These judgments are often absent from the requirements document. They are accumulated through years of exposure to how systems actually fail.

This is why one of the most dangerous categories of AI-generated software today can be described as:

Locally correct, globally wrong.

A function may be correct. A module may be correct. The demo may even look excellent. Yet the overall lifecycle, authorization boundaries, failure recovery, state consistency, or long-term maintainability of the system may be fundamentally flawed.

For someone without software engineering experience, these problems are particularly difficult to identify because the most dangerous moment in a software project is often the point at which the system appears to be working.

This also explains why coding agents may not necessarily reduce the productivity gap between expert engineers and non-experts. They can dramatically reduce the gap in the ability to produce code, while simultaneously increasing the gap in the ability to judge whether that code should be trusted.

7. Capgemini’s “Prototype” Is Better Understood as the Enterprise Default Trust Level

From an enterprise governance perspective, Capgemini’s strong recommendation is therefore reasonable: an AI-generated artifact should initially be assigned a prototype-level trust status.

The idea is conceptually similar to Zero Trust Security.

Zero Trust does not assume that every access request is malicious. It simply refuses to grant trust before identity, authority, and context have been established.

AI engineering can adopt a similar principle:

Generated ≠ Verified

Executable ≠ Correct

Tests Passed ≠ Production Ready

Production Ready ≠ Maintainable

The enterprise does not need to permanently label AI-generated code as “untrustworthy.” What it needs is a trust-escalation mechanism that moves an artifact from generated output to verified production asset.

Prototype should be the initial trust state. Architecture conformance, functional verification, security verification, integration testing, load testing, deployment gates, observability readiness, and owner acceptance progressively raise the trust level.

Seen from this perspective, Capgemini’s position is not especially conservative. It is actually close to the governance model that an AI-native software development lifecycle is likely to require.

8. This Is Why Harness Engineering Is Emerging as an Independent Engineering Layer

If every coding-agent session still requires a senior engineer to manually inspect every action from beginning to end, AI can improve individual productivity but will struggle to create enterprise-scale leverage.

The next engineering problem is therefore clear:

How do we encode the constraints, review methods, and failure knowledge held by senior engineers into the agent’s working environment, so that those constraints are enforced automatically during execution?

This is the purpose of the Harness.

The model provides intelligence.

The coding agent provides planning, tool use, and execution.

The Harness determines what context the agent works within, which tools it may use, what it may modify, which validations are mandatory, under what conditions execution may continue, when it must stop, which outputs can be accepted, and what evidence must be preserved throughout the process.

From the perspective of a development-agent Harness such as Forge, the important technical problem is therefore no longer simply “how do we make the agent write more code?”

The deeper problem is how to transform experienced engineering judgment into machine-enforceable constraints.

In other words, the long-term value of Harness Engineering lies in turning senior engineering judgment from individual tacit knowledge into reusable software-production infrastructure.

9. A Good Harness Must Control Behavior, Not Merely Add More Prompting

This distinction is critical.

Many systems today reduce the idea of an agent Harness to a longer system prompt, a rules.md file, AGENTS.md, or a set of coding guidelines. These mechanisms are useful, but they remain primarily forms of linguistic constraint.

A production-grade Harness must operate at the execution layer.

Specifications and architecture constraints should define the task boundary before work begins. Code changes should occur only inside explicitly defined repositories, branches, sandboxes, and permission scopes.

After each stage, the agent should automatically execute unit tests, integration tests, linting, type checking, security scanning, and, where appropriate, business-specific evaluations.

If failure thresholds are exceeded, execution should stop rather than enter an unlimited retry loop.

High-risk changes should automatically trigger human review.

Every tool invocation, code change, test result, and relevant decision should be traceable and reversible.

The transition is therefore from:

Engineer reads everything and decides

toward:

Engineer defines policies and evidence requirements; the Harness continuously enforces them.

Anthropic’s observations of real-world agent behavior point in the same direction. Experienced users increasingly allow agents to operate autonomously while supervising through monitoring and targeted interruption.

The role of the Harness is to encode as much as possible of the formalizable knowledge about when intervention is required before execution begins.

10. Software Engineering Is Moving from “Writing Code” to “Defining Acceptable States”

The traditional programmer’s core task has been to convert requirements into implementation.

For senior AI-native engineers, an increasingly important task may instead be to convert business objectives into a machine-verifiable acceptance space.

Consider a seemingly simple instruction:

“Implement an order-refund feature.”

For an autonomous agent, that remains far too open-ended.

If the engineer also defines the order state machine, refund-value boundaries, authorization policy, transaction semantics, idempotency requirements, API contracts, audit requirements, rollback behavior, test cases, and exception paths, the agent’s solution space becomes substantially narrower and the probability of correctness increases.

This helps explain why mature AI coding will not simply evolve into a competition over who can write better prompts.

The more important long-term disciplines are likely to be:

Specification Engineering

Context Engineering

Evaluation Engineering

Harness Engineering

Prompts communicate intent. These engineering systems define what it means for an outcome to be demonstrably correct.

From the perspective of software history, this evolution is entirely consistent.

High-level programming languages abstracted machine instructions.

Frameworks abstracted recurring software structures.

Cloud computing abstracted infrastructure operations.

Agents are now beginning to abstract large portions of implementation labor.

Every major layer of abstraction moves human value upward—toward constraints, architecture, judgment, and responsibility.

11. Capgemini’s Lifecycle Argument Matters More Than the Question of Whether AI Will Replace Programmers

One of the strongest aspects of the Capgemini report is its decomposition of the enterprise application lifecycle into seven phases:

Discovery → Design → Build → Test → Deploy → Operate → Change

This framework reminds enterprise leaders that dramatically reducing the time required to create the first working version of an application does not mean that the economics of software have been fully solved.

Generating an application in two hours and keeping that application reliable over five years of business growth, personnel turnover, dependency upgrades, regulatory change, data-model migrations, security incidents, and infrastructure evolution are fundamentally different capability problems.

The expensive part of enterprise software is often not writing it for the first time.

It is repeatedly proving that:

after every change, the system is still correct.

That is why the Change and Sustain phases remain difficult.

AI can assist with refactoring and modification, but it still requires a stable reference system that tells it which behaviors must remain unchanged, which contracts cannot be broken, and which compliance requirements must continue to hold.

The foundational assets of AI-native software engineering may therefore extend well beyond the source-code repository.

They will increasingly include:

specifications, architecture contracts, evaluation suites, policies, runtime telemetry, decision histories, and business acceptance cases.

Code remains essential, but code alone is no longer sufficient to describe the software system.

12. The Real Opportunity for Forge-Like Harnesses Is to Scale Assurance Capacity Alongside Generation Capacity

From both a product and enterprise-services perspective, this may become the defining competitive boundary for the next generation of automated development agents.

The first phase of competition has focused on Generation Capacity:

Who writes code faster?

Who supports more languages?

Who can modify larger repositories?

Who can operate autonomously for longer periods?

The second phase will increasingly focus on Assurance Capacity:

Who can reliably verify increasingly long and autonomous agent workloads?

Who can translate an enterprise’s engineering standards, security policies, architecture patterns, testing assets, and deployment controls into executable boundaries for agents?

As a result, the core performance indicators for a Harness should not be limited to code generated, tasks completed, or autonomous runtime duration.

They should increasingly include:

first-pass verification rate,

regression escape rate,

human intervention rate,

rollback rate,

security-gate failure rate,

cost per accepted change,

and, ultimately:

accepted production changes per engineering hour.

These measures are much more closely aligned with actual enterprise value.

13. Valuable Autonomous Coding Will Be Built on Stronger Constraints, Not Fewer Constraints

At first glance, this may appear counterintuitive.

The conventional assumption is that stronger models should be given more freedom.

Production systems have historically followed a different rule:

the greater the desired level of autonomy, the stronger the control infrastructure must become.

Capgemini’s Agentic Automation Framework defines autonomy as a progression from Assist Only, to Execute with Approval, Execute with Monitoring, Conditional Autonomy, and eventually Full Autonomy.

The report argues that most enterprise deployments should begin at lower autonomy levels and expand permissions only after observing real production performance.

The same principle applies directly to coding agents.

A development agent may be given substantial freedom to inspect repositories, modify code, generate tests, run compilers, control browsers, deploy preview environments, and coordinate multiple sub-agents.

But permissions to modify production branches, access credentials, perform database migrations, execute production deployments, or carry out destructive operations should depend dynamically on risk level, verification evidence, and policy.

Mature autonomous coding will therefore not look like “AI with nobody watching.”

It will more likely look like:

AI granted substantial operational freedom inside a highly structured Harness.

Greater structure makes greater autonomy possible.

14. Enterprise Accountability Does Not Disappear Because the Code Was Generated by a Machine

AI coding also creates an important organizational governance problem.

Historically, software code was directly produced by engineers, so the creator and the owner were usually relatively close.

With agentic coding, the immediate creator increasingly becomes the machine. Enterprise ownership, however, cannot disappear with that shift.

A production system still requires clearly assigned responsibility for:

architecture,

security,

data,

release management,

and business outcomes.

The agent may perform the work, but “the AI wrote it” cannot become a mechanism for diffusing accountability.

From the perspective of enterprise digital and intelligent transformation, this is analogous to autonomous driving.

The fact that a vehicle can perform an increasing share of driving actions does not mean safety responsibility can simply be delegated to “model capability.”

A mature system still requires a defined operational design domain, permission boundaries, handover conditions, and evidence.

Enterprises evaluating AI coding platforms should therefore ask more than:

“How many tasks can this system complete autonomously?”

They should also ask:

Who proves that those tasks were completed correctly?

How are failures detected?

Who holds final acceptance authority?

Can the evidence be audited?

These are the questions that determine whether an AI development platform is genuinely enterprise-grade.

15. AI Coding May Ultimately Change the Production Function of Software Organizations More Than It Changes Development Cost

One particularly important finding in Anthropic’s 2026 research is that domain expertise appears to explain successful agentic coding more strongly than coding proficiency alone.

The deeper the user understands the underlying problem, the more effectively the agent can perform.

This has significant implications for the long-term structure of software organizations.

Historically, product managers described requirements, architects designed systems, programmers implemented them, and testers validated the output.

As coding agents take on more implementation work, the distance between domain experts, product specialists, and senior engineers may shrink.

A smaller team with a much higher density of expertise may be able to use multiple agents to achieve several times—or potentially an order of magnitude more—implementation throughput than was previously possible.

But expertise does not disappear.

The organizational bottleneck shifts from:

How many people can write code?

to:

How many people truly understand the business, the system, and its risks—and can formalize that understanding into constraints that agents can execute and verify?

The more likely organizational pattern in the AI coding era is therefore:

expertise compression + execution amplification.

Teams may become smaller.

Execution capacity may increase dramatically.

And the value of high-quality professional judgment may rise rather than fall.

16. From the Perspective of HaxiTAG Forge, What Is Worth Building Is an Execution System for Engineering Judgment

If this reasoning is taken to its logical conclusion, a system such as Forge should not be positioned simply as “another coding agent.”

The market is unlikely to suffer from a long-term shortage of models capable of generating code.

What remains scarce is the engineering layer that connects:

expert intent, agent execution, and production assurance.

Such a system needs to transform:

what senior engineers know

into specifications;

what senior engineers forbid

into policies;

how senior engineers determine correctness

into evaluations;

and what senior engineers do when things fail

into recovery mechanisms.

One or more coding agents can then operate autonomously within those boundaries.

This produces a new AI-native software production pipeline:

Intent → Specification → Context → Plan → Agent Execution → Automated Evidence → Evaluation → Correction → Human/Policy Acceptance → Deployment → Runtime Feedback

The most valuable long-term assets in this architecture may not be the agents themselves.

Models will continue to improve.

Coding agents will increasingly become commoditized.

The durable enterprise assets are more likely to be:

specifications,

evaluation datasets,

engineering policies,

failure cases,

architecture rules,

and acceptance criteria.

This is where a Harness can accumulate compounding value over time.

17. Enterprise Customers Do Not Need to Buy “AI That Can Write Code”; They Need Provable Acceleration of Software Delivery

From a CMO and enterprise-services perspective, this distinction is critical.

“AI can write code” is rapidly moving from a differentiated capability to a baseline market expectation.

A product positioned primarily around generation speed will increasingly be forced into direct competition with foundation-model providers and coding-tool vendors.

Enterprise customers are concerned with a different set of questions:

Can we get to production faster?

Will the system fail after deployment?

Will existing systems be disrupted?

Are data and permissions protected?

Can future versions still be maintained?

Will the system remain understandable after team turnover?

Can we determine the cause of a production incident?

And, most importantly, has greater development efficiency actually reduced the cost of each acceptable production change?

For this reason, the enterprise AI coding value proposition needs to move from:

Code Generation

toward:

Trusted Software Delivery

This aligns with the broader enterprise AI transformation principle that technology deployment is not the end state.

The real objective is to embed intelligent capabilities into operational systems in a way that produces persistent, measurable, and governable gains in organizational performance.

18. Conclusion: Code Generation Is Becoming a Compute Resource; Verification Is Becoming Core Software Infrastructure

Returning to Capgemini’s original argument, treating AI-generated code as a prototype remains a reasonable enterprise default in 2026.

What the argument requires are two explicit boundaries:

a temporal boundary and a capability boundary.

As models and agents continue to improve, the scope of this default will progressively narrow.

But the principle will not simply disappear.

It will evolve into a more granular trust model.

Low-risk changes may be accepted automatically.

High-risk changes will require stronger verification.

Mature engineering organizations may delegate substantially more authority to agents.

Organizations with limited engineering capability will require stricter Harness controls.

Some categories of change may become fully autonomous.

Others will continue to require clearly accountable human owners.

The most important measure of progress in AI coding, therefore, may not be whether a model can program autonomously for five hours, fifty hours, or five hundred hours.

The more consequential question is:

Can we prove, at comparable speed, that the work it performed during those five hundred hours is still correct?

As code-generation capability becomes commoditized, the scarce resources in software engineering will increasingly concentrate around four capabilities:

understanding the problem, defining the constraints, recognizing failure, and proving the result.

From this perspective, Vibe Coding is only the first stage of the AI software engineering revolution.

The next stage—the one that determines whether enterprises can reliably move from prototype to production—will be defined by Harness Engineering, Evaluation Engineering, and Assurance Engineering.

And the most important problem for development-agent systems such as Forge is therefore not:

“How can the agent write even more code?”

It is the harder and more strategically valuable question:

How do we turn the judgment of exceptional software engineers into software infrastructure that can be executed at scale?


Related Topic

  1. In the Age of AI Coding, the Real Question Is How to Make the Right Judgment — Lessons from the Claude Code Team’s Frontline Practice

  2. From Code Completion to Engineering Intelligence: The AI Coding Revolution Behind Cursor’s Developer Habits Report

  3. Component Security in the AI Coding Era: From Dependency Management to Software Supply Chain Governance

  4. The Complete Guide to AI Coding in 2026

  5. Analysis and Extended Reflections on AI Use Cases in Software Development

  6. From Model Capability to Trusted Delivery: An Analysis of Trust Reconstruction in AI Commercialization

  7. The Truth About Enterprise AI Deployment: Why 90% of Projects Never Make It Past the Demo Stage

  8. Algorithm-Centric Enterprise IT Restructuring: Software Industry Divergence and Trusted Intelligent Infrastructure Practices in the Age of AI Agents

  9. Trust Reconstruction and Safety Productivity Evolution Under the Agent Paradigm

  10. Enterprise AI Adoption: A Paradigm Shift from "Buying Models" to "Buying Business Outcomes"