playbooks

home / skills / atrislabs / atris / autopilot

autopilot skill

/atris/skills/autopilot

This skill autonomously executes user tasks from planning to review until acceptance criteria pass, delivering PRDs and execution logs.

npx playbooks add skill atrislabs/atris --skill autopilot

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
4.0 KB
---
name: autopilot
description: PRD-driven autonomous execution - give it a task, it loops until done Triggers on "autopilot", "autonomous", "get it done", "finish this", "ship it".
version: 1.0.0
tags:
  - autopilot
  - workflow
  - automation
---

# Autopilot Skill

Autonomous task execution. Plan → Do → Review loop until acceptance criteria pass.

## When to Use

- User says "get this done" or "ship it"
- User describes a feature/bug and wants hands-off execution
- Any task that can be validated with acceptance criteria

## Process

```
┌───────────────────────────────────────────────────────┐
│  INPUT: "Add dark mode toggle"                        │
│                                                       │
│  1. GENERATE PRD                                      │
│     - Type: feature or bug (auto-detect)              │
│     - Acceptance criteria (testable conditions)       │
│     - Priority: 1 (single story)                      │
│                                                       │
│  2. LOOP (max 5 iterations)                           │
│     ┌──────────────────────────────────────┐          │
│     │ PLAN: Navigator creates tasks        │          │
│     │   - Read MAP.md for file locations   │          │
│     │   - ASCII diagram of approach        │          │
│     │   - Add tasks to TODO.md             │          │
│     │   - Signal: [PLAN_COMPLETE]          │          │
│     ├──────────────────────────────────────┤          │
│     │ DO: Executor builds                  │          │
│     │   - Implement each task              │          │
│     │   - Verify changes work              │          │
│     │   - Commit changes                   │          │
│     │   - Signal: [DO_COMPLETE]            │          │
│     ├──────────────────────────────────────┤          │
│     │ REVIEW: Validator checks             │          │
│     │   - Check acceptance criteria        │          │
│     │   - If fail: [REVIEW_FAILED] reason  │          │
│     │   - If pass: [COMPLETE]        │
│     └──────────────────────────────────────┘          │
│                                                       │
│  3. OUTPUT                                            │
│     - prd.json: PRD with passes: true                 │
│     - progress.txt: Execution log                     │
│     - Journal: Completion logged                      │
└───────────────────────────────────────────────────────┘
```

## Acceptance Criteria Templates

**Feature:**
- Feature implemented and working as described
- Tests pass (if test suite exists)
- Build passes
- Code follows project patterns (check MAP.md)

**Bug:**
- Bug is fixed and no longer reproducible
- Regression test added (if applicable)
- Build passes
- No new bugs introduced

## Commands

```bash
# With description
atris autopilot "Add dark mode toggle"

# Bug fix
atris autopilot --bug "Login fails on Safari"

# From TODO.md backlog
atris autopilot --from-todo

# With options
atris autopilot "Add feature" --iterations=3 --verbose
```

## Stop Conditions

1. `[COMPLETE]` — All acceptance criteria met
2. Max iterations reached (default: 5)
3. Error that can't be recovered

## Rules

- ONE task at a time
- Verify before marking passes: true
- Minimal changes only
- Check MAP.md before touching code
- Log to journal when complete

Overview

This skill runs PRD-driven autonomous execution: provide a task and it plans, does, and reviews in a loop until acceptance criteria are met or a stop condition is hit. It targets single-story tasks (feature or bug) and produces machine-readable outputs like prd.json, a progress log, and a completion journal. Triggers include "autopilot", "autonomous", "get it done", "finish this", and "ship it".

How this skill works

The skill auto-generates a PRD with testable acceptance criteria and priority, then iterates through a Plan → Do → Review loop up to a configurable max (default 5). The Plan step creates granular tasks and a roadmap; Do executes and commits minimal changes; Review validates acceptance criteria and either marks COMPLETE or emits a REVIEW_FAILED reason to trigger another iteration. It enforces one task at a time, checks project map files before edits, and logs progress and outcomes.

When to use it

  • You want hands-off implementation of a single feature described by acceptance criteria.
  • You need a bug fixed with a reproducible test and hands-off validation.
  • You want automated, repeatable execution that loops until tests pass or max iterations are reached.
  • You have a task that can be verified with clear pass/fail acceptance criteria.
  • You prefer minimal, incremental changes and audit-friendly execution logs.

Best practices

  • Provide a clear, concise description with explicit acceptance criteria or let the skill draft them.
  • Limit requests to a single story (one feature or bug) for predictable iteration and results.
  • Keep MAP.md or equivalent project map up to date so the planner can find files safely.
  • Enable CI/tests or provide reproducible verification steps so the reviewer can validate changes.
  • Set a reasonable max iterations and use verbose logging for debugging complex tasks.

Example use cases

  • Add a dark mode toggle with UI tests and build verification.
  • Fix a browser-specific login bug and add a regression test.
  • Implement a small API endpoint with documented acceptance criteria and automated tests.
  • Refactor a single module to match project patterns and ensure build passes.
  • Pick the next item from TODO.md and complete it end-to-end with validation.

FAQ

How many iterations will it try?

Default max iterations is 5; you can configure a different limit when invoking the skill.

What happens if acceptance criteria can't be met?

The skill stops after reaching the max iterations or emits an unrecoverable error; it logs REVIEW_FAILED reasons and progress for manual follow-up.