Chapter 5: Development Process Reconstruction

Agent-oriented software engineering shifts the development focus from “writing code” to “describing requirements”, with the core contradiction changing from interpersonal communication costs to requirements precision. The three-phase closed loop of “requirements authoring → Agent execution → value verification” compresses iteration cycles from weeks to hours, transforming humans from coders to requirement architects and Agent commanders.

1 Why Processes Must Be Reconstructed

When AI Agents evolve from auxiliary tools to execution subjects, the fundamental contradiction of software development also shifts. The core pain point of traditional agile processes lies in “communication costs in collaboration”—requirements pass from business to product managers, then to technical teams, with information loss and understanding deviation at every step. In the Agent-Oriented paradigm, this contradiction transforms into a problem of “requirements precision and consistency”—as long as requirements can be clearly and unambiguously expressed, AI Agents can faithfully translate it into runnable software, with communication costs almost reduced to zero.

This fundamental shift in contradiction determines that processes must be redesigned around new core elements. Traditional agile processes are built around “people” and “collaboration between people”—every ceremony, from requirements review meetings to daily standups to iteration retrospectives, is designed to facilitate information synchronization and consensus building among team members. However, in agent-oriented software engineering, the execution subject becomes the AI Agent, and process design logic must shift to ensuring that “requirements can be correctly understood, strictly executed, and effectively validated.” This means we need a completely new process framework, reorganizing development activities around the lifecycle of “requirements”—from definition, decomposition, execution to validation.

2 Comparison of Old and New Processes

Agile Development Process Review

Core Characteristics of Scrum Agile Process: Operating on fixed 2-4 week iteration cycles, managing requirements through Product Backlog, relying on ceremonies such as daily standups, sprint reviews, and retrospectives to facilitate team synchronization. The process is human-centric, with requirements passing from business stakeholders → product managers → development teams, where information loss easily occurs. Coding, testing, and reviews all require manual execution at each step, resulting in high communication costs and iteration pace limited by human working hours and context-switching efficiency.

Agent-Oriented Development Process

Core Characteristics of Agent-Oriented Software Engineering: Evolving from a “pure manual chain” to a “human-machine collaborative closed-loop system. Product managers transform into “prompt engineers,” responsible for defining product vision and boundaries, converting ambiguous requirements into high-quality instructions that intelligent agents can understand. Coding Agents handle 80%+ of foundational coding and testing work, while engineers shift from “writing code” to “reviewing code,” focusing on architectural design and core logic review. Ops Agents autonomously execute deployment, gray releases, and self-healing, with humans acting only as the “last line of defense” for兜底. Data and experience from requirements → development → operations are rapidly fed back and accumulated through Agents, forming a continuously evolving automation flywheel.

3 Detailed Comparison of Process Steps

4 Core Process Steps of Agent-Oriented Development

Requirements Authoring

Three Tightly Connected Phases:

Phase 1: Product Manager Defines Product Requirements. The product manager authors structured business requirements (Why) and product requirements (What), clarifying “why we are doing this” and “what to achieve.” The clearer the requirement boundaries, the higher the Agent execution efficiency.

Phase 2: Agent Understanding and Requirements Clarification. The Agent proactively analyzes requirement boundaries and potential ambiguities, requesting clarification from the product manager when necessary. For example: “Badge color suggestion is gold to convey exclusivity—should we use brand color #FFD700?”

Phase 3: Technical Requirements Emerge Iteratively. Technical requirements are formed progressively during development: the Agent generates technical solutions based on clarified product requirements; the Agent Engineer reviews and provides feedback; the Agent optimizes based on feedback, identifies dependencies and conflicts, and forms final technical requirements.

Why “Emergent” Rather Than “Preset”?

In traditional development, technical solutions must be fully determined before coding. In AOSE, technical requirements “emerge” through human-machine dialogue—the Agent generates preliminary solutions, humans propose constraints on key design points, and the Agent optimizes based on feedback. Advantages:

• Reduces upfront cognitive burden: No need to enumerate all technical details at the start
• Leverages Agent’s global analysis capability: Agents can quickly evaluate multiple technical solutions
• Rapid response to requirement changes: Technical solutions can flexibly refactor when product requirements adjust

Agent Execution

