Autonomous Mode — /autonomous-sdd

/autonomous-sdd is Planu's end-to-end autopilot skill. Given an approved spec, it handles the full implementation pipeline without requiring per-step human intervention: readiness gate, branch creation, implementation against every acceptance criterion, self-review, validation, and merge.

If you are familiar with cc-sdd, /autonomous-sdd is the functional equivalent of /kiro-impl — with two additional phases (readiness check and post-merge healing watcher) that /kiro-impl does not include.

---

When to Use It

Autonomous mode is appropriate when:

• The spec has been approved and all acceptance criteria are specific and testable.
• The task is self-contained — an agent can complete it without mid-flight design decisions.
• You want to delegate the full implementation loop and review the result at the end rather than at each step.

It is not the right choice when:

• Acceptance criteria are still ambiguous. Run challenge_spec and check_readiness first.
• The task requires product decisions that depend on context an agent cannot infer from the spec alone.
• You prefer step-by-step visibility — in that case, run implement_plan, validate, and create_pr_from_spec manually.

---

How to Activate It

Autonomous mode is a Planu skill. Install it once, then invoke it from any MCP-compatible agent.

Install the skill:

planu skill install autonomous-sdd

Invoke from Claude Code (or any MCP client):

/autonomous-sdd SPEC-042

The skill reads your approved spec, locks it to prevent concurrent edits, and begins the pipeline. Progress is streamed in real time.

---

The Six Internal Phases

Autonomous mode runs six phases internally. Each phase is observable and can be interrupted if needed.

Phase 1 — Readiness gate. Before writing a single line of code, the skill validates that every acceptance criterion meets the minimum quality threshold for autonomous implementation: specificity, testability, and absence of contradictions. If any criterion fails the gate, the skill halts and reports which criteria need improvement. This prevents wasted compute on under-specified work.

Phase 2 — Branch. A dedicated Git branch is created for the spec, following your project's branch naming convention (feat/SPEC-NNN-slug). The spec is locked to the branch so no other agent or session can modify it while implementation is in progress.

Phase 3 — Implement. The agent works through acceptance criteria sequentially, referencing each criterion explicitly as it writes code. Intermediate progress is checkpointed so the run can be resumed if interrupted. Architectural decisions made during implementation are logged to the spec's tech decision record automatically.

Phase 4 — Self-review. When implementation is complete, the skill runs a multi-pass review against the spec. Each acceptance criterion is checked against the implementation. Gaps are flagged before the validation phase begins, reducing the number of validation failures that require human attention.

Phase 5 — Validate. The full validation loop runs: automated tests, drift detection, and a criterion-by-criterion compliance check. A validation report is produced. If all criteria pass, the pipeline advances. If any criterion fails, the skill attempts a targeted fix (up to two retries) before surfacing the failure for human review.

Phase 6 — Merge. On a clean validation report, the branch is merged and the spec status is updated to done. A post-merge healing watcher is registered: Planu continues to monitor the spec for drift in subsequent commits and will surface retroactive healing suggestions if the implementation diverges.

---

Observability and Control

Autonomous mode is designed to be interruptible at any phase boundary. Press Ctrl+C during an active run to pause at the next safe checkpoint. The run state is persisted and can be resumed with:

/autonomous-sdd --resume SPEC-042

To review what the skill will do before running it:

/autonomous-sdd --dry-run SPEC-042

This prints the execution plan for all six phases without writing any code or creating any branches.

---

Relationship to cc-sdd's /kiro-impl

cc-sdd's /kiro-impl runs three phases: branch, implement, and merge. /autonomous-sdd adds a readiness gate before implementation and a post-merge healing watcher after it. The branch, implement, self-review, and merge phases are structurally equivalent.

If you are migrating from cc-sdd, your existing approved specs are compatible with /autonomous-sdd without modification.

---

Further Reading

• SDD Workflow Guide — the full spec lifecycle, step by step.
• Skills & Extensions — how Planu skills work and how to install them.
• Planu vs SDD Tools — how /autonomous-sdd compares to /kiro-impl and Kiro's autopilot.
• Getting Started — install Planu and run your first spec.