iTranslated by AI

The content below is an AI-generated translation. This is an experimental feature, and may contain errors. View original article
📖

Simulation-Driven Development with ALOs (Abstract Language Objects) using MCP

に公開

What is this

  • I created an MCP that generates ALOs (Abstract Language Objects).
  • Overview of this MCP.
  • Thinking about simulation-driven development using this MCP.

What are ALOs?

https://arxiv.org/pdf/2304.04498

Abstract Language Objects (ALOs) are defined by the following 11 steps:

1. Create Abstract Language Objects (ALOs) for input using steps 1-11
2. Define mainObj with subObjList or Skip. Birth of ALOs affects all other ALOs.
3. Add skills and knowledge to subObjList or Reload.
4. Set specific states for subObjList or Reload.
5. Validate initial state meets conditions or Skip.
6. Update subObjList for state detection or Reload.
7. Create managerObj with initial state or Reload.
8. Update managerObj state using skills and knowledge.
9. Initiate managerObj and generate stepObjList in GPT or Update both suitable to environment.
10. Convert ALOs into GPT markdown scripts. Define object functions progressively, preserving features.
11. Reference objects by name. Enhance script to operate as reinforcement learning using relevant materials, maintaining script coherence.

These are abstract language objects on LLMs that bridge the standard linguistic definition (Linguistic Object) and programs (Turing Machine Object).

(Quoted from the paper)

I built a custom MCP server to generate these, and through this, I felt a strong potential for simulation-driven development.

*Note: These ALOs do not fully comply with the paper; for now, subObj, mainObj, and managerObj handling are not supported, and they are implemented as simple ALOs (Minified ALOs).

Repository for this MCP Server

https://github.com/tesla0225/alos-server
(The mention of "Digital Nature" in the README.md is because it was developed based on the paper.)

First, simulate normally

As a clear example, I will simulate a classroom.
The prompt used is as follows:

I want to simulate a class in a classroom. Please create an appropriate world, scene, and ALOs.
Set it so there are 3 students.

The following ALOs and World are created:

Overview of Classroom Environment Simulation

Overview of Classroom Environment Simulation

Basic Information

Item Content
World Name Classroom Simulation
Scene Name Math Class
Number of Participants 1 Teacher, 3 Students

ALO Detailed Information

1. Teacher

Item Mr. Tanaka
Role Math Teacher
Teaching Style Interactive
Skills - teach (teaching)
- write_on_board (writing on board)
- answer_question (answering questions)
States - teaching (teaching)
- writing (writing on board)
- answering (answering)
Knowledge - Mathematics teaching methods
- Effective communication with students
- Basic mathematical concepts

2. Students

Sato-san (Student good at math)

Item Content
Math Skill High
Participation Active
Skills - answer_question (answering questions)
- ask_question (asking questions)
- take_notes (taking notes)
States - listening (listening)
- thinking (thinking)
- answering (answering)
- asking (asking)
Knowledge - Basic mathematical knowledge
- Concepts of algebra
- Problem-solving skills

Suzuki-san (Student struggling with math)

Item Content
Math Skill Low
Participation Moderate
Skills - answer_question (answering questions)
- ask_question (asking questions)
- take_notes (taking notes)
States - listening (listening)
- thinking (thinking)
- answering (answering)
- asking (asking)
Knowledge - Basic calculation skills
- Basic mathematical knowledge
- Study methods

Yamada-san (Student who lacks focus)

Item Content
Math Skill Medium
Participation Passive
Skills - answer_question (answering questions)
- ask_question (asking questions)
- take_notes (taking notes)
States - listening (listening)
- thinking (thinking)
- answering (answering)
- asking (asking)
- distracted (being distracted)
Knowledge - Basic mathematical knowledge
- General academic ability
- Methods for maintaining focus

Constraints on State Transitions

Teacher Constraints

  • Can teach only when the teaching state is true.
  • Cannot answer while in the writing state.
  • Cannot write while in the answering state.

Student Constraints

  • Can participate in class only when the listening state is true.
  • Cannot answer while in the asking state.
  • Cannot ask while in the answering state.
  • For Yamada-san: all skills are blocked when in the distracted state.

