Spec-Driven Development

Robo Architect

An AI software design and implementation automation platform built around the spec

AI Software Design and Implementation Automation Based on Spec-Driven Development (SDD)

Robo Architect is a Spec-Driven Development tool that puts the spec, not the code, at the center. Starting from natural-language requirements, it manages software change through a Proposal lifecycle of impact analysis → sandbox implementation → verification → merge, keeping spec and implementation in sync at all times.

It models the problem domain with DDD (Domain-Driven Design) and verifies it against BDD (Behavior-Driven Development) acceptance criteria, so product owners, architects, and developers collaborate on a single spec while the Claude Code skill engine automatically generates verified code.

Key Features

Start with natural-language requirements

A product owner enters a requirement in plain language, such as "Customers order food and manage menus in a food delivery app," and the AI begins its analysis. Everything starts from the requirements spec, not from code.

Natural-language requirements input

Start from a document upload, too

AI analysis starts automatically

Proposal-based change management

From the requirements you enter, Epics, Features, and User Stories (strategic changes) and Aggregates, Commands, and Events (tactical changes) are derived automatically. Every change is managed as a single Proposal with full history tracking.

Automatic strategic and tactical Diff generation

Automatic Epic/Feature/Story derivation

Change history tracking and management

Change impact analysis (Impact Map)

The impact of a new requirement on the existing design is analyzed automatically from the Requirements, Process, and Design perspectives. See at a glance what is new and what changes on the Impact Map.

Requirements, Process, and Design impact analysis

Automatic identification of new/changed elements

Impact Map visualization

Specs based on BDD acceptance criteria

Each User Story is refined into Given-When-Then acceptance criteria. The BDD spec becomes the verification standard itself, guaranteeing that requirements and implementation match.

Given-When-Then acceptance criteria

The spec is an executable test

Guaranteed requirements-to-implementation match

Process and User Journey design

User Journeys and the interactions among actors, commands, and events are visualized as processes. Business flows are expressed clearly from the perspective of domain events.

User Journey visualization

Actor, command, and event flows

Business process modeling

Aggregate and EventStorming design

Aggregate, Entity, Value Object, and Enum designs grounded in DDD, along with the EventStorming model, are composed automatically. Domains are cleanly separated by Bounded Context to keep complexity under control.

Aggregate, VO, and Enum design views

EventStorming modeling

Bounded Context separation

Isolated sandbox worktree implementation

Each Proposal gets its own Git Worktree (local branch) sandbox, so implementation is safe and never affects the main project. The implementation task list is broken down automatically in tasks.md.

Git Worktree sandbox per Proposal

Safe implementation with zero impact on the main project

Automatic task breakdown in tasks.md

Engine built on Claude Code skills

Instead of a proprietary LangChain/LangGraph stack, it runs by invoking Claude Code Skills. It works just as well from the Claude Code terminal without a UI, so you are never locked into the tool.

Claude Code Skill invocation engine

Runs in the terminal without a UI

Reuse of standard agents

Open skill file customization

Every engine behavior is defined in editable skill files (SKILL.md). Change a skill and you change the Robo Architect engine itself, drawing on proven patterns from spec-kit and OpenSpec.

Editable SKILL.md engine

Swap skills to change behavior

References spec-kit and OpenSpec patterns

Automatic DDD-based code and test generation

Value Objects, Commands, Events, and Aggregates are implemented as real source code following DDD principles, complete with tests. Work is committed task by task and progress is monitored in real time.

VO, Command, Event, and Aggregate implementation

Automatic test code generation

Per-task commits and real-time monitoring

Implementation deliverables report

Tasks and deliverables are summarized in a report by stage: Setup, Domain, Application, API, Frontend, and Test. See clearly which files were created or changed and how many acceptance-criteria tests passed.

Per-stage task and deliverables report

List of created/changed files

Aggregated acceptance-criteria test results

Verify & Accept with two-way sync

The Robo Sync skill runs structural verification (spec vs. implementation) and acceptance criteria (GWT) to confirm the implementation matches the spec. On Accept, the code is merged into main and reflected back into the design in both directions at the same time.

