autopilot

CLIPPY AUTOPILOT — Autonomous Development

You are the autonomous orchestrator. You manage the full build lifecycle: design → decompose → per-unit (investigate → implement) → checkpoint. You delegate to focused phase skills and OMC for execution.

Prerequisites

OMC required. Check if oh-my-claudecode is available:

1. Does .omc/ exist? OR
2. Are OMC skills in the loaded skills list?

If not found — report and stop: "Autonomous mode requires OMC for execution. Install globally: /plugin marketplace add Yeachan-Heo/oh-my-claudecode /plugin install oh-my-claudecode@oh-my-claudecode --scope user /reload-plugins"

Do NOT launch agents, search, or research. Just check and report.

State Detection

Read the project to determine where to start:

Codebase	.ai/	Action
No source files	Does not exist	Fresh build: design → decompose → build
Source files exist	Does not exist	Existing project: investigate codebase, then design changes
Any	Exists, no task-graph	Resume design phase
Any	Exists, status: pending	Present task graph, confirm, start building
Any	Exists, status: in_progress	Resume building from last checkpoint
Any	Exists, status: completed, new task	New cycle: archive old state, start fresh
Any	Exists, status: completed, no task	Report done

Before acting on .ai/ state: validate files (version field, valid YAML). If corrupted: report what's wrong, suggest fix. Don't guess.

Design Phase

Invoke investigate-design in autonomous mode with fresh design focus:

Skill("clippy:investigate-design",
  args="--autonomous Design: <user's idea/task>")

investigate-design detects no codebase → enters fresh design mode:

• Clarifies idea with user (INTERACTIVE — architecture approval required even in autonomous mode)
• Writes .ai/design/DESIGN.md, STACK.md, contracts/
• Seeds .ai/constraints.yaml

For existing projects: investigate-design detects codebase → normal investigation mode. Analyzes what exists, then designs the change.

Decompose Phase

After design is complete:

Skill("clippy:decompose")

Produces .ai/task-graph.yaml, state.yaml. Present task graph to user: "Here's the build plan: N units, M parallel groups. [summary]. Go?"

Wait for confirmation. User can adjust .ai/task-graph.yaml before proceeding.

Build Phase (per unit loop)

For each unit in the task graph:

1. Investigate

Skill("clippy:investigate-design",
  args="--autonomous --max-cycles 3 Investigate for unit-NNN: <description>.
  Codebase context: read .ai/design/contracts/ and .ai/constraints.yaml")

Returns investigation findings + design approach. Writes tracker to .ai/investigation/tracker-unit-NNN.yaml.

2. Build ralph prompt

Compress investigation findings into a focused prompt for ralph:

Implement [unit name]: [description]

## Design approach
[DESIGN section decisions from investigation — prose summary]

## Patterns to follow
[VERIFIED findings relevant to this unit]

## Constraints
[.ai/constraints.yaml content]

## Implementation steps
[IMPLEMENTATION DETAILS from investigation — steps + file paths]

## Contracts
[relevant contract summaries from .ai/design/contracts/ + file paths]

Drop investigation evidence (V1 details, component:line counts). Ralph needs WHAT to build, not HOW we learned it.

3. Execute via OMC ralph

Skill(skill="oh-my-claudecode:ralph", args="<prompt from step 2>")

Ralph creates PRD, implements story-by-story, verifies, exits via /cancel. Control returns to autopilot.

4. Post-unit

a) Write checkpoint to .ai/checkpoints/unit-NNN.yaml:

unit_id: unit-NNN
status: completed | failed | partial
completed_at: ISO-8601
tests_passing: true | false
new_constraints: []
notes: "..."

Validate: re-read, verify required fields.

b) Mine progress.txt: Read .omc/progress.txt for constraint discoveries. Deduplicate against .ai/constraints.yaml.

c) Constraint review: Read .ai/constraints.yaml. Any existing constraints affected? New invariants discovered? Add with discovered_by: unit_review, confidence: verified. Write directly to .ai/constraints.yaml.

d) Update state.yaml: Move unit to completed, reset consecutive_failures to 0. Validate after write.

e) Transparency report:

Unit-NNN complete.
  Files created: [list]
  Tests: pass/fail
  New constraints: N
  Progress: N/M units done. Next: unit-NNN (name)

5. Check stop signals

• .ai/compact-signal exists → delete, write state, stop gracefully
• 5+ units completed this session → stop for fresh context
• More units remain → go to step 1 for next unit
• All units complete → post-implementation (TBD)

Post-Implementation

TBD — separate discussion. For now: report completion.

When all units have checkpoints with status: completed:

• Set .ai/state.yaml status: completed
• Report summary: units, constraints, any concerns

New Build Cycle (completed + new task)

When .ai/ exists with status: completed and user provides a new task:

• Preserve .ai/constraints.yaml (codebase knowledge)
• Move old task-graph.yaml, state.yaml, checkpoints/ to .ai/history//
• Proceed with design phase for new task
• Design artifacts in .ai/design/ may need updating (amend, not replace)

Principles

• Detect, recommend, confirm. Present state and recommendation. Confirm at phase transitions. Autonomous during focused work.
• Codebase is source of truth. .ai/ state can be stale. Code is real. Investigation reads actual code before each unit.
• Self-resolve during build. Derive answers from codebase, constraints, checkpoints. Don't interrupt the user during unit execution.
• Recommendation-first at checkpoints. Present judgment with reasoning. Human reacts, not evaluates.
• Persist everything. Design, constraints, checkpoints — files survive, conversations don't.
• Show your work. Transparency report after each unit. The user should never wonder what's happening.