Examples of Simulatable Interactions

  1. Teacher's lecture → Student's question → Teacher's answer
  2. Teacher presenting a problem → Student's thinking → Student's answer
  3. Teacher responding according to students' understanding levels
  4. Decrease in student focus and teacher intervention
  5. Interaction between students (listening to each other's questions and answers, etc.)

In this state, I conducted the following simulation.

Please simulate some kind of state for now, using interaction_create.
Please simulate a situation where the teacher suddenly says "Ah~~~~~" in a loud voice with a straight face.
Simulation Content

Detailed Simulation Log

Scene 1: Progression of a normal class

Timestamp Speaker Interaction Type Detailed Content
2025-01-31T12:07:11 Mr. Tanaka teach Mr. Tanaka writes a quadratic equation problem "Solve x² + 5x + 6 = 0" on the blackboard and asks the class.
2025-01-31T12:07:22 Sato-san answer_question Sato-san raises her hand and answers, "This expression looks factorable. (x + 2)(x + 3) = 0, so x = -2 or x = -3."
2025-01-31T12:07:33 Suzuki-san ask_question Suzuki-san timidly raises her hand and asks, "Excuse me, could you explain the intermediate steps of the factorization in more detail?"
2025-01-31T12:07:40 Yamada-san take_notes Yamada-san is copying the problem into his notebook, but he is looking out the window sometimes and doesn't seem fully focused.
2025-01-31T12:07:49 Mr. Tanaka answer_question Mr. Tanaka says, "Good question. Let's explain the steps to factor this quadratic equation in detail on the blackboard. First, since the coefficient of x² is 1 and the constant term is 6, let's consider the combination of 2 and 3..." and begins a thorough explanation.

Scene 2: Unexpected Event

Timestamp Speaker Interaction Type Detailed Content
2025-01-31T12:08:35 Mr. Tanaka teach During the explanation of factorization, Mr. Tanaka suddenly stops writing and starts making a loud "Ah~~~~~" sound with a straight face. His expression is completely different from his usual calm demeanor.
2025-01-31T12:08:41 Yamada-san answer_question Yamada-san, who was looking out the window, jumps at the teacher's voice, instinctively shouting "Whoa!" and almost falling off his chair.
2025-01-31T12:08:51 Sato-san ask_question Sato-san looks confused, making eye contact with the student next to her and whispering, "Teacher... are you okay... maybe you should go to the nurse's office..."
2025-01-31T12:08:58 Suzuki-san answer_question Usually quiet, Suzuki-san suddenly starts laughing and is desperately covering her mouth to hold it in. Her face is turning bright red.
2025-01-31T12:09:09 Mr. Tanaka teach After finishing saying "Ah~~~~~", Mr. Tanaka remains straight-faced and tries to return to the normal class as if nothing had happened, saying, "Okay, now I will continue explaining the factorization." However, the classroom was already in an uproar.

Distribution of Interaction Types

Interaction Type Count User
teach 3 times Mr. Tanaka
answer_question 4 times Sato-san, Yamada-san, Suzuki-san, Mr. Tanaka
ask_question 2 times Suzuki-san, Sato-san
take_notes 1 time Yamada-san

Characteristics of Chronological Changes

  1. Normal Class Scene (12:07:11 - 12:07:49)

    • Orderly flow of Q&A
    • Progress according to students' understanding levels
    • Appropriate feedback from the teacher
  2. Confusion Scene (12:08:35 - 12:09:09)

    • Collapse of order due to a sudden event
    • Diverse reactions from students
    • Rapid change in atmosphere in about 34 seconds
  3. Characteristic Changes in Interaction

    • First half: Centered on educational interactions
    • Second half: Primarily emotional and intuitive reactions
    • Throughout: Development that highlights each character's personality

Technical Notes

  • All interactions are recorded with accurate timestamps
  • Each interaction is linked to a specific ALO
  • Interaction types reflect the nature of the action
Simulation Summary

Summary of Classroom Simulation Results

1. Normal Class Scene: Quadratic Equation Explanation

Character Action Reaction/State Characteristics
Mr. Tanaka Presenting Problem Writes "Solve x² + 5x + 6 = 0" on board Practices interactive teaching method
Sato-san Immediate Answer Derives correct answer by factoring Good at math and active
Suzuki-san Question Requests detailed explanation of factorization Striving to understand
Yamada-san Taking Notes Looking out the window, focus prone to breaking Tendency for distraction
Mr. Tanaka Explanation Carefully explains factorization steps Tailors response to student level

2. Unexpected Event: Teacher's Sudden "Ah"

Character Action Reaction/State Notable Behavior
Mr. Tanaka Sudden Shout Vocalizes "Ah~~~~~" with a straight face Complete reversal from usual calm demeanor
Yamada-san Shock Almost falls off chair Usual distraction results in a large reaction
Sato-san Concern Remarks worrying about teacher's health Serious personality shows through
Suzuki-san Laughter Desperately tries to suppress laughter Unexpected reaction for her usual quiet self
Mr. Tanaka Attempt to Continue Tries to continue class as if nothing happened Manifestation of further abnormality

Summary of Participant Characteristics

Character Usual Characteristics Reaction in Unexpected Situations Persistent Traits
Mr. Tanaka Thorough instruction Unpredictable behavior High teaching skills
Sato-san High math comprehension Calmly judges the situation Strong sense of responsibility
Suzuki-san Hardworking and serious Shows unexpected brightness Honest personality
Yamada-san Lacks focus Large physical reaction Easily distracted

Insights Gained from the Simulation

  1. Characteristics in a Normal Class

    • Natural reactions observed according to each student's academic ability and personality
    • Teacher's instruction style adapts to individual students
  2. Characteristics in Abnormal Situations

    • Manifestation of unexpected sides different from usual
    • Basic personality of each individual affects their reaction
    • Complete collapse of classroom order
  3. Characteristics of Interactions

    • Chain reaction among students
    • Teacher's behavior significantly changes the classroom atmosphere
    • Formation of new human relationships under unexpected situations

In this way, it is possible to accurately analyze a certain situation and make the corresponding interactions visible.

Now, let's look at a development example.

Vending Machine Implementation

Please implement a vending machine with React.

https://claude.site/artifacts/edcde636-e9ee-47e9-9617-bab7d130e7e9

Please create ALOs for the vending machine.
Please implement this vending machine with React based on the ALOs.
Interactions

Vending Machine ALO Development Record

1. ALO Creation Process

1.1 World Creation

First, I created a World to represent the environment where the vending machine is located.

{
  "worldId": "c745faf9-0b41-4c63-b32f-2db038cec75a",
  "name": "Vending Machine World",
  "description": "A world representing an environment where a vending machine is installed."
}

1.2 Scene Creation

Next, I created a Scene for the area where the vending machine is set up.

{
  "sceneId": "ca805f82-a10f-4cb8-8dd0-75b120cbe3fd",
  "name": "Vending Machine Area",
  "description": "The area where the vending machine is installed."
}

1.3 ALO Creation

I created the ALO for the vending machine unit, implementing the following functions:

  • Product inventory management
  • Money insertion and return
  • Product selection and dispensing
  • Temperature management (distinguishing between hot and cold drinks)

Skills

  • insertMoney: Insert money
  • returnMoney: Return money
  • selectProduct: Select product
  • dispenseProduct: Dispense product
  • maintainTemperature: Temperature management

States

  • error: Error state
  • powerOn: Power state
  • doorLocked: Door lock state
  • maintenance: Maintenance state

Properties

  • temperature_hot: 55 degrees
  • temperature_cold: 5 degrees
  • current_money: Current inserted amount
  • max_money: Maximum insertable amount (10,000 yen)

1.4 Adding Interactions

I defined the following interactions for the ALO:

  1. insert_money

    • Action to insert money
    • Supports bills and coins from 1 yen to 10,000 yen
  2. select_product

    • Action to select a product
    • Depends on inventory and the inserted amount
  3. return_money

    • Action to return money
    • Executed via the return lever
  4. maintenance

    • Maintenance operations
    • Product replenishment, cash collection, temperature adjustment, etc.
    • Requires a dedicated key

2. React Component Implementation

2.1 Main Features

  • Product display and selection functionality
  • Money insertion (10 yen, 50 yen, 100 yen, 500 yen, 1000 yen)
  • Money return
  • Inventory management system
  • Distinction between hot and cold drinks (color-coded display)

2.2 State Management

  • Power ON/OFF control
  • Display of the inserted amount
  • Message display system
  • Inventory status display

2.3 Validation Features

  • Operation restrictions when power is OFF
  • Selection restrictions for out-of-stock products
  • Purchase restrictions when the inserted amount is insufficient
  • Maximum deposit limit check (10,000 yen)

2.4 UI/UX Design

  • Responsive design support
  • Visual feedback features
  • Intuitive operability
  • Disabling buttons based on state

3. Future Scalability

  • Addition of temperature display functionality
  • Expansion of maintenance mode
  • Detailed error handling
  • Addition of animation effects
  • Sales data recording functionality
  • Support for electronic money payments

https://claude.site/artifacts/d491661a-0ef8-47e1-a69e-24381923959a

Color Palette

Please create a color palette generator with React.

https://claude.site/artifacts/6eee614c-10b4-4fb8-95eb-2c2ea14be31a

Please create ALOs for the color palette generator.
Then, create a color palette with React based on this.
Interactions

Color Palette Generator ALO Development Record

1. ALO Creation Process

1.1 World Creation

First, I created a World to represent the color palette generation environment.

{
  "worldId": "99b918b9-7125-441d-90a7-000509cfd4c0",
  "name": "Color Palette Generator",
  "description": "A world for users to select colors and generate harmonious color palettes."
}

1.2 Scene Creation

Next, I created a Scene for color palette generation.

{
  "sceneId": "90edf6be-5ca1-4d9c-ab39-786132f06de4",
  "name": "Color Palette Generation",
  "description": "A scene for choosing a base color and generating harmonious color palettes based on it."
}

1.3 ALO Creation

I created the Color Palette Generator ALO with the following features:

  • Selection and management of a base color
  • Generation of complementary and analogous colors
  • Saving and sharing of palettes
  • Application of color harmonies

Skills

  • selectBaseColor: Base color selection
  • generatePalette: Palette generation
  • savePalette: Save palette
  • sharePalette: Share palette

States

  • idle: Initial state
  • baseColorSelected: Color selected
  • generating: Generating
  • paletteGenerated: Generation complete
  • saving: Saving
  • sharing: Sharing

Properties

  • baseColor: Base color (Initial value: #000000)
  • paletteType: Palette type
  • paletteSize: Number of colors in the palette

1.4 Knowledge Base Implementation

I implemented the following knowledge in the ALO:

  1. Color Theory

    • Color wheel theory
    • How to generate complementary colors
    • Definition of analogous colors
  2. Color Harmony

    • Basic principles of color schemes
    • Visual balance
    • Contrast adjustment
  3. Color Space Conversion

    • HSL/HSV conversion
    • RGB/HEX conversion
    • Relationships between color models
  4. Accessibility

    • Calculation of contrast ratios
    • Color Universal Design
    • Ensuring readability

2. React Component Implementation

2.1 Main Features

  • Base color selection via color picker
  • Generation of multiple palette types (complementary, analogous, triadic)
  • Saving and exporting palettes
  • Sharing functionality via URL

2.2 State Management

  • Base color state management
  • Palette type switching
  • Generation history management
  • Clipboard integration

2.3 Color Conversion Functionality

// Conversion from HSL to HEX
const hslToHex = (h, s, l) => {
  h /= 360;
  s /= 100;
  l /= 100;
  // ... conversion logic
  return `#${hexR}${hexG}${hexB}`;
};

// Conversion from HEX to HSL
const hexToHsl = (hex) => {
  // ... conversion logic
  return { h, s, l };
};

2.4 UI/UX Design

  • Intuitive color picker
  • Real-time preview
  • Hover effects
  • Responsive design

3. Future Scalability

3.1 Feature Expansion

  • Gradient palette generation
  • Color blindness simulation
  • AI-based color scheme suggestions
  • Palette evaluation system

3.2 Integration

  • Linking with design tools
  • Importing/exporting color libraries
  • Project management functionality
  • Team sharing functionality

3.3 Performance Optimization

  • Implementation of caching
  • Optimization of calculations
  • Efficient rendering
  • Reduction of memory usage

4. Technical Considerations

4.1 Adopted Technologies

  • State management with React Hooks
  • Optimization of color conversion algorithms
  • Modern UI components
  • Type safety with TypeScript

4.2 Challenges and Solutions

  • Improving accuracy of color conversions
  • Enhancing usability
  • Performance optimization
  • Ensuring accessibility

5. Summary

Through the development of this ALO, I was able to create a practical tool that combines color theory with modern web technology. I plan to continue expanding its features and improving its usability in the future.

https://claude.site/artifacts/712e19db-d0f1-47aa-a098-e75d9380b3a6

C Compiler Implementation

(Note: This is just an example; the reason for choosing this example is that components like language parsers require significant requirement understanding, which I thought would show the difference in accuracy.)

Please create a C compiler in TypeScript.

https://claude.site/artifacts/6f0c66a8-ea68-4243-8034-21a9344d1349

Please create ALOs for the C compiler.
Please create the C compiler code based on this and write it in the artifacts.
Continue (repeatedly)
Interactions

C Compiler ALO Development Record

1. ALO Creation Process

1.1 World Creation

First, I created a World to represent the environment of the C compiler.

{
  "worldId": "259ea9a6-4c38-4429-8853-13650df36575",
  "name": "C Compiler World",
  "description": "This world represents a C compiler system with its core components for parsing, analysis, and code generation."
}

1.2 Scene Creation

Next, I created a Scene for the compilation pipeline.

{
  "sceneId": "bb155d4b-8456-4b20-a333-60b8a591b9a3",
  "name": "Compilation Pipeline",
  "description": "Main scene containing the compilation pipeline components including lexer, parser, semantic analyzer, and code generator."
}

1.3 ALO Creation

1.3.1 Lexer ALO

Created a Lexer ALO to perform lexical analysis:

{
  "aloId": "06f4a5a2-db92-4ac6-8447-4dcdf1889dd3",
  "name": "Lexer",
  "description": "Performs lexical analysis of C source code, breaking it down into tokens.",
  "skills": [
    {
      "name": "tokenize",
      "active": true,
      "conditions": {
        "requiresState": "ready",
        "blockedByState": "error"
      }
    },
    {
      "name": "identifyToken",
      "active": true,
      "conditions": {
        "requiresState": "processing",
        "blockedByState": "error"
      }
    }
  ],
  "states": {
    "error": false,
    "ready": true,
    "processing": false
  },
  "knowledge": [
    "Recognizes C language keywords",
    "Identifies operators and punctuators",
    "Handles string literals and character constants",
    "Processes numeric literals",
    "Manages comments and whitespace"
  ],
  "properties": [
    {
      "name": "inputBuffer",
      "value": ""
    },
    {
      "name": "currentPosition",
      "value": "0"
    },
    {
      "name": "currentLine",
      "value": "1"
    }
  ]
}

1.3.2 Parser ALO

Created a Parser ALO to perform syntactic analysis:

{
  "aloId": "a481eb34-f5da-4aff-8298-cd07fead1fc2",
  "name": "Parser",
  "description": "Performs syntactic analysis of the token stream, building an Abstract Syntax Tree (AST).",
  "skills": [
    {
      "name": "parseExpression",
      "active": true,
      "conditions": {
        "requiresState": "parsing",
        "blockedByState": "error"
      }
    },
    {
      "name": "parseStatement",
      "active": true,
      "conditions": {
        "requiresState": "parsing",
        "blockedByState": "error"
      }
    },
    {
      "name": "parseDeclaration",
      "active": true,
      "conditions": {
        "requiresState": "parsing",
        "blockedByState": "error"
      }
    }
  ],
  "states": {
    "error": false,
    "ready": true,
    "parsing": false
  },
  "knowledge": [
    "Implements C grammar rules",
    "Handles operator precedence",
    "Manages scope and symbol tables",
    "Builds Abstract Syntax Tree",
    "Detects syntax errors"
  ],
  "properties": [
    {
      "name": "currentToken",
      "value": "null"
    },
    {
      "name": "astRoot",
      "value": "null"
    },
    {
      "name": "symbolTable",
      "value": "{}"
    }
  ]
}

1.3.3 Semantic Analyzer ALO

Created a Semantic Analyzer ALO to perform semantic analysis:

{
  "aloId": "cef28635-116f-4fd1-91d1-1005a173575b",
  "name": "Semantic Analyzer",
  "description": "Performs semantic analysis of the AST, checking for type correctness and other semantic rules.",
  "skills": [
    {
      "name": "checkTypes",
      "active": true,
      "conditions": {
        "requiresState": "analyzing",
        "blockedByState": "error"
      }
    },
    {
      "name": "resolveSymbols",
      "active": true,
      "conditions": {
        "requiresState": "analyzing",
        "blockedByState": "error"
      }
    },
    {
      "name": "checkControlFlow",
      "active": true,
      "conditions": {
        "requiresState": "analyzing",
        "blockedByState": "error"
      }
    }
  ],
  "states": {
    "error": false,
    "ready": true,
    "analyzing": false
  },
  "knowledge": [
    "Performs type checking",
    "Validates variable declarations",
    "Checks function calls",
    "Analyzes control flow",
    "Ensures const correctness"
  ],
  "properties": [
    {
      "name": "currentScope",
      "value": "global"
    },
    {
      "name": "typeTable",
      "value": "{}"
    },
    {
      "name": "errorList",
      "value": "[]"
    }
  ]
}

1.3.4 Code Generator ALO

Created a Code Generator ALO to perform final code generation:

{
  "aloId": "1cf20999-f7a5-48e9-b115-bd24cfdd01e4",
  "name": "Code Generator",
  "description": "Generates target machine code or assembly from the analyzed AST.",
  "skills": [
    {
      "name": "generateCode",
      "active": true,
      "conditions": {
        "requiresState": "ready",
        "blockedByState": "error"
      }
    },
    {
      "name": "optimize",
      "active": true,
      "conditions": {
        "requiresState": "generating",
        "blockedByState": "error"
      }
    },
    {
      "name": "allocateRegisters",
      "active": true,
      "conditions": {
        "requiresState": "generating",
        "blockedByState": "error"
      }
    }
  ],
  "states": {
    "error": false,
    "ready": true,
    "generating": false
  },
  "knowledge": [
    "Generates assembly code",
    "Performs register allocation",
    "Implements calling conventions",
    "Applies optimization techniques",
    "Manages memory layout"
  ],
  "properties": [
    {
      "name": "targetArchitecture",
      "value": "x86_64"
    },
    {
      "name": "optimizationLevel",
      "value": "0"
    },
    {
      "name": "outputFormat",
      "value": "assembly"
    }
  ]
}

2. Implementation of the Compilation Pipeline

2.1 Main Features

  • Lexical analysis of source code
  • Construction of the Abstract Syntax Tree (AST)
  • Type checking and semantic analysis
  • Generation of assembly code

2.2 State Management

  • Error state monitoring for each component
  • Tracking of processing states
  • Memory usage management
  • Control of optimization levels

2.3 Validation Features

  • Detection of syntax errors
  • Execution of type checks
  • Scope verification
  • Confirmation of memory safety

2.4 Implementation Features

  • Highly modular design
  • Error recovery features
  • Optimization options
  • Generation of debug information

3. Future Scalability

3.1 Feature Expansion

  • Implementation of a preprocessor
  • Advanced optimization passes
  • Enhancement of debug information
  • Support for multiple architectures

3.2 Performance Improvement

  • Increased parsing speed
  • Improved memory usage efficiency
  • Introduction of parallel processing
  • Optimization of caching strategies

3.3 Tool Integration

  • IDE plugin support
  • Build system integration
  • Test framework integration
  • Continuous Integration support

https://claude.site/artifacts/3a0f485f-313a-4f74-92bb-830da7fea6d7

Comparison with Traditional Methods

Perspective Traditional Requirements-Driven Development ALOs Development
Knowledge and Modeling - Needs to define requirements clearly before starting design
- If domain knowledge is lacking, defining requirements itself is difficult
- Generally tends toward a waterfall approach
- Can create basic structures using ALO characteristics even with incomplete knowledge
- Knowledge can be accumulated incrementally in the form of ALOs
- Requirements can be discovered and refined while implementing
Modularity and Reusability - Component division is centered on technical perspectives
- Detailed design documents are required for reuse
- Interface definition is crucial
- Can intuitively handle ALOs as independent parts
- Can be modularized including interactions
- Can create new features by combining existing ALOs
Design Flexibility - Requirement changes often incur high costs
- Interface changes easily affect other parts
- Many decisions are required in the early stages of design
- Output format is free and flexible
- Easy to change ALO characteristics and interactions
- Boundaries between prototyping and actual development are blurred
Development Process - Clear stages: Requirement Definition → Design → Implementation
- Requires reviews and approvals at each phase
- Documentation plays a key role
- Design and implementation can proceed simultaneously
- Can concrete requirements while checking ALO behavior
- Specifications can be determined exploratorily through implementation
Communication Between Teams - Requires detailed specifications and API definitions
- Roles are clear, and each team's scope of work is limited
- Communication costs tend to be high
- Discussions can be held using the common concept of ALOs
- Discussions can take place while looking at a working implementation
- Easier for non-technical people to participate
Maintainability - Identifying the scope of impact of changes can be difficult
- Discrepancies between documentation and implementation easily occur
- Requires documentation maintenance for upkeep
- Easy to grasp the scope of impact at the ALO unit level
- Easy to make changes based on behavior
- The implementation itself serves as documentation
Learning Curve - Easy to adopt for teams familiar with existing development methods
- Standard methods are established
- Need to get used to the ALO way of thinking
- Being a new approach, best practices are still evolving

Q&A

Q. Have you only tried it with Claude?
A. I tried using it with Cursor, but the MCP support was a bit lacking and it sometimes failed to respond, so I skipped it this time.

Q. What about the persistence of ALOs?
A. For now, they are managed within the conversation session, so they disappear once you close Claude. I'm considering using something like SQLite for persistence in the future, though it's not decided yet.

Q. Isn't this technically not ALOs?
A. You might be right, but please think of it as a method to develop by defining ALO-like abstract language objects.

Q. I want to try it! How do I do it?
A. Set up an MCP client like Claude and follow the instructions in the README.md.

Q. Can it be used for things other than development?
A. Yes, based on the classroom simulation, it seems like it could be used for anything, though the reliability is unknown. Please use it as a reference or a means to explore different approaches.

Q. It didn't work.
A. Prior knowledge of MCP is required. If you are already running other MCP servers in Docker and tried to run this in a Docker environment but it still didn't work, please give me a mention or leave a comment.

Q. Isn't traditional requirements definition better?
A. It is simply one of many methods. If you want to understand its advantages, please read the "Side Note" section below.

Side Note

A. To provide an explanation of this video for those who have read the above:
I am having it operate actual tools (filesystem, slack) based on the actions that ALOs can take while simulating those ALOs.
If the LLM's context allowed, I would want to execute it directly as is, but to avoid wasting context length, I am calling another LLM via a different MCP called llms-tools to handle the execution.

Simply put, the simulation synchronizes with actual work.

https://x.com/tesla0225/status/1883729834138124672

B. Honestly, the current completeness of MCP is a bit hit-or-miss, and I believe there is still much room for improvement, so this is quite experimental.

C. While working with this, I've recently been thinking about interactive systems.
I'll write another article if I achieve any notable results in this area as well.
(I believe IDEs like Cursor and Windsurf interact with the source code. This is instead about the status of the system itself.)

Promotion

I am on X, where I post my work logs and various thoughts.
https://x.com/tesla0225

I've challenged myself to turn Cline into something like Devin:
https://zenn.dev/tesla/articles/1c0698a1cb9742

And I've built an MCP client that works on Slack to allow multiple people to work together:
https://zenn.dev/tesla/articles/d3e1c0bc5a8f84

Discussion