Chapter 1: What is Agent-Oriented Software Engineering

As AI agents become the actual producers of code, the core contradiction of software development has shifted from “how to write code” to “how to schedule agents.” Humans transform from coders to schedulers and constraint definers, with core value returning to defining “what to do” and “why to do it.”

1 A Core Proposition

Software engineering is undergoing a profound paradigm shift. In the future, software development will no longer be a craft centered around code, but an entirely new engineering paradigm—Agent-Oriented Software Engineering (AOSE).

The core of this transformation lies in: Agents are becoming the center of software production. In traditional software development, human programmers are the direct producers of code; in the AOSE paradigm, LLM agents become the actual generators of code, while humans transform into schedulers and constraint definers for agents.

To better understand the revolutionary significance of this paradigm, we can compare it with another major paradigm shift in software engineering history—Object-Oriented Programming (OOP). The essence of OOP is to reduce programming complexity, helping human developers manage increasingly complex code structures through mechanisms like encapsulation, inheritance, and polymorphism, making it easier for “humans to understand code.” The essence of Agent-Oriented Software Engineering, however, is the disruptive change brought to software engineering by the enhanced capabilities of LLM agents—when AI agents can transform human requirements into executable code with high efficiency, the core contradiction of software development has shifted from “how to help humans write and understand code better” to “how to help humans schedule agents more effectively and have agents implement efficiently.”

It is important to emphasize that this is not a replacement manifesto aimed at programmers, but a profound re-examination of the essence of software engineering itself. When AI agents can already handle the technical details of “how to do” (How) efficiently, human core value will inevitably return to a more fundamental level—defining “what to do” (What) and understanding “why to do it” (Why).

When AI agents can efficiently execute “how to do,” human core value will return to “what to do” and “why to do it.”

It is important to further emphasize that the complexity of software engineering has not disappeared—it has only shifted. LLM agents are like code generation engines with unlimited horsepower—if you install one in a vehicle without a steering wheel or brakes, it will only pile up a “mountain of spaghetti code” for you at extreme speed. To use agents to build robust, large-scale software systems, human developers must transform their role from “bricklayers” (writing code) to schedulers (directing), architects (defining boundaries), and supervisors (verifying quality). This transformation is not an evasion of software engineering complexity, but a redistribution of complexity and an upgrade in how it is managed.

2 Agents: The Core of Transformation

In Agent-Oriented Software Engineering, agents are the true core of this transformation. Agents are not just code generation tools, but software entities with autonomy, goal orientation, and environmental awareness.

Essential Characteristics of Agents

Autonomy: Agents can make autonomous decisions and execute tasks based on goals, without requiring step-by-step human guidance
Goal Orientation: Agents are oriented toward completing specific goals, able to understand task intent and plan implementation paths
Environmental Awareness: Agents can perceive contextual information such as development environments, codebase status, and team standards
Collaboration Capability: Multiple agents can work together, dividing labor and cooperating to complete complex tasks

The Role of Agents in Software Production

In the AOSE paradigm, agents participate in various aspects of software production in multiple forms. These agents are not merely functional tools, but collaborative partners with different capabilities and interaction methods:

1. Integrated Development Environment Agents (IDE Agents)

These agents are deeply integrated into development environments, capable of understanding code context and providing real-time assistance:

Cursor: As a new generation of AI-native IDE, Cursor deeply integrates agents into the coding experience. It can understand the context of entire projects, perform cross-file code modifications, and even refactor entire codebases based on natural language descriptions. The core capabilities of Cursor agents lie in context awareness and large-scale code operations.
Windsurf: An agent specialized in code generation, particularly adept at generating compliant code based on existing code patterns and team standards. The characteristics of Windsurf agents are pattern recognition and standard compliance, able to learn team coding styles and maintain consistency.
Claude Code: As an agent in command-line tools, Claude Code demonstrates how agents can complete complex development tasks without relying on graphical interfaces. It understands development intent through natural language interaction, performing tasks such as file operations, code generation, and test execution, embodying task orientation and automated execution capabilities.

2. Platform Agents

These agents provide more complete development platforms, supporting end-to-end software development processes:

