Loading...

Spec-Driven Development

Robo Architect

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

Download Tutorial Watch the demo Download the product brochure (PDF)

Desktop app Robo Architect Lite · macOS (Apple Silicon) · Windows (x64) · Installation · 15-chapter hands-on tutorial · GitHub

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.

HOW ROBO ARCHITECT WORKS

Connect business intent to design and code

Bring existing system knowledge and new requirements into a shared specification. Robo Architect turns that specification into domains, screens and implementation tasks, then reconciles it with changes in code.

01 / WORKFLOW

From business knowledge to verified implementation

For an existing system, Robo Analyzer extracts business rules first. New development can start directly from requirements, then follow the same design and verification workflow.

  1. 01Robo Analyzer

    Extract business knowledge

    Structure logic and relationships from code, databases and documents

    Business logic inventory
  2. 02Robo Architect

    Clarify requirements

    Break work into Epics, Features and User Stories; ask about ambiguous conditions

    Given · When · Then
  3. 03Robo Architect

    Design domains and tasks

    Define DDD boundaries and derive plans and implementation tasks

    Bounded Context · Plan · Task
  4. 04UI/UX design integration

    Connect events to screens

    Design user actions, business events and visible outcomes together

    Event Model · Wireframe
  5. 05IDE · Coding Agent

    Implement and verify

    Pass on design and tasks; check results against acceptance criteria

    MCP · Code · Test
02 / DOMAIN DESIGN

Turn business boundaries into implementation units

A bounded context is a business boundary with consistent language and rules. Match the design approach to the complexity of core and supporting domains, then prepare work within each boundary.

CORE DOMAIN

Core domain

Where business rules differentiate the product. Place entities and use cases at the center, separating domain logic from changes in external UI and databases.

UI · DB · FrameworksUse CasesDomain Model
SUPPORTING DOMAIN

Supporting domain

For standardized management work, use layers, transaction scripts and templates with the level of complexity the work requires.

PresentationTransaction ScriptData Access
DDD model
Order context↓
Plan · Context design
↓
Task · Implementation · Tests
Inventory context↓
Plan · Context design
↓
Task · Implementation · Tests
Settlement context↓
Plan · Context design
↓
Task · Implementation · Tests
Modernization preserves business intent while redesigning transaction boundaries. Splitting one ACID transaction requires local transactions within each context and a SAGA compensation flow for failures.
03 / EVENT MODELING & UI

Trace user actions to business outcomes and screens

Model who makes a request, what fact occurs, and what the user sees in one flow. This gives screens and domain logic a shared design basis.

Order management example
ActorCustomerWho starts the flow?
CommandPlace orderWhat is requested?
EventOrder placedWhat fact has occurred?
Read ModelOrder overviewWhat does the screen show?
Order management
COMMAND

Order form

Product · Quantity · Address
Place order
EVENT✓ Your order has been placed
READ MODEL

Order overview

OrderStatusQty
ORD-001Received2
Forms and buttons connect to CommandsState changes are recorded as EventsLists and summaries display Read Models

The event model is the connection point for UI/UX design. Compare input and output changes in Figma or other wireframes against the same model to reduce mismatches with domain design.

04 / CONTINUOUS ALIGNMENT

Keep specifications and code in a shared change cycle

Both implementing a design and reflecting development changes back into the design matter. Robo Architect connects these two directions through specifications and verification criteria.

SPEC

Domain specifications and design

Requirements · Acceptance criteria · Plan/Task

Spec AlignSpecification changes into code →
Review · Verify · Accept
Spec Backfill← Code changes into specifications
CODE

Implementation and tests

Services · UI · Data access

Spec AlignAnalyze the impact of specification changes so the coding agent can update the implementation and tests.

Spec BackfillAnalyze the meaning of code changes and reflect them back into the domain model and specifications.

Spec → Design → Implementation → Verification → Spec. Each change builds on the same shared basis.

Key Features

Natural-language requirements input

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
Or start from a requirements document
AI analysis starts automatically
Strategic and Tactical Diff

Proposal-based change management

From the requirements you enter, bounded contexts, features, and user stories (strategic design) and aggregates, commands, and events (tactical design) are derived automatically. Every change is managed as one Proposal, so its history can be traced.

Automatic strategic and tactical Diff generation
Automatic derivation of BCs, features, and stories
Change history tracking and management
Change Impact Map

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
BDD acceptance criteria

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

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 EventStorming design

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
Sandbox task list

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
Claude Code skill engine

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 files

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 code generation

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

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 and Accept

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
Project Constitution

Set the project constitution

Before planning, set the design principles, tech stack, architecture style, and repository strategy once, as a Constitution. Claude Code reads the Proposal and offers questions and recommendations, so you only pick the answers; from then on, every Plan decision cites the constitution passage it rests on.

A constitution built from questions and recommendations
Constitution rationale on every Plan decision
Where the constitution is silent: "Constitution Gap"
Legacy code analysis screen

New design grounded in legacy analysis

Analyze a running legacy system (Java and DDL) into a code graph, business rules, and a data schema, and a new Proposal is designed on top of that analysis. The legacy rules and tables carry over into the new service's acceptance criteria and data structures.

Code graph and business rule extraction
Data schema of tables and columns
Proposals backed by legacy evidence
Data source connection screen

Connect production databases through the data fabric

Register a running database (PostgreSQL, MySQL, MariaDB) as a data source and its real tables show up right away; that connection becomes the source for legacy analysis and the data schema. Ontological DB and the data fabric start up with the desktop app.

Test the connection, then register the data source
Browse the real tables right away
Source for legacy analysis and the data schema
Starting a design from a requirements document

Start designing from a requirements document