Purpose: Coding Agent autonomously completes development tasks based on requirements

Current Model (IDE Era):

Currently mainstream coding Agents (such as Cursor, Windsurf, etc.) exist as IDE plugins. Humans interact with Agents through natural language instructions, and Agents have multiple built-in capability modules (code generation, refactoring, testing, debugging, etc.), automatically selecting appropriate capabilities to execute tasks based on instructions.

Workflow:

flowchart LR
    A[Human Instruction] --> B[Agent Analysis]
    B --> C[Requirement Clarification]
    C --> D[Technical Design]
    D --> E[Task Decomposition]
    E --> F[Code Implementation]
    F --> G[Human Verification]

    style A fill:#e8f5e9,stroke:#333,stroke-width:2px
    style G fill:#fff3e0,stroke:#333,stroke-width:2px

Key Activities: After receiving requirements, the Agent completes Requirement Analysis (identifying ambiguities, clarifying with humans when necessary), Technical Design (generating solutions for human review), Task Decomposition (determining execution order), Code Implementation and Unit Testing (coding, debugging, generating tests, self-diagnosing and repairing failures), End-to-End Testing (developing test cases, preparing data, verifying functionality), and Result Delivery (submitting code, tests, and documentation). The entire process forms a development-test closed loop with the Agent autonomously handling most work, humans only monitoring key decision points.

Agent Self-Review and Iteration Mechanism:

sequenceDiagram
    participant H as Human Commander
    participant A as Coding Agent

    H->>A: 1. Input requirements document

    opt Requirement Clarification (Optional)
        A->>A: Analyze requirements, identify ambiguity
        alt Requirement has questions
            A->>H: Request clarification
            H-->>A: Provide answer
        else Requirement clear
            A->>A: Complete requirement analysis
        end
    end

    opt Technical Solution Confirmation (Optional)
        A->>A: Generate technical solution
        A->>H: Submit solution for review
        alt Solution needs adjustment
            H-->>A: Feedback modification suggestions
            A->>A: Optimize technical solution
        else Solution confirmed
            H-->>A: Approve execution
        end
    end

    A->>A: Decompose development tasks

    loop Coding and Unit Testing Loop
        A->>A: Write code + generate unit tests
        alt Unit test fails
            A->>A: Self-diagnose and repair code
        else Unit test passes
            A->>A: Continue to next step
        end
    end

    A->>A: Develop end-to-end test cases + prepare test data

    loop End-to-End Test Validation Loop
        A->>A: Execute end-to-end tests
        alt Bug found
            A->>A: Return to coding phase for repair
        else Test passes
            A->>A: Validation complete
        end
    end

    A->>H: Submit results (code + tests + data + documentation)

Key Decision Points:

• Requirement ambiguous → Find human for clarification: Agent proactively seeks human confirmation when encountering uncertainty during analysis
• Unit test fails → Self-modify code: Agent autonomously diagnoses test failure reasons and repairs code
• End-to-end test fails → Return to coding phase for repair: Bug repair triggers re-execution of test closed loop

Future Model (Web Era):

As coding Agent capabilities mature, the development interface will evolve from IDE to Web. Humans issue instructions to Agents through Web interfaces, and Agents complete all development work in the cloud. The human role completely shifts from “code writer” to “Agent commander and coordinator”:

• Coordinate multi-Agent collaboration: When involving multiple system modules, coordinate different Agent instances to work in parallel
• Conflict resolution: Handle Agent dependency conflicts and boundary issues
• Result verification: Review Agent output to ensure it conforms to original requirements
• Quality control: Perform manual confirmation on key design decisions

Deployment & Value Verification

Purpose: Deploy features to production, collect user feedback, and verify business value

Technical Testing Already Completed: In Section 6.4.2 Agent Execution phase, unit tests, end-to-end tests, and code quality checks have all been completed and passed. This phase no longer conducts technical validation, focusing entirely on business value verification.

Participants: Product Manager (leading), Business Stakeholder, Data Analyst

Key Activities:

1. Deployment: Agent automatically completes code merging, building, and release processes
2. User Feedback Collection: Collect user reactions through tracking data, user behavior analysis, and direct feedback channels
3. Business Value Verification: Compare against business goals to verify whether expected results are achieved
4. Rapid Iteration Decision: Based on feedback, decide whether to continue optimizing, roll back, or promote

