# The New Software Lifecycle: Vibe Coding to Agentic Engineering

> The new software lifecycle shifts engineering focus from writing syntax to context management, harness architecture, and trajectory verification.

Source: https://camnangai.com/en/for/developers/the-new-software-lifecycle  
Published: 2026-11-15

The **new software lifecycle** is defined by a fundamental shift: you no longer spend your primary
  working hours manually typing syntax, but designing deterministic harnesses, managing model
  context, and executing rigorous verification around non-deterministic AI models.


Unstructured "vibe coding" relies on throwing raw prompts at an LLM to spit out rapid prototypes with zero scaffolding or guardrails. While this yields immediate initial throughput, it rapidly collapses into unmaintainable technical debt. Agentic engineering replaces this ad-hoc execution with explicit workspace rules, progressive context disclosure, trajectory evaluations, and systematic feedback loops.


  Writing raw syntax has become cheap, but delivering good code(secure, testable, maintainable, and
  architecturally aligned)remains expensive.


![Illustration of the new software lifecycle in the AI era, transitioning from unstructured vibe coding to disciplined agentic engineering.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/01-infographic-en.webp)

## Why the Traditional SDLC Breaks Down

![The DORA AI delivery tension: Code throughput accelerates while software instability and review debt escalate without automated verification.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/02-en.webp)
Traditional SDLC models treat software creation like an industrial assembly line where static specifications flow downstream to engineers who translate requirements into syntax. This model breaks down because software development is an iterative learning loop (Observe/Understand -> Experiment/Try -> Recall/Apply), not a predictable manufacturing process. Software design emerges through implementation; you often must write code to discover the correct architecture. When you rely on AI models to jump straight to generated boilerplate, you bypass the "productive struggle" required to internalize deep system context, leaving you with brittle systems and zero durable understanding of your underlying architecture.

Also, while the cost of typing raw code has plummeted to near zero, the cost of delivering _good_ code remains high. Good code must function correctly, handle error and edge cases gracefully, remain minimal, incorporate regression test suites, align with security standards, and afford future architectural changes. Generating hundreds of lines of plausible syntax in seconds does not satisfy these quality standards; it merely transfers the audit workload downstream.

Data from the DORA Q3 2025 research survey, which analyzed 1,110 open-ended responses from Google software engineers over three months, illustrates this operational friction. While AI adoption reached 90% with over 80% of engineers reporting productivity gains, macro-level metrics reveal a critical paradox: higher AI adoption correlates directly with an increase in software delivery throughput alongside a simultaneous increase in software delivery instability. AI acts as an amplifier, accelerating technical debt generation in organizations with fragile infrastructure or poor test suites.

This instability is driven by the "verification tax." According to DORA research, 30% of developers report low or no trust in AI-generated code. Because non-deterministic models cannot signal uncertainty, they produce hallucinations with high confidence. The time you save writing initial code is immediately re-allocated into auditing outputs, fine-tuning prompts, and managing reviewer cognitive load. Authors can churn out massive pull requests instantly, but human reviewers face a severe cognitive bottleneck auditing every line for subtle bugs and hollow documentation.

## The 10/90 Rule: An Agent is a Model Plus a Harness

![Agent architecture anatomy: The foundation model represents 10% while 90% of production reliability depends on the surrounding harness.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/03-en.webp)
When an agent fails to perform a task correctly, your initial impulse might be to blame the underlying model. In agentic engineering, this is usually a mistake. An agent is 10% model and 90% harness. The model functions merely as the engine; the harness provides the chassis, steering, road infrastructure, and traffic laws. Most agent failures are configuration failures in the harness, caused by missing tools, vague rules, absent guardrails, or cluttered context windows.

The harness consists of everything surrounding the LLM engine: system instructions, repository rule files (such as `AGENTS.md`, `CLAUDE.md`, or `GEMINI.md`), Model Context Protocol (MCP) servers, execution sandboxes, deterministic hooks that execute code at set points, orchestration logic that spawns sub-agents, model routing, and observability suites that track execution drift. Because models will inevitably be swapped out underneath your system over time, building a reliable, version-controlled harness is where your true engineering use lies.

