From AI Code Generation to Execution: How Agents Are Redefining Software Delivery

Background: From Code Completion to Agent‑Driven Execution

Recent advances in AI‑assisted development have moved beyond simple code completion (referred to as AI Coding 2.0 ) toward agents that can act asynchronously, forming a generate‑validate‑rollback loop. The shift changes the responsibility for software delivery from a human‑centric process to an automated system that must be explicitly governed.

Case Study: Adding an Agent to a Kanban Module

When extending the open‑source project Routa (GitHub: https://github.com/phodal/routa) with a Kanban board, the initial task was to define columns, enable drag‑and‑drop, and synchronize state. Introducing an agent that reacts to column changes turned the board into a decision‑making control plane. The agent required explicit rules for:

When a card may move between columns.

Whether unfinished steps block progression.

How to handle execution failures (pause, retry, or rollback).

These rules, previously implicit in human communication, must be formalized because agents cannot interpret vague context.

AI Coding 2.0 vs. AI Coding 3.0

AI Coding 2.0 focuses on improving the generation capability of models: richer context, better prompts, and post‑generation safeguards such as testing, linting, building, and rollback. The goal is higher output quality.

AI Coding 3.0 shifts the focus to execution. The system must answer fundamental questions:

When should an agent run?

Is the current state eligible for advancement?

What is the retry or rollback policy on failure?

How can the entire pipeline be trusted and verified?

These concerns belong to the execution layer rather than the generation layer.

Harness Engineering: From “Can Do” to “Provably Can Do”

In 2.0, testing, linting, and building are auxiliary checks. In 3.0 they become integral constraints that the execution engine must satisfy before proceeding. Harness Engineering provides a set of enforceable constraints that turn experiential judgments into verifiable engineering actions, enabling the system to prove that a step is safe to execute.

Kanban as a Control Plane

The Kanban board evolves from a visual status display to a control surface that drives decisions:

Columns become state‑machine nodes.

Cards become executable units (tasks).

Transitions become conditional state changes governed by gates (policy checks).

All three—state definition, flow paths, and gate conditions—must be aligned in a single unified model; otherwise agents may act on inconsistent information.

Unified Model for State, Flow, and Validation

A unified model defines:

State   = { column, allowed_transitions, entry_conditions }
Flow    = { source_state -> target_state | guard }
Gate    = { validation_rule, pass/fail_action }

Every transition is permitted only if the associated gate validates the current context. Harness supplies the validation implementation; the Kanban board supplies the orchestration (when to invoke which gate).

Orchestration and Constraints in Multi‑Agent Collaboration

Two capabilities are essential for reliable multi‑agent systems:

Orchestration : decides execution order and timing based on the Kanban control plane.

Constraints : prevents illegal states by enforcing gate outcomes via Harness.

Without both, automation may increase throughput but reduces predictability.

From “Can Complete” to “Can Be Proven to Complete”

AI Coding 3.0 treats software delivery as a system problem. Each step must be:

Bounded (explicit pre‑conditions).

Verified (gate passes).

Justified (audit trail of validation results).

This transforms the delivery pipeline into a discipline that can be reasoned about mathematically.

Conclusion: Collaboration Becomes System Behavior

When agents are part of the workflow, collaboration is no longer a human activity but a system behavior that must be defined, constrained, and verified. The combination of a Kanban control plane, Harness Engineering constraints, and autonomous agents creates a provably correct execution system for software engineering.