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.”
Cozy translates the DSL of the literate model into an implementation-ready form.
-
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
-
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.
- literate model
-
A Literate Model is a “readable model” that integrates model structure with natural-language narrative (structured documentation). It extends the idea of literate programming into the modeling domain, unifying structure (model) and narrative (structured text) into a single intelligible artifact interpretable by both humans and AI. The concept of “Literate Modeling” has been explored previously by some researchers and developers, mostly as an approach to improve documentation or code comprehension. However, those attempts did not establish a systematic modeling methodology that integrates models, narrative, and AI assistance as a unified framework. The Literate Model is a modeling concept newly systematized and proposed by SimpleModeling for the AI era. Building upon the ideas of literate modeling, it redefines them as an intelligent modeling foundation that enables AI-collaborative knowledge circulation and model generation. It is not merely a modeling technique but a framework that embeds human reasoning and design intent as narrative within the model, enabling AI to analyze and reconstruct them to assist in design and generation.
- 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.
- 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.