SimpleModeling Development Process in the AI Era

Traditional development processes define phases such as requirements, design, implementation, and testing, but they assume human interpretation and execution.

As a result, processes exist as documents or guidelines, while actual execution is delegated to code and individual decisions.

As a result, processes exist but are not executed, or they diverge from actual implementation.

In the AI era, development processes themselves are expected to be executed by AI or at least driven with AI assistance.

With this shift, processes that rely on human interpretation become insufficient, and must instead be defined in a form that AI can understand and execute.

In SimpleModeling, the Essence Framework is adopted as the foundation for explicitly defining development processes.

The Essence Framework provides a theoretical structure for describing software development processes using a common conceptual model.

Essence consists of the following elements:

These elements enable development processes to be defined as structures independent of specific methodologies.

In SimpleModeling, this Essence structure is used to organize concrete methodologies such as UP (Unified Process) and CBD (Component-Based Development), integrating them into a coherent process model.

However, Essence itself is a framework for describing processes, and it is not directly executable.

Therefore, an additional mechanism is required to determine how the defined processes are executed.

The reinterpretation of UP (Unified Process) in the AI era is discussed in 📄 Reinterpreting the Unified Process in the AI Era. Here we focus only on the essentials.

UP provides a process backbone that advances development in executable slices through iteration and use-case-driven development.

CBD structures systems as components, ensuring quality through boundaries and structure.

In SimpleModeling, this structure is described using CML (Conceptual Modeling Language) and transformed by Cozy into programs that run on CNCF.

Furthermore, this CBD structure is realized on the execution platform by CNCF (Cloud-Native Component Framework), ensuring that component boundaries are consistently preserved at runtime.

This integrates UP-based process, CBD-based structure, CML-based modeling, Cozy-based generation, and CNCF-based execution into an executable development process.

Traditional development processes have been described as specifications or models, but they were not directly executable. Execution was delegated to programs, creating a clear gap between process and implementation.

SimpleModeling redefines this relationship by treating development processes as executable structures. In this view, processes are not merely descriptions, but targets of execution.

Through this transformation, the scope of execution—traditionally limited to programs—is expanded. First, components defined by CBD can be executed directly on CNCF, which extends conventional approaches.

In the AI era, use cases themselves become executable units. Applications operate not only at the component level, but also at the level of use cases.

Finally, the development process itself becomes an executable target. As a result, systems, use cases, and development processes are all treated as unified executable entities.

SimpleModeling adopts an architecture that integrates BoK, Cozy, CNCF, and SKILL to make described processes and models executable.

Their roles are as follows:

This architecture connects description (BoK), generation (Cozy), execution (CNCF), and process (SKILL) into a unified structure.

Through this, the transformation from description to execution described in the previous section is realized as a concrete system.

In SimpleModeling, a use case is not just a requirement description, but an executable unit. This represents a new domain made possible by the emergence of generative AI.

In traditional development, use cases were only inputs to design and implementation, and were never directly executable. In this model, leveraging AI’s interpretive capability, use cases themselves directly express system behavior and become executable targets.

As a result, the application operates not only as a collection of components, but also as a collection of use cases.

This structure concretizes the “expansion of execution scope” described earlier, positioning use cases alongside components as executable targets.

A use case defines system behavior through its internal operations and state transitions, and is treated as a coherent unit at runtime.

As shown in the previous sections, use cases are treated as executable units in SimpleModeling. Going one step further, SKILL is a mechanism that makes the development process itself executable, which is also a new domain enabled by AI.

SKILL provides this execution mechanism, transforming use cases into executable forms and controlling their execution.

Specifically, use cases are interpreted by SKILL and transformed into a set of executable operations (Actions) within the system.

These operations are executed on CNCF, realizing the behavior described in the use case as a running system.

Furthermore, SKILL handles not only the execution of use cases but also the execution of the development process itself. This unifies the execution of use cases and development processes under the same mechanism.

Through this structure, processes, use cases, and systems are unified as consistently executable targets in SimpleModeling. This represents an AI-era execution model that did not exist in traditional software development.

This article presented the SimpleModeling development process as a reconstruction of software development in the AI era.

While traditional development processes existed as descriptions and execution was delegated to programs, SimpleModeling treats the process itself as an executable structure.

Through this transformation, the scope of execution expands from components to use cases, and further to development processes. In particular, the execution of use cases and development processes represents a new domain enabled by generative AI.

Through the integration of BoK, Cozy, CNCF, and SKILL, description, generation, execution, and process are connected into a unified structure.

This is not merely a methodology, but an execution model directly operable by AI, and may become a foundational structure for future software development.