AI-Era Development Stack
Starting from 📄 Rethinking the Development Process in the AI Era, and using UP (Unified Process) as a guiding reference in 📄 Framing the Development Process in the AI Era, we have explored the development process in the AI era.
In 📄 Component-Based Development in the Age of AI, we redefined CBD (Component-Based Development) in the AI era within the framework of “literate models + DSL (Domain Specific Language) & code generation + AI.”
There, we demonstrated that the traditional weaknesses of CBD—such as difficulty of discovery, specification comprehension cost, and integration cost—can be significantly mitigated through AI, DSLs, and automated code generation.
Furthermore, in 📄 Cloud Native Component Framework:HelloWorld and 📄 Understanding the CNCF Execution Model Through HelloWorld, we introduced the execution foundation for components through the HelloWorld examples of the Cloud Native Component Framework (CNCF).
By combining DSLs and automated generation with the CNCF execution platform, we began to see a path toward structurally addressing implementation challenges such as quality attributes and cloud readiness.
In this article, we integrate this progression and organize the overall picture of a “development stack” that spans from the BoK (Body of Knowledge) to the execution platform.
Elements Integrated
In the previous articles,
have been discussed as individual technological elements.
SimpleModeling constructs these layers—BoK, literate models, DSLs, and the execution platform—into a single coherent technical system.
Knowledge organized in the BoK is reflected in literate models, literate models are translated into DSLs, and the structures defined in DSLs are guaranteed by the execution platform.
When this vertical continuity is established, design and implementation are no longer divided, and evolution becomes possible while preserving structural integrity.
And the axis that binds this technical system together is AI.
AI traverses across each layer,
-
understanding knowledge
-
structuring models
-
expanding structures
-
assisting execution configurations
thereby connecting the natural language world with the implementation technology world.
BoK and Literate Model
SimpleModeling adopts an approach in which knowledge development is central, and IT systems are produced as its output.
At the very top of this flow is the BoK.
The BoK can be constructed using SmartDox.
Within the BoK, knowledge is structured and consolidated using natural language, but it must be formalized in a way that enables IT system implementation. This formalization is carried out by the literate model.
A literate model is a model that performs the structuring and formalization required for IT system construction while preserving the meaning of natural language.
Alongside IT-system-ready structuring and formalization, concepts, relationships, and constraints are described in prose and organized in a way that AI can understand.
The literate model thus serves as the key element that connects natural language knowledge, IT systems, and AI.
Literate Model and DSL
The structured and formalized parts of the literate model function as a DSL. The DSL is the layer that provides an “executable structure.”
-
Entities
-
Contracts
-
Operations
-
States
-
Constraints
are defined explicitly.
AI supports processing of natural language, operations on structured information such as literate models and DSLs, as well as model transformations, completion, and consistency checks.
Because a literate model is written in natural language, traditional technologies could only operate on the DSL portion; however, with AI, the entire literate model—including its natural language content—becomes operable and usable.
DSL and Execution Platform (CNCF)
CNCF provides an execution platform for cloud applications, where components serve as the unit of execution.
Components generated from the DSL by Cozy run directly on the CNCF execution platform as real systems.
In SimpleModeling, CBD is the modeling axis, and components as modeling elements operate directly on the execution platform without conceptual gaps.
CNCF also has the following two characteristics.
-
An execution foundation for cloud-native applications
-
Separation of concerns such as quality attributes, enabling component development focused on realizing the domain model
These characteristics also positively influence AI.
AI achieves higher accuracy when context is bounded and specifications are explicit.
By centering on components, the scope of reasoning is naturally constrained. Although a component definition is a collection of strict specifications, those clearly defined specifications become the foundation for AI reasoning.
Furthermore, through separation of concerns, complex parameters such as quality attributes do not need to be interwoven into domain logic, allowing AI to focus on understanding domain specifications and their realization.
Role of AI in Each Element
Let us examine the role of AI in each of the following technological elements.
BoK ― Understanding and Exploration of Knowledge
AI supports the following activities:
-
Exploration of related concepts
-
Summarization of definitions
-
Extraction of relationships between concepts
-
Detection of terminology inconsistencies
The reason the BoK can be used not merely as a collection of documents but as a structured knowledge base is that AI can handle meaning across contexts and boundaries.
Literate Model ― Organization of Meaning and Maintenance of Consistency
Within the literate model, AI supports:
-
Refinement and formatting of descriptions
-
Adjustment of abstraction levels
-
Elimination of redundancy
-
Detection of contradictions
-
Terminology unification
AI helps impose order on the natural language world and supports structuring while preserving meaning.
DSL ― Expansion and Generation of Structure
Within the DSL layer, AI supports:
-
Code generation from models
-
Completion of contracts
-
Validation of constraints
-
Detection of differences
Here, AI functions as a supporting mechanism that expands structure into implementation.
Execution Platform ― Assistance in Configuration and Operation
Within the execution platform, AI is responsible for:
-
Proposing component configurations
-
Assisting in tuning execution parameters
-
Analyzing logs and traces
-
Supporting error classification
AI plays the role of cross-layer verification to ensure that structures are executed correctly.
The Role of AI in Integrating the Elements
As we have seen, AI plays distinct roles at each layer.
However, the role of AI is not limited to supporting each layer independently.
A crucial role of AI is to connect these layers transversally.
Knowledge organized in the BoK is reflected in the literate model, translated into DSL, and executed on the execution platform.
AI understands, maintains, and assists this vertical continuity.
In other words, AI is:
-
Preserving semantic continuity
-
Maintaining structural consistency
-
Verifying alignment with execution
a vertical connective mechanism.
The natural language world and the implementation technology world are connected end-to-end without fragmentation. AI plays a vital role in guaranteeing this complex connection. Thus, a development stack spanning from the BoK to the execution platform is established.
Summary
This article has organized the vertical structure spanning from the BoK to the execution platform.
In the next article, 📄 CBD Enabled by DSL and Execution Platform: Implementable Component Structure, we will examine how CBD is established on top of this structure.
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.
- DSL (Domain Specific Language)
-
A DSL (Domain-Specific Language) is a language designed for a particular domain, enabling direct and concise expression of the domain’s concepts and structures. Compared to general-purpose programming languages (GPLs), DSLs offer a higher level of abstraction tailored for domain-specific problem solving and automation.
- 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.
- BoK (Body of Knowledge)
-
At SimpleModeling, the core knowledge system for contextual sharing is called the BoK (Body of Knowledge). The goal of building a BoK is to enable knowledge sharing, education, AI support, automation, and decision-making assistance.
- Development Process
-
Undefined
- Literate Model
-
Undefined
- 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.
- Quality Attribute
-
A Quality Attribute is a characteristic that expresses the degree of quality with which software satisfies requirements in addition to performing its functions. Examples include Security, Performance, Availability, Reliability, Resilience, Observability, and Maintainability.
- SimpleModeling
-
SimpleModeling is a modeling-centered software development methodology and technology system for constructing a Domain Model from Knowledge, formalizing it in CML, realizing it as executable software through Cozy and AI, and running it on Textus.
- Model
-
A Model is an abstraction that represents a subject according to a particular Purpose and Concern so that it can be understood, reasoned about, evaluated, or constructed. It is not the subject itself; it preserves the elements, relationships, and meanings required for its purpose.
- Cozy
-
Cozy is the SimpleModeling toolchain that analyzes Models expressed in CML and other DSLs and transforms them into realization artifacts such as programs, configuration, and documentation.
- Operation
-
In UML, an Operation is a Behavioral Feature of a Classifier that specifies the name, type, Parameters, and Constraints for invoking associated Behavior. The Operation specifies an invocation contract, while a Method or another Behavior realizes it.
- State
-
In UML, a State models a situation during which an invariant condition holds. The current State of an Object may determine accepted Events and Operations, applicable Constraints, and possible next Transitions.
- Constraint
-
In UML, a Constraint is a condition or restriction expressed in natural language or a machine-readable language to declare part of the Semantics of one or more Model Elements. Its evaluation yields a Boolean value and has no side effects.
- Feature
-
In UML, a Feature is a structural or behavioral characteristic of Instances of a Classifier. Features include Structural Features such as Attributes and Behavioral Features such as Operations.
- Domain Model
-
Undefined
- Platform
-
A Platform is a shared set of technical foundations and services used to build, deploy, execute, and operate software.
- error
-
A generic term used broadly in practice. In software engineering, it is ambiguous and may denote bugs or failures in general. In SimpleModeling, Error is treated as a broad label, with specifics clarified as Mistake, Defect, Fault, Failure, or Deviation.
- verification
-
Verification is the activity of confirming that an implementation conforms to its specified design or requirements.