Autonomous Development Engine (ADE)

Transform requirements into production code with AIOX’s autonomous development system

What is ADE?

The Autonomous Development Engine (ADE) is AIOX’s revolutionary system for autonomous software development. It transforms vague requirements into production-ready code through structured pipelines and specialized AI agents.

ADE enables truly autonomous development: from gathering requirements to shipping working code, with built-in recovery, quality gates, and learning.

The 7 ADE Epics

ADE is composed of seven interconnected systems that work together to enable autonomous development:

Epic 1: Worktree Manager

Isolates work in Git worktrees for safe parallel development

Epic 2: Migration V2→V3

Migrates agents to autoClaude V3 format

Epic 3: Spec Pipeline

Transforms requirements into executable specifications

Epic 4: Execution Engine

Executes specs with 13-step Coder Agent workflow

Epic 5: Recovery System

Automatically recovers from failures

Epic 6: QA Evolution

Structured 10-phase quality review

Epic 7: Memory Layer

Learns and documents patterns for future use

Architecture Flow

Epic 1: Worktree Manager

Isolates development work in separate Git worktrees, enabling parallel development without branch conflicts.

Commands (@devops)

Create Worktree

@devops *create-worktree STORY-42

Benefits

• Safe Isolation: Each story gets its own working directory
• Parallel Work: Multiple stories can be developed simultaneously
• Easy Cleanup: Remove completed worktrees without affecting main branch

Epic 2: Migration V2→V3

Migrates agent definitions from autoClaude V2 to the new V3 format with enhanced capabilities.

Commands (@devops)

Inventory Assets

@devops *inventory-assets

autoClaude V3 Format

autoClaude:
  version: '3.0'
  migratedAt: '2026-01-29T02:24:10.724Z'

  specPipeline:
    canGather: boolean      # @pm
    canAssess: boolean      # @architect
    canResearch: boolean    # @analyst
    canWrite: boolean       # @pm
    canCritique: boolean    # @qa

  execution:
    canCreatePlan: boolean  # @architect
    canCreateContext: boolean # @architect
    canExecute: boolean     # @dev
    canVerify: boolean      # @dev

  recovery:
    canTrackAttempts: boolean # @dev
    canRollback: boolean    # @dev

  qa:
    canReview: boolean      # @qa
    canRequestFix: boolean  # @qa

  memory:
    canCaptureInsights: boolean # @dev
    canExtractPatterns: boolean # @analyst
    canDocumentGotchas: boolean # @dev

Epic 3: Spec Pipeline

Transforms vague user requirements into detailed, executable specifications through a multi-agent collaboration process.

Pipeline Phases

1. Gather Requirements

   @pm collects and documents user needs

   @pm *gather-requirements
   
2. Assess Complexity

   @architect evaluates technical complexity and identifies risks

   @architect *assess-complexity
   
3. Research Dependencies

   @analyst investigates required libraries, APIs, and patterns

   @analyst *research-deps
   
4. Write Specification

   @pm creates detailed executable spec

   @pm *write-spec
   
5. Critique & Approve

   @qa reviews and approves or requests changes

   @qa *critique-spec
   

Spec Output

The pipeline produces a spec.yaml file containing:

• User Story: What and why
• Acceptance Criteria: Success conditions
• Technical Approach: Implementation strategy
• Dependencies: Required packages and APIs
• Risks: Potential issues and mitigations
• Subtasks: Breakdown of work

Epic 4: Execution Engine

Executes approved specs using the 13-Step Coder Agent workflow with mandatory self-critique.

The 13 Steps

Steps 1-3: Context Loading

1. Load Context - Read project structure, tech stack
2. Read Implementation Plan - Load implementation.yaml
3. Understand Current Subtask - Parse requirements

Steps 4-5: Code Implementation

4. Plan Approach - Design solution
5. Write Code - Implement solution
   • 5.5 SELF-CRITIQUE (mandatory) - Review own code

Steps 6-9: Testing & Quality

6. Run Tests - Execute test suite
   • 6.5 SELF-CRITIQUE (mandatory) - Evaluate test results
7. Fix Issues - Address failing tests
8. Run Linter - Check code style
9. Fix Lint Issues - Resolve violations

Steps 10-13: Completion

10. Verify Manually - Smoke test functionality
11. Update Plan Status - Mark subtask complete
12. Commit Changes - Git commit with message
13. Signal Completion - Notify orchestrator

Commands

Create Implementation Plan

@architect *create-plan

Self-Critique

The Execution Engine enforces mandatory self-critique at steps 5.5 and 6.5:

selfCritique:
  required: true
  checklistRef: 'self-critique-checklist.md'
  phases:
    - code_quality
    - test_coverage
    - edge_cases
    - error_handling

Epic 5: Recovery System

Automatically detects and recovers from failures during subtask execution.

Recovery Flow

Commands (@dev)

Track Attempt

@dev *track-attempt

Automatic Features

• Attempt Tracking: Records each implementation try
• Stuck Detection: Identifies repeating failures
• Smart Rollback: Returns to last known good state
• Human Escalation: Notifies when intervention needed

Epic 6: QA Evolution

Structured 10-phase quality review process that ensures code quality before shipping.

10 Review Phases

1. Setup & Context Loading

   Load story, specs, and changed files

2. Code Quality Analysis

   Check patterns, practices, architecture

3. Test Coverage Review

   Verify tests exist and are comprehensive

4. Security Scan

   Identify vulnerabilities and risks

5. Performance Check

   Analyze for bottlenecks and inefficiencies

6. Documentation Audit

   Ensure code is well-documented

7. Accessibility Review

   Check WCAG compliance for UI changes

8. Integration Points Check

   Verify API contracts and dependencies

9. Edge Cases & Error Handling

   Test boundary conditions and failures

10. Final Summary & Decision

    PASS, CONCERNS, FAIL, or WAIVED

Commands (@qa)

Full Review

@qa *review-build STORY-42

QA Decisions

Decision	Meaning	Next Action
PASS	Ready to ship	Merge to main
CONCERNS	Approved with follow-ups	Ship with tech debt story
FAIL	Needs fixes	Return to @dev
WAIVED	Bypass authorized	Requires @po approval

Epic 7: Memory Layer

Persistent memory system that captures and reuses patterns, insights, and gotchas.

Memory Types

Insights

Discoveries during development sessions

Patterns

Reusable code patterns extracted from implementations

Gotchas

Known pitfalls and how to avoid them

Decisions

Architectural and technical decisions

Commands

Capture Insights (@dev)

@dev *capture-insights

Memory Structure

.aiox-core/memory/
├── insights/
│   ├── 2026-01-15-auth-flow.md
│   └── 2026-01-20-performance.md
├── patterns/
│   ├── api-error-handling.md
│   └── state-management.md
├── gotchas/
│   ├── async-race-conditions.yaml
│   └── dependency-conflicts.yaml
└── decisions/
    ├── tech-stack.md
    └── architecture.md

Complete ADE Workflow

Here’s a full example of using all ADE epics together:

1. Create Spec

   @pm *gather-requirements
   @architect *assess-complexity
   @analyst *research-deps
   @pm *write-spec
   @qa *critique-spec
   
2. Prepare Execution

   @devops *create-worktree STORY-42
   @architect *create-plan
   @architect *create-context
   
3. Execute Subtasks

   @dev *execute-subtask 1.1
   @dev *execute-subtask 1.2
   # Recovery kicks in automatically if needed
   
4. QA Review

   @qa *review-build STORY-42
   # If issues found:
   @qa *request-fix "Issue description"
   @dev *apply-qa-fix
   @qa *verify-fix
   
5. Capture Learning

   @dev *capture-insights
   @analyst *extract-patterns
   
6. Merge & Ship

   @devops *merge-worktree STORY-42
   @devops *cleanup-worktrees
   

QA Gates

Each Epic has a quality gate that must pass before proceeding:

@qa *gate epic-{N}-{name}

Possible Outcomes:

• PASS - Next epic unlocked
• CONCERNS - Approved with follow-ups
• FAIL - Return for fixes
• WAIVED - Bypass authorized by @po

Related Documentation

Agent Reference

See all agent capabilities and commands

Custom Agents

Create your own agents with ADE capabilities

Squads System

Organize agents into specialized teams

IDE Integration

Set up ADE in your development environment

Troubleshooting

Subtask Fails Repeatedly

# Check attempt history
@dev *track-attempt --status

# Rollback to last good state
@dev *rollback --hard

# Try alternative approach
@dev *execute-subtask 2.1 --approach alternative

Spec Not Approved

# View critique feedback
cat docs/stories/STORY-42/spec-critique.json

# Refine spec
@pm *write-spec --iterate

# Re-submit
@qa *critique-spec

Worktree Conflicts

# List active worktrees
@devops *list-worktrees

# Resolve conflicts
@devops *merge-worktree STORY-42 --resolve

# Cleanup
@devops *cleanup-worktrees

Version: 1.0.0 | Status: Production Ready ✅