Value Verification Metrics:

• User Behavior Metrics: Feature usage rate, completion rate, dwell time changes
• Business Goal Metrics: Conversion rate improvement, revenue changes, cost savings
• User Satisfaction: NPS scores, feedback sentiment analysis, customer complaint changes

Outputs:

• Production deployment report
• Comprehensive user feedback analysis
• Business value achievement assessment
• Subsequent iteration recommendations

Key Role Transformations

Product Manager: From PRD Author to Requirements Architect

In traditional models, product managers’ core output is PRD documents describing features through text and prototypes. In AOSE mode, product managers become “Prompt Engineers,” transforming fuzzy business requirements into structured, Agent-understandable requirement specifications. This requires not only deep business understanding but also the ability to accurately translate human language into machine-executable instructions.

Agent Engineer: From Code Writer to Agent Commander

This is a new role born in the AOSE era. Agent engineers don’t need to code line-by-line like traditional engineers. Instead, they:

• Design technical constraints and acceptance criteria: Define boundary conditions for “good code”
• Review Agent-generated technical solutions: Gatekeep at key design decision points
• Handle complex problems Agents cannot solve autonomously: Such as system architecture adjustments, cross-module dependency conflicts
• Continuously optimize Agent execution efficiency: Improve Agent first-attempt success rate by adjusting constraint rules

Ops Engineer: From Passive Response to Active Safety Net

Under Agent-dominated operations:

• Daily Operations: Deployment, gray releases, monitoring alerts, and self-healing are handled autonomously by Ops Agents
• Human Intervention: Only in complex production environments or emergency situations where Agents cannot decide
• Role Shift: From “watching dashboards” to “designing operational strategies and contingency plans”

6 Chapter Summary

Agent-oriented software engineering fundamentally reconstructs the software development process. The core contradiction of traditional agile processes is “interpersonal communication costs,” while AOSE transforms this contradiction into a problem of “requirements precision and consistency”—as long as requirements can be clearly expressed, AI Agents can faithfully translate it into runnable software.

Three-Phase Closed Loop

The essence of AOSE is shifting from “writing code” to “describing requirements,” forming a flywheel of “Requirements Authoring → Agent Execution → Value Verification”:

1. Requirements Authoring & Iteration: Product managers define business and product requirements, Agents proactively analyze and clarify ambiguities, and technical requirements emerge through human-machine collaboration. Technical requirements are “emergent” during development rather than fully preset from the start.

2. Agent Execution: Agents autonomously complete requirement analysis, technical design, code implementation, and test verification. Agents self-diagnose and repair code issues, forming a development-test closed loop with human intervention only at key decision points.

3. Deployment & Value Verification: Agents automatically complete deployment and gray releases. This phase focuses entirely on business value verification—do users truly perceive the new feature? Does behavior data support business assumptions? Have financial indicators improved? Based on data insights, the team plans the next iteration.

Key Transformations

Practical Results

Taking a typical member badge feature development as an example:

• Time Efficiency: Requirements authoring 45 minutes + Agent execution 40 minutes + deployment 5 minutes = Completed from requirements to production within 1.5 hours
• Human Distribution: Product manager-led requirements authoring (67% time), Agent engineer monitoring execution (11% time), production validation (22% time)
• Quality Results: Code coverage 87%, interface response 10ms, zero-fault production launch
• Business Value: Renewal rate +3%, NPS +3 points, estimated annual revenue increase 1.5M

Process Essence

The essence of the AOSE process is shifting the focus of software development from “how to write code” to “how to describe requirements.” When Agents can translate requirements into code with extremely high efficiency, the true value of humans lies in:

1. Precisely describing business requirements: Letting Agents understand “why do” and “what to achieve”
2. Designing effective validation methods: Ensuring the ability to measure achievement of business goals
3. Continuous optimization based on data: Transforming verification results into next-round requirements input

The process is no longer about managing “people’s work,” but managing “the flow of requirements”—from business requirements to product requirements, from technical requirements to runnable software, from user feedback to new business requirements. The faster this flow, the stronger the organization’s innovation capability.