Technical Summary: Agentic Agile-V: From Vibe Coding to Verified Engineering

1. Problem Statement

The paper identifies a critical gap in the current adoption of Agentic AI for software, firmware, and hardware development. While autonomous agents can inspect repositories, plan tasks, edit files, and submit pull requests, evidence suggests that autonomous code generation does not automatically improve engineering outcomes.

Key challenges identified include:

• Context-Dependent Productivity: While randomized controlled trials (RCTs) show productivity gains in specific enterprise tasks (e.g., a 21% reduction in time for Google engineers), other studies report slowdowns (e.g., a 19% increase in task completion time for experienced open-source developers in mature repositories).
• Verification Debt: Agentic AI can generate code faster than humans can verify it. This leads to "verification debt," characterized by weak tests, hidden regressions, and increased reviewer burden, which can erase perceived speedups.
• Hardware Reliability: In hardware and firmware domains (e.g., Verilog generation), current models show low pass rates on system-level tasks and fail to reliably handle functional verification, timing, and safety constraints.
• The "Vibe Coding" Trap: Relying on conversational prompts ("vibe coding") is insufficient for implementation. Chat histories contain superseded assumptions, implicit constraints, and non-executable acceptance criteria, making them unreliable engineering contracts.

The core problem is not a lack of prompt engineering capability, but a lack of engineering process control. The bottleneck has shifted from code synthesis to specification quality, execution context, and verification.

2. Methodology

The paper employs a bounded evidence synthesis rather than a quantitative meta-analysis. This approach was chosen because the evidence base is heterogeneous, comprising:

• Randomized controlled trials (e.g., Google, METR).
• Large-scale GitHub datasets (e.g., AIDev, task-stratified pull request analysis).
• Repository configuration and execution environment studies.
• Hardware and firmware verification benchmarks (e.g., RealBench, FIXME).

The synthesis integrates findings from agentic software engineering surveys, productivity studies, repository-configuration research, and hardware benchmarks to propose a process framework. The paper explicitly avoids pooling these diverse sources into a single effect size, arguing that doing so would obscure the specific process problems.

3. Key Contributions: The Agentic Agile-V Framework

The paper proposes Agentic Agile-V, a process framework designed to convert conversational intent into structured engineering artifacts and acceptance evidence. It consists of two layers:

A. Macro Layer: Agile-V Lifecycle

This layer combines Agile iteration with the V-model's verification and audit artifact generation. It ensures that every increment remains traceable to requirements, design, implementation, verification, and approval.

B. Micro Layer: The SCOPE-V Task Loop

This is a six-step execution loop for individual agentic tasks:

1. Specify: Convert intent into a task brief (objective, scope, non-goals, dependencies, acceptance criteria, required evidence).
2. Constrain: Define boundaries (e.g., no public API changes without approval, no new dependencies without justification, preservation of hardware timing).
3. Orchestrate: Direct the agent to inspect, summarize, plan, implement in small slices, run local checks, and produce a diff summary.
4. Prove: Require specific evidence based on risk (unit/integration tests, static analysis, simulation, formal checks, hardware-in-the-loop results).
5. Evolve: Feed validated learning back into repository instructions and baselines; remove stale instructions.
6. Verify: Treat verification as recurring (pre-implementation, during patching, pre-merge, post-deployment).

C. Core Mechanisms

• Conversation-to-Contract Gate: A mandatory separation between exploratory dialogue (discovery) and structured execution (implementation). Agents must implement from a reviewed brief, not a long chat history.
• Minimum Input Artifact Model: A taxonomy of required inputs (Table I) to prevent agents from guessing. This includes intent, acceptance criteria, architecture context, constraints, execution context (build commands, toolchains), and evidence requirements.
• Risk-Adaptive Acceptance Gates: A four-level classification (R0–R3) determining the rigor of evidence required:
  • R0 (Exploratory): Optional review, smoke tests.
  • R1 (Routine): Normal code review, targeted tests.
  • R2 (Production): Mandatory reviewer approval, regression tests, CI, security checks.
  • R3 (High Assurance): Explicit sign-off, independent tests, simulation/formal/HIL evidence, audit artifacts.

4. Results and Evidence Synthesis

The paper synthesizes existing evidence to support its framework:

• Productivity Variance: Evidence confirms that AI assistance helps in well-scoped or routine tasks but creates overhead in mature, complex codebases due to review and correction cycles.
• Configuration Impact: Repository configuration files (e.g., AGENTS.md) can reduce runtime and token usage, but mismatched or excessive context files can reduce task success and increase costs.
• Execution Bottlenecks: Real-world repository tasks often fail due to environment setup and dependency resolution rather than code generation logic. Agents require explicit execution context (build commands, test suites, simulator access).
• Hardware Limitations: Current LLMs struggle with system-level hardware generation and functional verification, necessitating stricter human oversight and evidence bundles (simulation logs, formal properties).

5. Significance and Claims

The paper claims that Agentic AI does not eliminate engineering discipline; it increases the value of requirements, constraints, traceability, independent verification, and human approval.

• Shift in Focus: The central problem is no longer "How do we prompt better?" but "Which process turns natural-language intent into verifiable engineering output?"
• Verified Engineering: The future of agentic engineering is not "vibe coding at scale" but "verified engineering with agents inside the loop."
• Practical Utility: The framework provides a actionable path for teams to adopt agentic tools without accumulating verification debt. It offers specific templates for feature briefs, bug briefs, and hardware/firmware briefs, and defines clear evidence bundles for acceptance.

The paper concludes that while agentic AI is an operational phenomenon, its successful integration requires a process that separates discovery from implementation and mandates evidence appropriate to the risk level of the task.