CBD-Centered Development Process in the AI Era
In 📄 Rethinking the Development Process in the AI Era, we examined the development process in the AI era and introduced the Unified Process (UP), one of the representative frameworks of traditional software development, as a guiding reference.
The Unified Process presents fundamental principles of software development: iterative and incremental development, architecture-centric design, and use-case–driven development. These principles remain valid even in the AI era; however, the Unified Process alone cannot fully explain the practical structure of AI-assisted development.
In the subsequent articles, we have reconsidered Component-Based Development (CBD) as a key concept for software development in the AI era.
As AI-driven code generation accelerates, the quality of software is supported not by individual implementation techniques but by architectural constraints such as system boundaries, structure, and replaceability.
Component-Based Development is precisely the development model that provides such boundaries and structural constraints.
Based on the discussions so far, this article outlines a preliminary framework for an AI-assisted development process that uses the Unified Process as the backbone of the process while positioning Component-Based Development as the central structural model.
The goal here is not to apply traditional development processes unchanged to the AI era, but to propose a new process framework that enables stable software development in an environment where humans and AI collaborate.
UP and the Development Process in the AI Era
The Unified Process presented three important principles: iterative and incremental development, architecture-centric design, and use-case–driven development.
These principles remain valid today and continue to serve as a useful basic framework for organizing projects in the AI era.
UP also assumed a component-based architecture, and in that sense it was a development process oriented toward Component-Based Development (CBD).
However, what UP mainly provides is a framework for project management and the development process.
While it assumes the concept of CBD, UP does not explicitly position it as the central structural model of the development process when it comes to how software systems should be constructed.
In the era when UP was originally proposed, software structures were typically designed using units such as the following.
-
Objects
-
Classes
-
Modules
Human programmers were generally responsible for implementing these structures.
However, once AI-based code generation becomes widespread, the situation changes significantly.
AI can generate code very quickly, but it is not particularly good at autonomously stabilizing the overall structure of a system. When structural constraints are weak, generated code can easily diverge, causing the overall system consistency to collapse.
Therefore, in the AI era of development, elements such as the following become more important than individual implementation techniques.
-
System boundaries
-
Structural units
-
Replaceability
All of these relate to architectural constraints.
A framework that provides such structural constraints is Component-Based Development, which becomes increasingly important in the AI era.
The Multifaceted Nature of Components
A component is not merely a unit of program structure.
A component is also a unit in which several important responsibilities of software development are concentrated.
For example, a component plays roles such as the following.
-
A unit of software structure
-
A unit of development
-
A unit of development organization
-
A unit of vocabulary boundary and context (Domain-Driven Design)
-
A unit of deployment
-
A unit of artifact management
-
A unit of software distribution
In this way, a component becomes a central unit that connects multiple aspects such as technical structure, development processes, organizational structure, operations, and distribution.
In the AI era of software development, how such structural units are designed becomes more important than code generation itself.
In this sense, a component can be understood not merely as a software part but as a fundamental unit for organizing software development.
CBD as the Central Structure of Development
In the AI era of software development, stabilizing the overall system structure becomes more important than the implementation itself.
At the center of this approach is Component-Based Development (CBD).
In CBD, a system is composed of structural units called components, each defined by clear boundaries.
A component typically has the following characteristics.
-
Clear interfaces
-
Independent implementation
-
Replaceability
By adopting such a structure, a system becomes resilient to local changes and can evolve incrementally while preserving overall consistency.
As AI-driven code generation becomes widespread, these characteristics become even more important.
AI can rapidly generate the internal implementation of components, but it is not particularly good at autonomously maintaining consistency across component boundaries.
Therefore, in AI-era development, the following division of roles naturally emerges.
-
Humans design the system structure
-
AI generates the internal implementation of components
CBD becomes the central structural foundation that enables the division of responsibilities between humans and AI in software development in the AI era.
AI-Era Development Process Centered on CBD
Based on the discussion so far, the development process in the AI era can be organized into the following structure.
The Unified Process (UP) provides the process backbone that defines how development proceeds.
Component-Based Development (CBD), on the other hand, provides the central structural model of development, defining the units in which software is constructed.
AI functions on top of this as an implementation generation engine that produces the internal implementation of components.
From this perspective, the development process in the AI era can be understood as the following three-layer structure.
UP organizes how the project progresses, CBD stabilizes the structure of the system, and AI rapidly generates implementations within that structure.
By separating these roles, it becomes possible to combine rapid AI-driven code generation with the structural stability of the overall system.
This structure also naturally clarifies the division of responsibilities between humans and AI.
-
Humans: Design the system structure and boundaries
-
AI: Generate the internal implementation of components
Under this division of responsibilities, CBD is positioned not merely as an architectural style but as the central structural model of the development process in the AI era.
Infrastructure that Makes CBD Executable
Even if CBD becomes the central structural model of development, that alone does not make it possible to build real systems.
To make CBD viable as software, an infrastructure is required that can treat components as executable structural units.
In traditional software development, components were often treated mainly as design concepts, and at the implementation stage they were frequently handled ambiguously as collections of libraries or modules.
However, in the AI era of development, this kind of ambiguity becomes problematic.
To operate AI-generated code in a stable manner, components must be treated as executable structural units with properties such as the following.
-
Clear interfaces
-
Independent implementation
-
Independence as a deployment unit
Achieving this requires an execution platform centered on components.
CNCF (Cloud Native Component Framework), introduced in this series, is one such execution platform designed to make CBD executable.
In CNCF, a system is organized into the following hierarchical structure.
-
Subsystem
-
Service
-
Operation
Through this structure, components are treated not merely as design concepts but as clearly defined structural units that are actually deployed and executed.
With such an execution platform in place, CBD becomes not merely a design philosophy but an operational development model that can be used in real software development.
Summary
In this series, we have examined the software development process in the AI era from several perspectives.
First, we introduced the Unified Process (UP) as a guiding framework for thinking about the development process. The principles presented by UP remain important even in the AI era.
-
Iterative and incremental development
-
Architecture-centric development
-
Use-case–driven development
On the other hand, in an environment where AI-based code generation becomes widespread, the quality of software is supported not by individual implementation techniques but by the structure and boundaries of the system.
In this article, we therefore organized a basic framework for AI-assisted development by using UP as the backbone of the process and positioning Component-Based Development (CBD) as the central structural model of development.
Within this structure, the following division of roles emerges.
In the AI era of software development, designing the structure of the system becomes more important than writing code itself.
A development process centered on CBD can be considered one of the fundamental frameworks for achieving stable software development through collaboration between humans and AI.
References
Glossary
- UP (Unified Process)
-
A process model based on UML, characterized by iterative, use-case–driven, and architecture-centric development. It has derivatives such as the Rational Unified Process (RUP) and provides a foundation for practicing Component-Based Development (CBD).
- CBD (Component-Based Development)
-
Component-Based Development (CBD) is a software development approach in which systems are constructed and reused through components that define clear responsibilities, contracts, and interfaces. Components are designed to be independent and replaceable, enabling loosely coupled architectures that improve maintainability and reusability. In the logical model, a component serves as an abstract structural unit defining functionality and contracts; in the physical model, it corresponds to implementation and deployment units.
- Development Process
-
A development process is the entire set of activities involved in building, deploying, and maintaining software systems. It encompasses planning, modeling, implementation, testing, and delivery as a systematic flow of development activities.
- Component
-
A software construct that encapsulates well-defined responsibilities, contracts, and dependencies as a reusable and replaceable unit. In the logical model, it serves as an abstract structural unit; in the physical model, it corresponds to an implementation or deployment unit.
- Cloud Native Component Framework (CNCF)
-
Cloud Native Component Framework (CNCF) is a framework for executing cloud application components using a single, consistent execution model. Centered on the structure of Component, Service, and Operation, it enables the same Operation to be reused across different execution forms such as command, server (REST / OpenAPI), client, and script. By centralizing quality attributes required for cloud applications—such as logging, error handling, configuration, and deployment—within the framework, components can focus on implementing domain logic. CNCF is designed as an execution foundation for literate model-driven development and AI-assisted development, separating what is executed from how it is invoked.