home / skills / vudovn / antigravity-kit / plan-writing

plan-writing skill

/.agent/skills/plan-writing

This skill helps you plan tasks with clear, verifiable steps and dependencies for features, refactors, or multi-step work.

npx playbooks add skill vudovn/antigravity-kit --skill plan-writing

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

Files (1)
SKILL.md
3.9 KB
---
name: plan-writing
description: Structured task planning with clear breakdowns, dependencies, and verification criteria. Use when implementing features, refactoring, or any multi-step work.
allowed-tools: Read, Glob, Grep
---

# Plan Writing

> Source: obra/superpowers

## Overview
This skill provides a framework for breaking down work into clear, actionable tasks with verification criteria.

## Task Breakdown Principles

### 1. Small, Focused Tasks
- Each task should take 2-5 minutes
- One clear outcome per task
- Independently verifiable

### 2. Clear Verification
- How do you know it's done?
- What can you check/test?
- What's the expected output?

### 3. Logical Ordering
- Dependencies identified
- Parallel work where possible
- Critical path highlighted
- **Phase X: Verification is always LAST**

### 4. Dynamic Naming in Project Root
- Plan files are saved as `{task-slug}.md` in the PROJECT ROOT
- Name derived from task (e.g., "add auth" β†’ `auth-feature.md`)
- **NEVER** inside `.claude/`, `docs/`, or temp folders

## Planning Principles (NOT Templates!)

> πŸ”΄ **NO fixed templates. Each plan is UNIQUE to the task.**

### Principle 1: Keep It SHORT

| ❌ Wrong | βœ… Right |
|----------|----------|
| 50 tasks with sub-sub-tasks | 5-10 clear tasks max |
| Every micro-step listed | Only actionable items |
| Verbose descriptions | One-line per task |

> **Rule:** If plan is longer than 1 page, it's too long. Simplify.

---

### Principle 2: Be SPECIFIC, Not Generic

| ❌ Wrong | βœ… Right |
|----------|----------|
| "Set up project" | "Run `npx create-next-app`" |
| "Add authentication" | "Install next-auth, create `/api/auth/[...nextauth].ts`" |
| "Style the UI" | "Add Tailwind classes to `Header.tsx`" |

> **Rule:** Each task should have a clear, verifiable outcome.

---

### Principle 3: Dynamic Content Based on Project Type

**For NEW PROJECT:**
- What tech stack? (decide first)
- What's the MVP? (minimal features)
- What's the file structure?

**For FEATURE ADDITION:**
- Which files are affected?
- What dependencies needed?
- How to verify it works?

**For BUG FIX:**
- What's the root cause?
- What file/line to change?
- How to test the fix?

---

### Principle 4: Scripts Are Project-Specific

> πŸ”΄ **DO NOT copy-paste script commands. Choose based on project type.**

| Project Type | Relevant Scripts |
|--------------|------------------|
| Frontend/React | `ux_audit.py`, `accessibility_checker.py` |
| Backend/API | `api_validator.py`, `security_scan.py` |
| Mobile | `mobile_audit.py` |
| Database | `schema_validator.py` |
| Full-stack | Mix of above based on what you touched |

**Wrong:** Adding all scripts to every plan
**Right:** Only scripts relevant to THIS task

---

### Principle 5: Verification is Simple

| ❌ Wrong | βœ… Right |
|----------|----------|
| "Verify the component works correctly" | "Run `npm run dev`, click button, see toast" |
| "Test the API" | "curl localhost:3000/api/users returns 200" |
| "Check styles" | "Open browser, verify dark mode toggle works" |

---

## Plan Structure (Flexible, Not Fixed!)

```
# [Task Name]

## Goal
One sentence: What are we building/fixing?

## Tasks
- [ ] Task 1: [Specific action] β†’ Verify: [How to check]
- [ ] Task 2: [Specific action] β†’ Verify: [How to check]
- [ ] Task 3: [Specific action] β†’ Verify: [How to check]

## Done When
- [ ] [Main success criteria]
```

> **That's it.** No phases, no sub-sections unless truly needed.
> Keep it minimal. Add complexity only when required.

## Notes
[Any important considerations]
```

---

## Best Practices (Quick Reference)

1. **Start with goal** - What are we building/fixing?
2. **Max 10 tasks** - If more, break into multiple plans
3. **Each task verifiable** - Clear "done" criteria
4. **Project-specific** - No copy-paste templates
5. **Update as you go** - Mark `[x]` when complete

---

## When to Use

- New project from scratch
- Adding a feature
- Fixing a bug (if complex)
- Refactoring multiple files

Overview

This skill structures multi-step work into small, verifiable tasks with clear outcomes and a single-sentence goal. It helps teams and individuals break features, refactors, or bug fixes into 2–5 minute actions and keeps verification last.

How this skill works

You define a one-line goal, then list up to 10 focused tasks. Each task includes a specific action and a concrete verification step so completion is binary. Tasks are ordered by dependency, allow parallel work when possible, and the plan is saved as a single file named from the task slug in the project root.

When to use it

  • Starting a new project and deciding MVP scope and file layout
  • Adding a feature that touches multiple files or systems
  • Refactoring code across modules where sequencing matters
  • Fixing a complex bug that needs reproducible verification
  • Breaking large work into multiple, reviewable increments

Best practices

  • Keep plans short: 5–10 tasks max; if longer, split into separate plans
  • Make each task 2–5 minutes with one clear outcome and a verification step
  • Name the plan file from the task slug and save it in the project root
  • Highlight dependencies and the critical path; mark verification steps last
  • Avoid copy-paste templatesβ€”tailor actions and scripts to the project

Example use cases

  • Add authentication: install package, add API route, wire UI β†’ Verify login succeeds and token stored
  • Refactor header component: extract to shared module, update imports, adjust styles β†’ Verify UI renders and tests pass
  • Bug triage and fix: reproduce error, identify failing file/line, apply fix β†’ Verify error no longer occurs and regression tests pass
  • New project MVP: choose stack, scaffold app, add CI config β†’ Verify app runs and CI passes
  • Database migration: add migration file, run locally, update seed β†’ Verify schema and sample queries return expected results

FAQ

How long should each plan be?

One page maximum; if a plan exceeds that, split it into multiple focused plans.

What counts as verification?

A simple, repeatable check: a command, a UI action, or an automated test that yields a pass/fail result.