Kiro: As a complete development platform, Kiro connects requirements, design, development, testing, and deployment through agents. The core value of Kiro agents lies in process integration and specification-driven development—it can automatically transform structured requirement specifications into executable development tasks and coordinate multiple agents to collaborate on completion.
Replit: Agents in cloud development environments, providing one-stop services from idea to deployment. Replit agents are particularly skilled at rapid prototyping and collaborative development, lowering the barrier to software development.

Common Characteristics of Agents

Despite their varied forms, these agents share the following common characteristics:

Context Understanding: Ability to understand contextual information such as codebases, project structures, and team standards
Autonomous Execution: Ability to autonomously plan and execute tasks after clear goals are defined
Continuous Learning: Ability to learn from historical tasks, continuously improving execution efficiency and quality
Collaboration Capability: Multiple agents can work together, dividing labor to complete complex tasks

In the AOSE paradigm, human developers no longer need to master all technical details, but need to learn to select appropriate agents, define clear tasks, set reasonable constraints, and validate agent outputs. This transformation shifts developers’ core competencies from “coding implementation” to “agent scheduling and quality management.”

Transformation of Human Roles

As agents become the core of software production, human roles undergo fundamental changes:

From Coders to Schedulers: Humans no longer personally write every line of code, but schedule agents to complete coding tasks
From Implementers to Constraint Definers: Human’s main work becomes defining behavioral boundaries and constraint conditions for agents
From Executors to Validators: Humans are responsible for verifying whether agent-generated results meet expected goals

This transformation is not a negation of human value, but a repositioning of human value—liberating humans from repetitive technical implementation to focus on higher-level creative work.

3 Paradigm Comparison: Agent-Oriented vs. Code-Oriented

To more clearly understand the transformation brought by Agent-Oriented Software Engineering, let us compare it comprehensively with traditional code-oriented development:

Dimension	Code-Oriented (Traditional Paradigm)	Agent-Oriented (Emerging Paradigm)
Core Activity	Developers spend significant time writing, debugging, and optimizing code	Primary effort invested in scheduling agents, defining constraints, and validating results
Human-Machine Division of Labor	Humans responsible for writing code, machines only responsible for compilation and execution	Humans focus on scheduling agents, agents responsible for generating specific code
Mental Focus	Focused on How—how to implement a feature or solve a technical problem	Focused on What & Why—what functionality is needed, why this feature is being built
Output Form	Code files as primary output, documentation often lagging or missing	Agent scheduling instructions and constraint definitions become core assets, code automatically generated by agents
Validation Method	Relies on manual testing and Code Review to ensure quality	Ensures implementation meets expectations through agent output validation and automated testing

The profound nature of this paradigm shift lies in the fact that it is not merely a tool upgrade, but a fundamental redefinition of software engineering itself. In the agent-oriented era, code is no longer the center of engineering activities, but the product of agents executing tasks—just like products on a factory production line, code is “produced” by agents.

4 A Vivid Analogy

If we were to use a vivid analogy to understand the difference between these two paradigms, factory production might be a good comparison.

Traditional software development is like artisanal workshop production:

Each artisan (programmer) needs to master the full set of skills from raw material processing to finished product creation
Artisans spend significant time on repetitive basic operations such as cutting, polishing, and assembly
Product quality highly depends on the personal skills and experience accumulation of artisans
Production efficiency is limited by artisans’ working hours and physical limits

This approach can produce personalized products but struggles to achieve scale production and places extremely high demands on artisan skills.

Agent-oriented development, on the other hand, is more like modern smart factory production:

Human engineers are responsible for designing product specifications, planning production processes, and setting quality standards
Smart robots (agents) are responsible for executing specific production tasks such as welding, painting, and assembly
Each robot has specific expertise and can efficiently complete tasks assigned to it
Robots automatically coordinate through collaborative systems to ensure smooth production flow

In this analogy, humans shift from “operators” to “engineers,” from personally operating machines to designing and optimizing production systems. This is not just a change in work content, but an upgrade in value creation.

5 Core Characteristics

Agent-Oriented Software Engineering, as an emerging engineering paradigm, has a series of distinctive characteristics that set it apart from traditional development. Understanding these characteristics helps us grasp the essence of this paradigm transformation.

Agents as Producers

Under the AOSE framework, agents become the actual producers of software code. In traditional development, human programmers are the direct writers of code; in the AOSE paradigm, humans transform into schedulers of agents, while agents undertake the specific work of code generation. This transformation is not a simple tool replacement, but a reconstruction of production relations—agents become the core execution units of software production.

