Colin Uber Code

---
description: Autonomous large-task delivery loop - critique, decide, implement, review, fix, ship, and monitor CI until green
argument-hint: "<task, plan path, spec path, or objective> [--agents list...] [--max-coders 1|2|3] [--base branch] [--dry-run]"
allowed-tools: Read, Write, Edit, MultiEdit, Glob, Grep, Task, Bash(git *), Bash(gh *), Bash(glab *), Bash(jq:*), Bash(bun *), Bash(claude *), Bash(occtl *), Bash(codex *), Bash(ls:*), Bash(find:*), Bash(wc:*), Bash(rg:*), Bash(cat:*)
---

# Uber Code

Run a large coding task from initial plan to green CI with no human-in-the-loop gates.

This command deliberately keeps the main agent hands-off. The main agent gathers only enough context to validate and route the task, writes durable artifacts to disk, delegates almost all reasoning and implementation to agents, and uses MBOT / MBOD for adversarial critique, review, and bundled decisions.

Do **not** use Paseo or any Paseo-dependent tool. The command may borrow the pattern of durable plan files, phase handoffs, and monitor loops, but it must run through the current harness, MBOT, MBOD, platform CLIs, and regular agent/task facilities.

User request:

```text
$ARGUMENTS

Operating Principles

• No human gates after launch. Do not ask the user to choose between options during the run. Resolve implementation decisions with MBOD when needed.
• Artifacts are the source of truth. Write every large plan, critique, review, decision, and monitor result to .tmp/uber-code-<slug>/. Keep chat updates short.
• The main agent orchestrates. It should not implement substantial code directly. It creates briefs, launches agents, validates artifacts, runs final commands, commits, pushes, and opens/monitors the PR/MR.
• Delegate with complete briefs. Every spawned agent starts from a self-contained prompt with paths to the exact artifacts it must read.
• Never revert unrelated user changes. If the worktree is dirty before starting, record it and instruct every coding/fix agent to preserve unrelated changes.
• Always deliver through PR/MR. Create or reuse a feature branch, push to origin, open/update a hosted review item, and monitor CI until green or a documented hard blocker remains.
• Bound parallel coding. Use one to three coding agents. Use multiple agents only when write scopes are genuinely disjoint.

Input Resolution

Resolve the first argument that looks like the task source:

Input	Resolution
Existing file path	Read it as the source plan/spec/objective
SPECS-*.md / PLANS-*.md implied by current directory	Use the single matching file when exactly one exists
Task-like ID or URL	Fetch enough title/body/context with the available CLI or MCP, if configured
Plain text	Treat it as the user-provided objective/plan

Flags:

Flag	Behavior
--agents <list>	Pass through to MBOT / MBOD participant selection where applicable
--max-coders 1|2|3	Upper bound for implementation agents; default 3
--base <branch>	Base branch for diff, branch creation, and PR/MR; default is detected default branch
--dry-run	Create the execution outline only. Do not launch agents, edit code, commit, push, or open PR/MR

If no usable task source can be resolved, stop and ask for a plan, spec, or objective. Otherwise proceed without further user input.

Run Directory

Create one run directory inside the project root:

.tmp/uber-code-<slug>/
  briefs/
  plans/
  critiques/
  decisions/
  agents/
  reviews/
  fixes/
  ci/
  final/

The slug should be short, lowercase, and derived from the task. If there is a collision, append a numeric suffix.

Write these initial files:

• briefs/request.md - original user request and resolved source content
• briefs/repo-basics.md - branch, remotes, status, default/base branch, recent commits, likely platform
• briefs/context.md - only basic local context needed to validate the plan: relevant AGENTS.md / CLAUDE.md, obvious manifests, likely test/build commands, and any directly referenced files
• plans/original.md - normalized copy of the user-provided plan/objective
• final/ledger.md - append-only phase log with timestamps, artifact paths, agent names, command outcomes, and blockers

For --dry-run, write final/dry-run.md with the planned phases, expected artifact files, and intended agent fan-out, then stop.

Phase 1: Basic Context

Gather only enough context to validate the user's plan and launch critique.

Do:

• Record git status --short, current branch, remotes, upstream, default branch, and latest commit.
• Detect GitHub vs GitLab from git remote get-url origin.
• Read root and path-relevant AGENTS.md / CLAUDE.md files.
• Read directly relevant manifests such as package.json, pyproject.toml, go.mod, Cargo.toml, Makefile, justfile, CI config, or task-referenced files.
• Identify likely local gates, but do not run expensive full gates yet.

Do not:

• Explore the whole repo.
• Start implementation.
• Ask the user about decisions that can be resolved later by MBOD.

Phase 2: Critique the Plan

Use the many-brain-one-task skill with the critique task shape.

Run MBOT against plans/original.md plus briefs/context.md. Instruct agents to critique the plan for:

• Contradictions and inconsistent terminology
• Major gaps in behavior, error handling, state transitions, or dependencies
• Poor naming or ambiguous concepts
• Inferior design choices, over-engineering, under-engineering, or hidden coupling

Agents must not propose unrelated features or scope expansion.

Save the full validated critique to:

critiques/mbot-critique.md

The chat summary should only include the model list, issue count, and file path.

Phase 3: Second Draft Plan

Launch one planning agent. Give it:

• plans/original.md
• critiques/mbot-critique.md
• briefs/context.md

The planner must compare the critique to ```