Paste an entire requirements document into a new Proposal, and Claude Code splits the whole document into bounded contexts, features, user stories, acceptance criteria, and processes. Even a long planning document becomes the starting point for the design as is.

Paste the whole document
Automatic breakdown into BCs, features, stories, and acceptance criteria
Runs on Claude Code on your own computer

Watch the Videos

A walkthrough video for each tutorial chapter, recorded on the real app. Click a thumbnail to play it — Full playlist · Tutorial

At a Glance

Robo Architect Lite: Full Tour

The whole Lite flow in one video: from a one-line requirement through design, implementation, validation, and acceptance, to change impact and legacy analysis.

Chapter 0 · Introduction

Start with the whole path the tutorial takes: proposal → constitution → Plan → implementation → validation → acceptance.

Getting started

Chapter 1 · Install and create your first project

Install the desktop app, check that the graph DB and analysis services come up with it, then open your first project.

Chapter 2 · A tour of the screens

One lap around the tab strip, Home, and the seven screens: Proposals, Requirements, Process, Design, Data, Code, and Legacy.

Proposal lifecycle

Chapter 3 · Create a proposal — from one requirement to strategic design

Create a proposal from a one-line requirement, then read the strategic design Claude Code breaks it into and the Impact Map.

Chapter 4 · Set the project constitution

Answer questions, with recommended options, to set the design principles, tech stack, architecture style, and repository strategy as the constitution.

Chapter 5 · Plan — tactical design and architecture

Aggregates, commands, events, and architecture decisions come out together with their constitution rationale.

Chapter 6 · Implement in a sandbox

Generate the task list, and the Claude Code cell in the Code tab implements it item by item in the sandbox worktree.

Chapter 7 · Validate and accept

Check the implementation against structural validation and acceptance criteria, then merge code and design together with Accept (Dual Merge).

Design and change

Chapter 8 · Tour the design — Requirements · Process · Design · Data

Look at the accepted design four ways: Requirements, Process, the design canvas, and Data.

Chapter 9 · A second proposal — change impact

See what a new requirement creates (CREATE) and what it modifies (MODIFY) in the existing design.

Chapter 10 · Change the engine with skill files

Add one rule line to SKILL.md and compare how the engine's output changes.

Legacy and data

Chapter 11 · Connect data sources — the data fabric

Register a running PostgreSQL database as a data source and see its real tables.

Chapter 12 · Start a design from a requirements document

Paste in one document and split it into bounded contexts, features, stories, and processes.

Chapter 13 · Analyze legacy code

Design a new feature as a proposal, grounded in the graph from analyzing the old order system.

Final project

Chapter 14 · Final project — add reviews

Run the whole flow so far once more, end to end, on your own.

Ontology Studio knowledge graph

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 (Ontological DB, 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 plain language, and bounded contexts, 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 approachSpec-Driven (the spec is the single source of truth)Prompt-Driven (the code is the output)
Change managementPer-Proposal history and impact analysisOne-off prompts, no history management
Work isolationGit Worktree sandbox (no impact on the main project)Edits the workspace directly
Design integrationTwo-way code-to-design syncGenerates code only; design not updated
Engine architectureClaude Code skills (swappable)Fixed internal pipeline
Design methodologyBased on DDD and EventStormingBased on unstructured prompts
VerificationStructural verification + automatic acceptance-criteria (GWT) executionMostly 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

Download

Install it and try it now

Install the desktop app Robo Architect Lite, and the graph DB (Ontological DB), the data fabric and the legacy analysis services come up together on Docker on this computer. Analysis, planning and implementation of proposals are done by Claude Code signed in on this computer, so no API key is needed.

macOS (Apple Silicon)

Macs with M1 or later · Download the DMG, open it and drag the app to Applications. (To check your chip: 🍎 menu → About This Mac)

Apple Silicon (M1 or later) (.dmg)
First install — allow it once in security settings
  1. Open the DMG and drag Robo Architect Lite to Applications.
  2. Open the app. When macOS says it “could not verify ‘Robo Architect Lite’ is free of malware”, click Done.
  3. Open System Settings › Privacy & Security, and under Security near the bottom click Open Anyway next to Robo Architect Lite, then enter your password.
  4. In the dialog that appears, click Open. From then on the app opens normally.

The build is not notarized by Apple yet, so this is needed only the first time. On macOS 14 and earlier you can also right-click the app and choose Open. Details: installation guide

Windows

Windows 10/11 (x64) · Run the installer.

Download for Windows (.exe)
First install — allow it once in SmartScreen
  1. Run the installer you downloaded.
  2. When “Windows protected your PC” appears, click More info, then Run anyway.
  3. Choose where to install and finish. No administrator rights needed.
  4. On the last screen, clear the Run check box, then open Robo Architect Lite from the Start menu.

You see this because the build is not code-signed yet. Keep Docker Desktop running on the WSL 2 backend (Linux containers), and note that Claude Code needs Git for Windows. Details: installation guide

Install Docker Desktop and keep it running. The app starts and stops the seven containers itself.
Install Claude Code and sign in (running claude in a terminal works).
The first launch downloads the seven container images (about 1.1 GB). Home shows the progress, and later launches skip the download.
Recommended: 16 GB of memory or more and at least 6 GB of free disk space.

Installers: GitHub Releases · Source: uengine-oss/robo-architect

Get started today!

Manage everything from requirements to verified code in one flow with the Robo Architect Proposal lifecycle.
Install one desktop app (Lite) and Ontological DB and the data fabric come up with it — follow the tutorial from your first proposal all the way to implementation.

Download Tutorial Watch the demo Download the product brochure (PDF)

Have more questions?

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

Contact us