Constraints as Guardrails

When agents gain the ability to generate code, how do we ensure they don’t “go off the rails” and generate code that doesn’t conform to team standards or has quality risks? The answer lies in the constraint system. By pre-defining multi-dimensional constraints such as architectural standards, security policies, performance metrics, and complexity ceilings, we establish clear guardrails for agents. These constraints are not limitations on creativity, but guarantees of quality—they ensure that agents remain on the right track while freely exercising their capabilities.

Validation as Driver

In traditional software development, testing is often placed at the end of the development process, playing the role of “quality gatekeeper.” But in the AOSE paradigm, validation is no longer a post-hoc check, but an endogenous component of agent scheduling. Agents automatically generate test cases based on acceptance criteria, and these test cases in turn drive code generation—only code that can pass all tests is considered a valid implementation. This “validation as driver” model embeds quality assurance into every step of development.

Scheduling as Assets

In the AOSE era, a team’s most valuable assets are no longer a specific codebase, but those knowledge components that can be continuously reused and evolved—high-quality agent scheduling patterns, validated constraint rules, and effective collaboration processes. These knowledge assets follow the law of compound interest growth: with every project completed, the team accumulates a batch of reusable scheduling experience; with every complex problem solved, there is one more solution for future reference. As time goes on, the team’s agent scheduling capabilities become increasingly strong, and development efficiency improves exponentially.

6 Why Not Just “AI-Assisted Programming”

People first encountering Agent-Oriented Software Engineering might have this question: Isn’t this what AI programming assistants like GitHub Copilot and Cursor are already doing?

The answer is no. There are essential differences between the two:

Comparison Dimension	AI-Assisted Programming (Current Stage)	Agent-Oriented Software Engineering (Future Paradigm)
Role Positioning	AI acts as “copilot,” assisting humans in completing code writing	AI becomes an independent “executor,” capable of independently completing end-to-end tasks
Task Granularity	Primarily handles line-level or function-level code completion	Capable of understanding and executing task-level or even business-level complex tasks
Human-Machine Relationship	Humans remain the main body of coding activities, AI provides assistance	Humans become the main body of agent scheduling, agents responsible for specific implementation
Code Source	Code primarily written by humans, AI responsible for local completion and optimization	Code automatically generated by agents based on task descriptions, humans responsible for validation and acceptance

We can understand Agent-Oriented Software Engineering as the next evolutionary stage of AI-assisted programming—it marks the leap of software engineering from the “human-machine collaborative coding” model to the “deep human-machine division of labor: humans focus on scheduling agents, agents responsible for execution and implementation” model. This is not just an enhancement of tool capabilities, but a reconstruction of production relations.

7 Chapter Summary

Agent-Oriented Software Engineering (AOSE) represents a completely new software engineering paradigm. Its core ideas can be summarized in the following four points:

Agents are the center of software production—agents become the actual generators of code, undertaking a significant portion of implementation work in traditional development;
Human roles transform into schedulers—humans shift from coders to schedulers and constraint definers for agents, focusing on higher-level creative work;
Constraint systems ensure quality—multi-dimensional constraint conditions establish behavioral boundaries for agents, ensuring the quality and standardization of generated code;
Validation-driven development—using task completion as the core standard for measuring software quality, rather than traditional lines of code or functional coverage.

Among these, agent scheduling capabilities and constraint design capabilities are the core competitiveness of this transformation—teams need to master how to effectively schedule agents to complete complex tasks, and how to design reasonable constraint conditions to ensure generation quality. This transformation is not a distant future, but a reality that is happening now. In the following chapters, we will explore why this transformation is necessary, and how teams should systematically complete this transition.

Reflection Questions

In your current project, how is your daily work time allocated? What proportion is spent on “writing code,” and what proportion on “understanding requirements, analyzing business, and designing solutions”? Is this allocation reasonable?
Assuming that through the introduction of the AOSE paradigm, you could compress “writing code” time by 80%, what more valuable work would you invest the saved time in? Deeper understanding of users, or more systematic thinking about architecture?
Imagine a future work scenario: if your main work is scheduling agents to complete coding tasks, what fundamental changes would occur in your daily work content? What new capabilities do you need to develop to adapt to this change?