Empirical benchmark data validates this architectural division. On the Terminal Bench 2.0 benchmark, one engineering team moved a coding agent from outside the top 30 into the top 5 by modifying only the harness while keeping the underlying model identical. In a separate experiment, LangChain achieved a 13.7-point increase on the same benchmark by adjusting only the system prompts, tools, and middleware surrounding a fixed model. Neither effort touched model weights or training data.

You can operationalize this harness-first workflow directly from your terminal. Command-line interface tools allow you to configure agent workspace rules, register Model Context Protocol (MCP) server endpoints, wire up evaluation datasets, and establish deployment targets (such as Agent Engine) before initiating lifecycle tasks:

```bash
# Example: Initializing agent harness capabilities and executing lifecycle tasks
uvx google-agents-cli setup

# Prompting the configured agent via terminal interface:
> Build a support agent that answers questions from our docs.
> Evaluate it on the FAQ dataset.
> Deploy it to Agent Engine.
```

## Why vs. How Loops: Positioning Engineers "On the Loop"

![The Why Loop and How Loop framework: Humans drive intent and outcomes while positioning themselves on the loop to govern agent harnesses.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/04-en.webp)
To understand your role in the new lifecycle, you must separate software development into two distinct operational loops: the **Why Loop** and the **How Loop**. The Why Loop is driven exclusively by humans; it represents the iterative process of turning business ideas into user value and evaluating software outcomes. The How Loop encompasses the creation and management of intermediate artifacts, including raw code, unit tests, architecture decision records, and infrastructure configs,used to deliver that outcome.

When you position yourself **outside the loop** (pure vibe coding), you hand the entire How Loop over to AI agents without structural guardrails. While this allows rapid initial prototyping, it quickly produces overly complex, unmaintainable spaghetti code. Because agents operating without architectural constraints generate redundant abstractions, they cause context windows to spiral, increasing latency, execution failures, and cloud infrastructure costs.

Conversely, remaining **in the loop** positions you as a manual gatekeeper within the innermost code generation cycle. In this mode, you micromanaging every line of generated syntax, reviewing PRs manually or editing broken outputs by hand. This approach creates a severe engineering bottleneck; humans cannot manually inspect code as fast as agents generate it, neutralizing any initial velocity gains achieved during creation.

The optimal engineering position is **on the loop** through Harness Engineering. Instead of manually fixing one-off generated code artifacts, you "shift left" by designing, executing, and continuously tuning the automated harness, rules, and test suites that guide agent execution. When an agent produces flawed output, an "on the loop" engineer does not edit the file by hand; you update the harness instruction or test check. This triggers an agentic flywheel, where every harness improvement systematically elevates code generation quality across your entire team.

## How Each Phase of the SDLC Actually Changes

![The five redesigned phases of the software development lifecycle when orchestrating autonomous coding agents.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/05-en.webp)
AI compresses the software development lifecycle, but it does so unevenly. Implementation time drops from weeks to hours, whereas requirements gathering, architectural design, and verification stay slow because they demand human judgment. Because implementation is no longer your main constraint, specification quality becomes your primary bottleneck, and verification shifts to the center of your daily workflow.

During **Requirements**, static product requirements documents (PRDs) are replaced by interactive conversations with agents that generate formal specifications and working prototypes simultaneously. **Architecture** remains stubbornly human. Fundamental engineering trade-offs (such as balancing consistency against availability under the CAP theorem) cannot be offloaded to models that lack broader business context. Your role is to define and document these structural decisions so agents can execute within those boundaries.

During **Implementation**, your role transforms from syntax author to code reviewer. Macro adoption metrics reflect this baseline shift: 85% of professional developers use AI coding agents regularly, 51% use them daily, and roughly 41% of all new code is AI-generated. However, velocity metrics show clear nuance. While industry surveys cite productivity gains of 25% to 39%, empirical studies by METR demonstrate that experienced developers actually move 19% slower on complex tasks due to verification overhead.

This slowdown is driven by the "80% problem." Agents rapidly solve the initial 80% of a task consisting of standard boilerplate and predictable patterns. However, because developers are bypassed during that initial construction phase, you are immediately thrust into evaluating the final, highly complex 20% (containing edge cases and integration seams) without having gained system context through the productive struggle of building the foundation.

