[BPStudy] Literate Model-Driven Approach to Software Development in the AI Era

ASAMI, Tomoharu Created: 2025-11-03

On October 31, 2025, at BPStudy, during "BPStudy#218 — Modeling in the Era of Generative AI", I gave the following presentation (delivered remotely via Zoom).

  • Literate Model-Driven Approach to Software Development in the AI Era

Thank you very much to everyone who joined the session.

Session Overview

In this session, we introduced the activities of SimpleModeling.org from the following perspectives:

SimpleModeling Development Method

The SimpleModeling Development Method is a development framework centered around the Object-Functional Model. Based on the UML metamodel, it refines the concepts of Entity, Value, Event, Rule, and Service, and restructures them to target cloud application development through Literate Models.

This method functions as an abstraction layer connecting modeling and generation, forming the foundation of Literate Model-Driven Development.

Literate Model-Driven Development

Literate Model-Driven Development extends the philosophy of Literate Programming into the modeling domain. Developers create Literate Models that integrate natural language and structural descriptions, and formalize them using CML.

These models are automatically transformed into implementation code (such as Scala), documentation, and API definitions through the Cozy model compiler.

The goal is to create model descriptions that are both human-readable and machine-understandable for AI analysis.

Literate Model-Driven Development and AI

Literate Model-Driven Development is a methodology highly compatible with Generative AI. A Literate Model integrates human-readable natural language explanations with structured data, forming a knowledge unit that AI can extract, interpret, and reconstruct.

As a result, AI can not only interpret the intent of the model to support code generation and design, but also reference the entire model as a knowledge base, enabling learning and assimilation as part of a continuous knowledge cycle.

To achieve this, SimpleModeling provides technologies for building a knowledge base composed of Literate Models, known as the BoK.

Generative AI treats these Literate Models as “input-ready knowledge structures,” performing explanations, design suggestions, and specification transformations based on them through Knowledge Activation via RAG (Retrieval-Augmented Generation).

This structure forms the foundation of the AI Collaboration Architecture advocated by SimpleModeling.

BoK

The BoK is a systematic knowledge framework that organizes Literate Models. It analyzes SmartDox documents to extract relationships among models, concepts, and terms, and generates structured data (JSON-LD / RDF) that AI can search, reference, and internalize alongside HTML documents.

This BoK serves as the Retrieval Knowledge Base for AI, supplying it to the AI knowledge-generation process (Activation → Assimilation → Promotion) through Knowledge Activation.

It is a mechanism by which Literate Models written by humans are transformed into a knowledge system that AI can learn from.

Toward Knowledge-Driven Development

Looking toward the full-scale utilization of AI, we need to shift from traditional programming-driven development to model-driven and knowledge-driven development.

At the core of this shift lies the Literate Model, which enables AI to interpret it as knowledge and apply it to reasoning and generation — a key source of new value.

In the long term, the BoK organized through Literate Models will be internalized by AI, leading to the emergence of Collaborative Knowledge — a fusion of implementation knowledge and conceptual knowledge.

SimpleModeling refers to the development style built upon this collaborative knowledge as Knowledge-Driven Development.

Although Knowledge-Driven Development is still in an experimental stage, SimpleModeling aims to establish Literate Model-Driven Development as its milestone and to explore new development foundations premised on collaboration with AI.

Panel Discussion

In the second part, we held a panel discussion under the theme “Modeling in the Era of Generative AI,” building upon the topics covered in the first session. Many thanks to moderator Haruo Sato, panelist Kentaro Takasaki, and everyone who contributed questions through the chat.

During the discussion, Mr. Sato created a diagram summarizing the key points of the presentation, which served as the basis for the conversation.

What left a strong impression was how Mr. Sato approached the framework of Literate Model-Driven Development and AI from the perspective of “value extraction.”

For this presentation, we also outlined a vision and goals, and within SimpleModeling.org, the following draft pages are currently being prepared under the Overview section:

  • vision.dox

  • mission.dox

  • goal.dox

  • values.dox

As our approach to AI has become more refined compared to the initial phase of the site, the overall direction is still being consolidated, but we plan to make these pages publicly available soon.

Mr. Takasaki made two particularly insightful points:

  • AI Assistance

  • Opportunities for Engineers

