SimpleModeling Development Process with Essence Framework
The previous article described the SimpleModeling development process in the AI era as an executable structure centered on BoK (Body of Knowledge), Cozy, CNCF (Cloud Native Component Framework), and SKILL.
This article redefines that development process using the Essence Framework. The goal is to clarify SimpleModeling not merely as a procedure, but as a Development Process composed from a Kernel and selected Practices.
Background
SimpleModeling is a development process based on the Unified Process and structured for the AI era. A development process is a framework that defines the activities, roles, work products, and way of progressing software development.
This article defines that development process using the Essence Framework.
Defining it with the Essence Framework makes the development process easier to handle as a set of composable parts. By organizing it around a Kernel and Practices, the necessary elements can be selected and combined according to purpose and context.
This organization also provides a foundation for process modeling oriented toward SKILLization. By making the relationships among Activities, Work Products, Roles, and Automation explicit, the process becomes easier to describe not only as a method for humans to read, but also as a structure that AI agents can interpret and assist.
Essence as the Foundation
The Essence Framework defines the essential concepts common to software engineering as a Kernel, and provides a way to compose Methods by combining Practices on top of it.
SimpleModeling uses the Essence concepts as follows.
| Concept | Role in SimpleModeling |
|---|---|
The common foundation for all Method Views. |
|
Things that evolve and are assessed during development, such as Opportunity, Stakeholders, and Requirements. |
|
A selectable unit used to compose a Method. |
|
An abstract work unit contained in a Practice. |
|
An artifact created or updated by Activities. |
|
The capability required to perform Activities. |
In SimpleModeling, a Practice is the unit of Method composition, an Activity is the unit of execution, and a SKILL is a concrete procedure that assists or automates an Activity.
Development Process and Method
In SimpleModeling, a development method is defined as a combination of selected Practices on top of the Essence Kernel.
A Development Process adds process flow, work products, roles, AI agents, automation, and lifecycle to this development method.
SimpleModeling Practice Groups
Practice Group is a classification concept introduced by SimpleModeling. It is not a standard Essence element.
A Practice Group is a toolbox for selecting Practices. A Method is not composed from Practice Groups directly; it is composed by selecting Practices.
At this stage, the following Practice Groups are assumed.
| Practice Group | Purpose |
|---|---|
Essence Practice Group |
Holds Practices derived from the Essence references. |
Solo Development Practice Group |
Holds Practices suitable for solo development. |
SimpleModeling Practice Group |
Holds tool-independent SimpleModeling Practices. |
SimpleModeling with Cozy Practice Group |
Holds SimpleModeling Practices based on the Cozy product family and CNCF. |
Baseline Method View
As the baseline for the standard SimpleModeling Development Process using Cozy and CNCF, the following Method View is defined.
The candidate selected Practices are as follows.
-
Scrum Solo Practice
-
Business Modeling Solo Practice
-
Cloud Native CBD (Component-Based Development) Practice
-
BDD (Behavior-Driven Development) with Use-Case Lite Practice
-
User Environment Lite Practice
-
CI/CD Pipeline Practice
-
DevOps Practice
Process Flow View
The Process Flow View arranges Activities from selected Practices into a concrete development flow.
As a draft, the minimum iteration cycle can be defined as follows.
-
Prepare the development environment.
-
Clarify the business context and goals.
-
Describe requirements using Use Case Lite.
-
Decompose use cases into slices.
-
Specify acceptance conditions using BDD.
-
Define the domain model and component structure.
-
Generate code, tests, and documentation.
-
Validate through the CI/CD pipeline.
-
Improve from the viewpoints of operation, observation, and security.
This flow is not a fixed waterfall sequence. Activities iterate and update work products as development progresses.
Practice, Activity, and SKILL
SimpleModeling introduces SKILL to connect Essence Practices and Activities to AI-era execution units.
A Practice is an abstract unit used to compose a Method. An Activity is work performed within a Practice. A SKILL is a concrete procedure used by a human or AI agent to perform an Activity.
Not every Activity can be fully represented as a SKILL. Activities involving judgment, dialogue, and decision-making remain human-led, with AI assistance.
Work Products
The Work Product View defines artifacts created or updated by Activities.
Representative Work Products include the following.
These artifacts should not be mere documents. They must have a structure that AI agents can read, update, and use as input for subsequent Activities. Components executed on CNCF are also treated as part of this work product structure.
Role and Agent View
In AI-era SimpleModeling, roles are not assigned only to humans. AI agents are also treated as actors that execute or assist Activities.
As a draft, the following roles can be defined.
| Role | Responsibility |
|---|---|
Product Owner |
Decides goals, value, and priorities. |
Solo Developer |
Handles design, implementation, validation, and operation across the process. |
Modeling Agent |
Assists in creating requirements, BoK, and domain models. |
Generation Agent |
Generates code, tests, and documentation from models. |
Review Agent |
Assists with consistency, quality, and security review. |
Automation View
The Automation View defines which Activities are assisted or automated by SKILLs and tools.
Initially, manually performed Practices and SKILL-assisted Practices are used together.
Automation targets can be expanded gradually as follows.
-
Checklist and review assistance.
-
Generation of models, tests, and documentation.
-
Execution of CI/CD and quality gates.
-
Operational observation and improvement suggestions.
Lifecycle View
The Lifecycle View defines how the Development Process progresses over time.
SimpleModeling refers to the Unified Process phase structure while treating it as a lightweight lifecycle suitable for AI-assisted iterative development.
| Phase | Focus |
|---|---|
Inception |
Clarify goals, stakeholders, and primary use cases. |
Elaboration |
Establish architecture, domain model, and major risks. |
Construction |
Generate, validate, and integrate functionality by slices. |
Release, operate, observe, and improve. |
Open Issues
This article is a draft template. The following points will be refined later.
-
The exact scope of Practices derived from Essence references.
-
The boundary between Use Case Lite Practice and CML Use-Case Modeling Practice.
-
Conditions for extracting BoK Practice as a tool-independent Practice.
-
A checkable file structure for Practice, Activity, and SKILL mappings.
-
How to derive purpose-specific Development Processes.
Conclusion
By defining the SimpleModeling Development Process with the Essence Framework, the development process can be composed as a set of Practices and connected to an executable structure through Activities and SKILLs. By positioning CNCF as the execution foundation, generated components can be connected to a running system.
With this structure, SimpleModeling can evolve as a Development Process that integrates AI-assisted solo development, model-driven development, and continuous generation, validation, and operation.
References
Glossary
- 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.
- 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.
- 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.
- 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.
- Kernel
-
The foundational subset of Essence containing the minimal concepts necessary to define and reason about any software engineering endeavor. It includes Alphas, Activity Spaces, and Competencies.
- Development Process
-
Undefined
- Practice
-
A reusable method fragment that defines how certain aspects of software engineering should be addressed. Practices can be combined to form methods.
- 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).
- 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.
- Work Product
-
A tangible result or artifact produced by activities to provide evidence of an Alpha’s state. Examples include documents, models, code, or other verifiable outputs.
- View
-
A View is a representation that projects selected parts of a Model according to a particular Purpose and Concern so they can be understood, reasoned about, evaluated, or used. A View presents part of a Model and does not own meaning independently of the source Model.
- Alpha
-
A key progress dimension in Essence representing an essential element of software engineering (e.g., Opportunity, Stakeholders, Requirements, Software System, Team, Work, Way of Working). Each Alpha evolves through well-defined states.
- Competency
-
A human capability required to perform certain Activities effectively. Competencies define skills, experience, and knowledge levels associated with roles.
- Development Method
-
Undefined
- Lifecycle
-
A Lifecycle is the range of States and Transitions through which a subject passes, while retaining its Identity, from creation to termination.
- Dependency
-
In UML, a Dependency is a directed Relationship indicating that the specification or implementation of a client Model Element depends semantically or structurally on the definition of a supplier Model Element.
- Use Case
-
In UML, a Use Case is a Model Element that specifies a set of Actions performed by a subject to yield an observable result of value to an Actor or other stakeholder.
- 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.
- BDD (Behavior-Driven Development)
-
Behavior Driven Development (BDD) is a development approach that focuses on specifying system behavior through scenarios written in a shared language.
- Security
-
Security is the quality of protecting information and functions according to legitimate authority and preventing unauthorized disclosure, use, modification, destruction, or repudiation. It includes Concerns such as Confidentiality, Integrity, Authenticity, and Accountability.
- Story
-
Undefined
- observation
-
A recorded result of perceiving/measuring a phenomenon.
- 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.
- Test
-
A Test is an activity and specification that executes or evaluates a subject under stated conditions and compares observed results with expected results or Constraints to check conformance to requirements or contracts.
- 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.
- Responsibility
-
A Responsibility is an obligation stating what an Object or Role must know, decide, perform, or protect. It assigns ownership of rules and Behavior, not merely structural information.
- validation
-
Validation is the activity of confirming that a system or product fulfills its intended use and stakeholder requirements.
- 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.
- Transition
-
In UML, a Transition is a directed Relationship from a source Vertex to a target Vertex in a StateMachine. Triggers, Guards, Effects, and related elements specify when the Transition occurs and what it performs.
- CML (Cozy Modeling Language)
-
CML (Cozy Modeling Language) is the SimpleModeling formal modeling language for describing the Executable Model portion of an Object Model that connects to program generation and execution.