**Testing & QA** flips completely. Rather than writing tests after implementation, your tests and evaluations become the primary prompt mechanism to define "correctness" for the agent. In **Maintenance**, agents eliminate historical risk. Legacy codebases previously deemed "too risky to touch" because original authors left can now be safely analyzed, refactored, and modernized by agents enforcing automated test suites.

## Verification: The Boundary Line Between Vibe Coding and Engineering

![Comparing Output Evaluation and Trajectory Evaluation when verifying coding agent outcomes and intermediate reasoning paths.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/06-en.webp)
The precise boundary line separating loose vibe coding from rigorous software engineering is verification. Vibe coding relies on visual inspection or trusting an agent's initial output based on a single successful execution. Agentic engineering requires establishing a dual verification framework composed of deterministic testing and non-deterministic evaluations.

Deterministic verification handles traditional binary logic: given input X, the system must produce exact output Y. Unit tests, static analysis, and integration suites enforce these boundaries. However, because AI agents output non-deterministic code and reasoning paths, deterministic tests alone are insufficient. You must implement evaluation rubrics ("evals") designed specifically to measure model behavior across non-deterministic outputs and complex task trajectories.

Evaluations must be split into two distinct categories: Output Evaluation and Trajectory Evaluation. Output evaluation checks whether the final artifact satisfies functional requirements. Trajectory evaluation audits the step-by-step path the agent executed to reach that output, including its tool calls, shell commands, and reasoning logic.

Trajectory evaluation is critical for catching hidden operational failures. For example, consider an agent executing an API write operation that times out. Output evaluation might show a successful final payload, but trajectory evaluation reveals whether the agent inspected system state before retrying or blindly repeated the write call, risking duplicate database records or duplicate customer emails.

To maintain production stability, you must adhere to a strict operational principle: set the bar at the eval, not the demo. A working demonstration proves only that an agent succeeded on a single happy path once under controlled conditions. A comprehensive evaluation suite (run against concrete rubrics and edge-case datasets) proves that your agent harness operates reliably in production environments.

## The Economics: The OpEx Trap and Context Engineering Levers

![CapEx versus OpEx cost curves comparing short-term vibe coding with disciplined agentic engineering over the software lifecycle.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/07-en.webp)
Evaluating the economics of AI-driven development requires looking beyond initial velocity to examine total cost of ownership (TCO). Organizations that adopt unstructured vibe coding fall into the "OpEx Trap." Vibe coding appears inexpensive initially because upfront setup requires only a basic subscription and raw prompting. However, past a brief usage threshold, vibe coding costs 3x to 10x more per feature due to token burn from iterative error correction, high maintenance debt on unscripted code, and continuous security cleanup.

Agentic engineering requires a higher upfront operational investment in structured schemas, harness configurations, test suites, and context architectures. Once established, however, it dramatically lowers your long-term cost per feature. Context engineering functions as your primary financial lever to control token expenditure and maintain high signal-to-noise ratios across agent executions.

Context architecture must be split into static and dynamic context boundaries. Static context is reloaded on every turn; it includes system instructions, repository rule files (such as `AGENTS.md` or `CLAUDE.md`), global memory, and core guardrails. While static context guarantees reliable instruction compliance, it incurs a high cumulative token cost on every API call. Dynamic context loads on demand, fetching matching tool results, RAG documentation, or specific agent skills only when triggered by task parameters.

To scale dynamic context efficiently without overloading context windows, you should implement Agent Skills using progressive disclosure. Under this technical pattern, the agent loads lightweight skill metadata (name and trigger description) into memory at startup. Only when a task matches that specific metadata does the agent fetch the full system instructions for that skill. Heavy reference documentation and schema definitions are retrieved on demand later in execution if required. Combined with model routing—where complex architectural reasoning is sent to high-capacity models while routine tasks (such as CI checks, test generation, and boilerplate reviews) are offloaded to smaller, low-cost models—you eliminate the "orchestration tax" and keep operational execution costs under control.