The observation that the focus should be on AI assistance rather than AI-driven development is exactly right. Instead of automatically generating entire programs from prompts, we aim for an approach where programs are divided into components, controlled by engineers, and managed through divide-and-conquer strategies, with AI effectively supporting this process.

In this approach, engineers continue to play a central role in controlling software development, creating new domains where their expertise can truly shine.

In any case, it is certain that AI will bring profound changes to both the methodologies and organizational structures of software development. I hope this serves as an opportunity to reflect on what kinds of approaches engineers should take in this transformative era.

References

Glossary

Activity

A concrete action or task performed within an Activity Space to move an Alpha to a more advanced state, typically producing or refining Work Products.

Development Method

A development method is a conceptual framework composed of models and model transformations that define the structure and semantics of software systems. Examples include object-oriented design, domain-driven design (DDD), and model-driven development (MDD). A development method provides the structural foundation that defines what is to be built and how it should be represented.

Literate Model-Driven Development (LMDD)

Literate Model–Driven Development (LMDD) is a software development methodology that integrates natural-language narrative and formal model structure within a unified text-based framework. It extends conventional Model–Driven Development (MDD) by treating documentation and models as a single, consistent source of truth. In LMDD, the descriptive and structural elements of development artifacts are expressed together using the SmartDox language. From this unified representation, ModelDox extracts structural data, CML (Cozy Modeling Language) defines domain-specific models, and Cozy generates executable code, documentation, and configuration artifacts. Artificial intelligence participates in the LMDD process by analyzing the narrative context, validating structural consistency, and supporting the refinement of models and generated artifacts. All artifacts are represented in text form, ensuring traceability, version control, and interoperability within standard development environments. By defining a formally connected and machine-interpretable relationship between documentation, design, and implementation, LMDD provides a foundation for AI-assisted model–driven engineering where human authorship and automated reasoning operate on the same representational layer.

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.

Knowledge-Driven Development

A development paradigm that centers on knowledge, integrating AI assistance and modeling for continuous evolution.

UML (Unified Modeling Language)

A standardized modeling language for object-oriented analysis and design. It represents system structures and behaviors through diagrams such as class, sequence, and use case diagrams. Serves as the foundational language for UP and CBD.

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.

CML (Cozy Modeling Language)

CML is a literate modeling language for describing Cozy models. It is designed as a domain-specific language (DSL) that forms the core of analysis modeling in SimpleModeling. CML allows model elements and their relationships to be described in a narrative style close to natural language, ensuring strong compatibility with AI support and automated generation. Literate models written in CML function as intermediate representations that can be transformed into design models, program code, or technical documentation.

knowledge circulation

Knowledge Circulation denotes the cyclical process in which knowledge is activated, assimilated, expressed, and promoted between AI and humans, then re-activated. Through this loop, knowledge generated by AI is organized and reintegrated into the SmartDox site or BoK (Body of Knowledge), allowing the whole system to evolve and deepen AI’s understanding and generative ability.

Retrieval-Augmented Generation (RAG)

A generation technique that supplements a language model’s internal (parametric) knowledge by retrieving relevant external information before generation. RAG systems first search knowledge sources such as databases or knowledge graphs and then use the retrieved context as input for text generation.

RDF

A W3C-standardized data model that represents information as subject–predicate–object triples.

Retrieval Knowledge Base

Retrieval Knowledge Base (RKB) is a structured, retrievable subset of Non-parametric Knowledge optimized for use by RAG (Retrieval-Augmented Generation). It contains indexed SmartDox documents, glossary entries, and semantic metadata, allowing AI models to fetch explicit knowledge as contextual input. Through RAG interaction, the RKB serves as a bridge for transforming external explicit knowledge into intermediate assimilated knowledge within the AI model.

Prompt

A structured instruction or contextual representation that bridges retrieved knowledge (RAG) and the AI model’s reasoning process. It transforms the structured knowledge from the BoK into a narrative or directive form that the model can interpret, act upon, and internalize.

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.

observation

Observation is the recorded form of phenomena that are judged worthy of being noted and stored. Observations serve as the foundation for logging, monitoring, auditing, and troubleshooting.