Type /autopilot to see available actions from BMAD, ECC, and UI/UX skills based on your project phase
A menu-driven orchestrator that discovers commands at runtime from everything-claude-code, BMAD-METHOD, and UI UX Pro Max, then lets you pick what to do next.
Quick Start • Usage • How It Works • Phase Detection • Architecture • Contributing
claude-autopilot is NOT a fork or bundle of ECC, BMAD, or UI UX Pro Max. It does not include any framework — you install them separately. What it provides is a thin orchestration layer that:
- Detects your project's lifecycle phase on every session start
- Discovers available commands from all installed frameworks at runtime
- Presents a unified menu of phase-relevant actions
- Executes your choice by invoking the right framework
- Loops — after each action completes, re-detects the phase and shows updated options
No hardcoded command lists. No behavioral routing. Just a menu that adapts to your project state.
ECC by Affaan Mustafa is a comprehensive toolkit that optimizes Claude Code's behavior during implementation. It installs globally into ~/.claude/ and provides:
- Rules — language-specific coding standards (Python, TypeScript, Go, etc.)
- Hooks — auto-formatting, type-checking, security scanning on every code change
- Skills — TDD workflows, code review, continuous learning
- Agents — specialized sub-agents for exploration, testing, and review
ECC makes Claude write better code, but it doesn't help you figure out what to build.
BMAD-METHOD by Brian (BMad) Madison is a structured agile workflow system for planning and design. It installs per-project and provides:
- Guided workflows — brainstorming, requirements elicitation, architecture design, story creation
- Document templates — product briefs, PRDs, architecture docs, user stories with acceptance criteria
- Phase-aware commands — each workflow is tagged with the lifecycle phase it belongs to
BMAD ensures you build the right thing, but it doesn't optimize the AI agent during coding.
UI UX Pro Max by NextLevelBuilder is a skill suite that brings design intelligence to Claude Code. It installs per-project or globally into ~/.claude/skills/ and provides:
- Style Search — BM25 search engine across 67 UI styles, 161 color palettes, 57 font pairings, 99 UX guidelines
- Design Tokens — Three-layer architecture (primitive, semantic, component) with CSS variables and Tailwind config
- Brand Identity — Voice, visual identity, and messaging framework generation
- UI Styling — shadcn/ui + Tailwind CSS patterns with accessibility and dark mode support
UI UX Pro Max fills the design gap between BMAD's planning outputs and ECC's implementation agents. It is optional — autopilot works fine without it, but surfaces its skills when detected.
BMAD and ECC aren't just different tools — they have fundamentally different execution models, and each is stronger where the other is weak.
BMAD workflows execute as step-file sequences loaded inline in your main Claude session. Each step is a detailed markdown file (often 400+ lines) with menus, user checkpoints, and frontmatter-based state tracking. BMAD "agents" (like the Architect or Analyst) are actually persona instructions — Claude adopts a communication style and presents a capability menu, but it's the same Claude instance doing all the work in the same context window, on the same model.
ECC agents are real sub-processes. When you dispatch an ECC agent (like code-reviewer or tdd-guide), Claude Code spawns a separate instance with a focused system prompt, running on a dedicated model. A code review runs on Sonnet instead of Opus. A doc update runs on Haiku. Each agent gets a fresh context — not polluted by your 50-message planning conversation.
This creates a natural split:
| Capability | BMAD | ECC | UI UX Pro Max |
|---|---|---|---|
| Guided multi-step workflows | Strong (step files, menus, state tracking) | Weak (no guided flow) | None |
| User interaction mid-task | Strong (A/P/C menus, approval gates) | Weak (fire-and-forget agents) | None |
| Task execution quality | Average (same Claude, growing context) | Strong (fresh context, focused prompt) | Strong (data-driven design decisions) |
| Cost efficiency | None (runs on main session model) | Strong (model-optimized per agent) | Strong (skills run inline) |
| Auto-formatting, type-checking | None | Strong (hooks run on every edit) | None |
| Design system generation | None | None | Strong (67 styles, 161 palettes, 57 fonts) |
| Brand identity & UX guidelines | None | None | Strong (99 UX guidelines, anti-patterns) |
BMAD excels at planning — guiding you from idea to stories with structured workflows and user interaction at every step. ECC excels at implementation — delegating coding, testing, and review to specialized agents on cost-appropriate models, with hooks that enforce quality on every edit. UI UX Pro Max excels at design — providing data-driven design decisions with industry-specific reasoning rules across styles, colors, typography, and UX guidelines.
No single framework covers the full lifecycle. Together, you get guided planning that produces high-quality artifacts, data-driven design systems, and agent-driven implementation with cost optimization and automated quality gates.
None of these frameworks knows about the others. If you install all three, you need to manually decide when to use BMAD workflows vs ECC agents vs UI/UX skills, which slash commands to run, and how to transition between planning, design, and building. claude-autopilot fills this gap — one menu that shows the right tool from any installed framework based on where you are.
- Claude Code >= v2.1.0
- everything-claude-code installed
- BMAD-METHOD installed (
npx bmad-method install) - UI UX Pro Max (optional) — adds design intelligence (
npm install -g uipro-cli && uipro init --ai claude)
# Clone this repo
git clone https://github.com/anuj142003/claude-autopilot.git
# Navigate to your project
cd ~/your-project
# Run the installer (will check prerequisites first)
bash /path/to/claude-autopilot/install.sh
# Or skip prerequisite checks if you'll install ECC/BMAD later
bash /path/to/claude-autopilot/install.sh --force
# Or auto-accept all prerequisite installation prompts
bash /path/to/claude-autopilot/install.sh --auto-install# Uninstall (removes autopilot files, keeps your artifacts)
bash /path/to/claude-autopilot/uninstall.shThe installer will:
- Check prerequisites and offer to install missing ones (Claude Code, ECC, BMAD) interactively
- Merge hooks into your existing
.claude/settings.json(preserving your permissions, env vars, etc.) - Copy the detection script and orchestration rules
- Install the
/autopilotcommand - Create
_bmad-output/directories for artifact storage
Note: The installer requires
python3for safe JSON merging. It will fail gracefully and tell you what to do manually ifpython3is not available.
cd ~/your-project
claude
# Type: /autopilotWhen you start a Claude Code session, the SessionStart hook detects your project phase and displays:
═══════════════════════════════════════════════════════════
Type /autopilot to see available actions for this phase
═══════════════════════════════════════════════════════════
Type /autopilot and you get a menu like this:
════════════════════════════════════════════════
AUTOPILOT — Phase: PLANNING
════════════════════════════════════════════════
BMAD Workflows:
[CP] Create PRD — Generate product requirements document (bmad-core)
[CA] Create Architecture — Design system architecture (bmad-core)
[DE] Deep Exploration — Research and analyze a topic (bmad-core)
ECC Agents:
[planner] Create implementation plan (model: opus)
[architect] System design decisions (model: sonnet)
[security-reviewer] Security analysis (model: sonnet)
UI/UX Design Skills:
[ui-ux-pro-max] Design intelligence — styles, palettes, fonts, UX guidelines
[design-system] Generate design tokens (primitive, semantic, component)
[brand] Brand voice and visual identity framework
Other:
[H] Show ALL available commands (all phases)
[Q] Exit autopilot
Pick an option, or describe what you want to do.
Pick an option by typing its code, or describe what you want in plain language. After the action completes, autopilot re-detects the phase (artifacts may have changed) and shows an updated menu.
You type: /autopilot
|
v
[1. Detect Phase]
| Check _bmad-output/ artifacts + source code
| Determine: IDEATION / PLANNING / BUILDING / etc.
|
v
[2. Discover Commands]
| BMAD: Parse ~/.bmad/cache/**/module-help.csv
| Filter rows by phase column
| ECC: Glob ~/.claude/agents/*.md
| Read frontmatter (name, description, model)
| Filter by phase relevance
| UI/UX: Glob ~/.claude/skills/*/SKILL.md
| Discover installed design skills
| Filter by phase relevance
|
v
[3. Present Menu]
| Show phase-relevant actions from both frameworks
| Group by source (BMAD / ECC)
|
v
[4. Execute Choice]
| BMAD workflow → invoke via Skill tool
| ECC agent → dispatch via Agent tool
| UI/UX skill → invoke via Skill tool
|
v
[5. Loop]
Re-detect phase → updated menu → next action
The detection script inspects your project directory and determines the lifecycle phase:
| Phase | Trigger | Available Actions |
|---|---|---|
IDEATION |
No artifacts, no source code | BMAD brainstorming and ideation workflows |
PLANNING_INFORMAL |
No BMAD artifacts, but docs exist in docs/, plans/, etc. |
Design work exists outside BMAD format — build from it, formalize it, or enhance with UI/UX skills |
ANALYSIS |
BMAD dir exists, no brief/PRD | BMAD analysis and research workflows |
PLANNING |
Product brief exists, no PRD | BMAD requirements and PRD creation workflows |
SOLUTIONING |
PRD exists, no architecture doc | BMAD architecture and design workflows |
STORY_CREATION |
PRD + architecture, no stories | BMAD story creation and sprint planning workflows |
READY_TO_BUILD |
Stories exist, no source code | ECC agents for planning, TDD, and implementation |
BUILDING |
Stories + source code exist | ECC agents for coding, testing, reviewing, and security |
BROWNFIELD |
Source code but no BMAD artifacts | ECC agents for implementation; BMAD workflows available on request |
Phase detection depends on artifacts being saved to the right locations:
_bmad-output/
product-brief.md # ANALYSIS -> PLANNING
prd.md # PLANNING -> SOLUTIONING
architecture.md # SOLUTIONING -> STORY_CREATION
ux-design.md # Optional
design-tokens.md # Optional (UI UX Pro Max)
brand-guide.md # Optional (UI UX Pro Max)
component-specs.md # Optional (UI UX Pro Max)
stories/ # STORY_CREATION -> READY_TO_BUILD
epic-name/
story-name.md
sprints/ # Sprint tracking
retros/ # Retrospectives
Two components:
A lightweight shell script that runs on every session start. It scans for BMAD artifacts and source code to determine the lifecycle phase, then outputs a one-liner nudging the user to type /autopilot. No behavioral routing, no persona assignments — just phase detection and a hint.
The core orchestrator. A Claude Code command skill that implements the menu-driven loop: detect phase, discover commands from both frameworks at runtime, present a unified menu, execute the user's choice, and loop. It never hardcodes command lists — it parses BMAD's module-help.csv files and reads ECC agent frontmatter on every invocation.
claude-autopilot/
CLAUDE.md # Minimal — mentions /autopilot exists
install.sh # One-command installer with safety checks
uninstall.sh # Removes autopilot files, keeps artifacts
.claude/
settings.json # SessionStart hook configuration
commands/
autopilot.md # Menu-driven command router
hooks/
detect-project-state.sh # Project state detection script
rules/
unified-orchestration.md # Artifact conventions
docs/
ECC-vs-BMAD-Analysis-Report.pdf # Detailed comparison of both frameworks
ECC-BMAD-Setup-Guide.pdf # Step-by-step setup guide
During BUILDING phases, /autopilot shows which model each ECC agent runs on, so you can make informed cost decisions:
| Agent | Model | Use Case |
|---|---|---|
| planner | Opus | Deep reasoning for implementation plans |
| tdd-guide | Sonnet | Test-driven development workflow |
| code-reviewer | Sonnet | Code quality and architecture review |
| security-reviewer | Sonnet | Security analysis |
| doc-updater | Haiku | Lightweight documentation updates |
The main session handles only menu presentation and user interaction. Bulk work is delegated to agents running on the appropriate model tier — use Haiku for lightweight tasks and Opus only when deep reasoning is needed.
...just using ECC? ECC has powerful agents and hooks for implementation, but no guided workflow for planning. You'd need to know which of the 28+ agents to dispatch, when, and in what order. There's no step-by-step process that takes you from idea to stories — you jump straight to code.
...just using BMAD? BMAD has excellent guided workflows for planning, but its "agents" are just persona instructions — the same Claude instance role-playing different characters in the same session. During implementation, there's no agent delegation to cheaper models, no hooks for auto-formatting or type-checking, and no specialized sub-processes for code review or security scanning.
...just using UI UX Pro Max? Great design intelligence, but no guided planning workflow and no implementation agents. You'd get a design system but need to figure out the rest yourself.
...using all three manually? You'd need to know that BMAD has 60+ workflows spread across 4 modules, ECC has 28+ agents, and UI UX Pro Max has 7 design skills — which ones apply to your current phase, how to invoke them, and when to switch between planning, design, and building. /autopilot discovers all of this at runtime and presents one menu — no framework knowledge required.
- Explicit invocation required —
/autopilotis a command-based system; it must be explicitly typed at the start of each session to activate the menu - Artifact path convention — Phase detection depends on planning artifacts being saved to the
_bmad-output/directory at the expected paths; artifacts saved elsewhere will not be detected - Separate prerequisites — BMAD, ECC, and UI UX Pro Max must be installed independently (though the installer can walk you through BMAD and ECC interactively)
- Runtime discovery — The menu contents are discovered at runtime from installed frameworks, so what you see depends on what is currently installed
Contributions are welcome! See CONTRIBUTING.md for guidelines.
Ideas for contributions:
- Improve
/autopilotcommand menu UX - Better phase-to-BMAD-phase mapping in the CSV filter
- Support for additional BMAD modules
- Automated end-to-end testing of the
/autopilotflow - Additional phase detection patterns (CI/CD status, branch naming)
- Support for additional AI coding frameworks
- everything-claude-code by Affaan Mustafa — the agent optimization layer
- BMAD-METHOD by Brian (BMad) Madison — the structured methodology layer
- UI UX Pro Max by NextLevelBuilder — the design intelligence layer
- Analysis and orchestration by Anuj Saxena
MIT License. See LICENSE for details.