## The Feedback Flywheel: Compounding AI Productivity for Teams

![The software engineering Feedback Flywheel: Harvesting four operational signals to continuously harden shared team harnesses.](https://camnangai.com/articles/vong-doi-phat-trien-phan-mem-moi/08-en.webp)
Most engineering teams reach a plateau with AI tools because individual learnings remain isolated. When you discover an effective prompt constraint or catch an agent using a deprecated API, that knowledge usually stays in your head. To compound productivity across your organization, you must systematically harvest signals generated during AI interactions and feed them back into shared repository artifacts.

Your daily AI interactions generate four distinct types of operational signal:

- Context signal: tracks gaps in system documentation or outdated dependencies, such as an agent defaulting to a deprecated API version because the repo priming file lacked explicit version boundaries.
- Instruction signal: captures specific prompt constraints and phrasing structures that consistently yield superior, highly maintainable code.
- Workflow signal: records multi-step execution sequences, task decomposition patterns, and playbooks that reliably yield production-ready outcomes.
- Failure signal: analyzes root-cause analysis on bad agent outputs to determine whether an issue stems from missing context, incomplete instructions, or a fundamental model boundary.

Harvesting these signals requires establishing four operational cadences within your development workflow:

1. **After each session:** pause briefly a brief reflection before closing your editor. Ask yourself if anything in the session should alter a shared rule file, immediately updating project guidelines or logging observations.
2. **Daily stand-ups:** you and your teammates briefly share prompt or harness discoveries from the previous day, converting individual intuition into team-wide context.
3. **Sprint retrospectives:** the team formally evaluates recurring friction points, updating shared execution commands, priming docs, and guardrail configurations.
4. **Quarterly audits:** your team conducts quarterly audits to prune outdated rule files and optimize active harness configurations against evolving model capabilities.

Persisting these signals directly into repository artifacts—such as committing updates to `.lattice/learnings/` or project `AGENTS.md` files—ensures that subsequent agent sessions automatically inherit past engineering lessons. To measure whether your feedback flywheel is functioning effectively, stop tracking output volume like lines of code generated. Instead, track quality-centric leading indicators: first-pass acceptance rate, reduction in back-and-forth iteration cycles, post-merge rework volume, and alignment with architectural principles.

## The Engineer's Evolution: From Syntax Coders to Conductors and Orchestrators

Your daily role as an engineer is splitting into two operational modes: the **Conductor** and the **Orchestrator**. As a conductor, you operate synchronously inside the IDE, steering real-time model interactions keystroke-by-keystroke during exploratory spikes or unfamiliar code paths. As an orchestrator, you operate asynchronously, delegating complex technical goals to multi-agent swarms coordinated via open standards such as the Model Context Protocol (MCP) for tool execution and Agent-to-Agent (A2A) protocols for inter-agent communication.

AI tools act as an amplifier: they accelerate well-structured engineering practices just as quickly as they compound technical debt in fragile environments. Writing raw syntax has become cheap, but engineering excellence has not. Navigating this shift requires investing your effort where it matters most—building explicit specifications, maintainable harness architectures, and rigorous trajectory evaluation suites.

## References

- [The New Software Lifecycle — O'Reilly Radar](https://oreillyradar.substack.com/p/the-new-software-lifecycle)
- [The New Software Lifecycle — Addy Osmani](https://addyosmani.com/blog/new-sdlc-vibe-coding/)
- [Humans and Agents in Software Engineering Loops — Martin Fowler](https://martinfowler.com/articles/exploring-gen-ai/humans-and-agents.html)
- [Balancing AI Tensions: Moving from AI Adoption to Effective SDLC Use — DORA](https://dora.dev/insights/balancing-ai-tensions/)
- [Feedback Flywheel: Compounding Improvements in AI-Assisted Development — Martin Fowler](https://martinfowler.com/articles/reduce-friction-ai/feedback-flywheel.html)
- [Writing Code is Cheap Now — Simon Willison](https://simonwillison.net/guides/agentic-engineering-patterns/code-is-cheap/)
- [The Learning Loop and LLMs — Martin Fowler](https://martinfowler.com/articles/llm-learning-loop.html)