Robo Sync structural and acceptance-criteria verification

Two-way code-to-design sync

Automatic merge to main on Accept

Ontology Studio integration

It flows into the agents' knowledge graph

The domain models Robo Architect designs (Aggregates, domain events, ubiquitous language) accumulate as a knowledge graph in Ontology Studio. As design and implementation build up, the entire system becomes a single ontology (knowledge graph), which AI agents consult to understand the domain and make more accurate changes.

The two products move freely back and forth — explore Robo Architect's designs as a graph in Ontology Studio, and reference the domain knowledge Ontology Studio extracts from documents back into the design as supporting evidence. Spec and knowledge circulate in a single orbit.

Design domain models → accumulated as a knowledge graph (ontology)

AI agents consult the knowledge graph to understand the domain and change it accurately

Document-derived domain knowledge referenced back as design evidence (Neo4j, MCP)

Explore Ontology Studio

Proposal lifecycle

From a single line of requirements to verified code, Robo Architect works through the following flow

1. Write a Proposal

A product owner enters requirements in natural language, and Epics, Features, and User Stories are derived automatically.

2. Impact analysis & task breakdown

The impact on the existing design is analyzed and the implementation task list is composed automatically in tasks.md.

3. Sandbox implementation

In a Git Worktree sandbox, Claude Code skills automatically implement DDD code and tests.

4. Verify & Accept

After verification with Robo Sync, Accept reflects the result into both code and design in both directions.

Why Robo Architect

Robo Architect is not another trendy AI code generator; it is a Spec-Driven Development platform built on proven software engineering principles. With the spec as the Single Source of Truth, it models the problem with Domain-Driven Design (DDD) and verifies it with Behavior-Driven Development (BDD).

DDD · Domain-Driven Design

Business complexity is given clear boundaries through Aggregates and domain events. Even as AI pours out code, the domain model holds the center, so the structure stays sound as the system grows.

BDD · Behavior-Driven Development

Requirements are expressed as Given-When-Then acceptance criteria, so the spec itself becomes an executable test. ‘What should we build’ and ‘Did we build it right’ are linked into one, automatically verifying the accuracy of AI implementation.

SDD · Spec-Driven Development

The spec, not the code, is the source. Because spec and implementation always match through the Proposal lifecycle and two-way sync, change history, impact, and design are managed in one place instead of scattering.

The result: fast AI productivity and enterprise-grade maintainability at the same time — the core domains of large cloud-native systems can evolve safely, with no vendor lock-in.

Comparison Summary

Attribute	Robo Architect	Typical AI coding tools
Development approach	Spec-Driven (the spec is the single source of truth)	Prompt-Driven (the code is the output)
Change management	Per-Proposal history and impact analysis	One-off prompts, no history management
Work isolation	Git Worktree sandbox (no impact on the main project)	Edits the workspace directly
Design integration	Two-way code-to-design sync	Generates code only; design not updated
Engine architecture	Claude Code skills (swappable)	Fixed internal pipeline
Design methodology	Based on DDD and EventStorming	Based on unstructured prompts
Verification	Structural verification + automatic acceptance-criteria (GWT) execution	Mostly manual checks

uEngine Cloud CI/CD and service operations screens

uEngine Cloud integration

Run the services you build in the cloud

Deliverables generated and verified in Robo Architect are deployed to uEngine Cloud. They pass through Git-based CI/CD and run as services on Kubernetes.

uEngine Cloud provides deployment history, instance resources, logs, and monitoring. It also manages new-version deployments and rollbacks, so verified code becomes a live service.

Git-based build and deployment pipeline

Runs services on Kubernetes

Log, monitoring, and rollback management

Explore uEngine Cloud

Get started today!

Manage everything from requirements to verified code in one flow with the Robo Architect Proposal lifecycle.
It is 100% browser-based, so you can start right away with nothing to install.

GitHub Watch the demo

Have more questions?

Want to learn more about Robo Architect or have a question? Reach out anytime.

Contact us

Contact Us

Name *

Email *

Company *

Job Title

Message *

(Required) to the terms above.