writing-plans
npx machina-cli add skill a5c-ai/babysitter/writing-plans --openclawWriting Plans
Overview
Create comprehensive implementation plans with bite-sized tasks (2-5 minutes each). Every task has exact file paths, complete code, verification steps, and TDD flow.
Core principle: Document everything the engineer needs. DRY. YAGNI. TDD. Frequent commits.
When to Use
- After design approval (from brainstorming)
- When you have specs/requirements for multi-step work
- Before any implementation begins
Task Structure
Each task follows: Write failing test -> Verify fail -> Implement minimal code -> Verify pass -> Commit
Plan Format
- Header: Goal, Architecture, Tech Stack
- Tasks with exact file paths and complete code
- TDD steps with expected output
- Task persistence via
.tasks.json
Execution Handoff
After plan is written, choose:
- Subagent-Driven - Fresh agent per task with two-stage review
- Batch Execution - Execute in batches with human checkpoints
Agents Used
- Process agents defined in
writing-plans.js
Tool Use
Invoke via babysitter process: methodologies/superpowers/writing-plans
Source
git clone https://github.com/a5c-ai/babysitter/blob/main/plugins/babysitter/skills/babysit/process/methodologies/superpowers/skills/writing-plans/SKILL.mdView on GitHub Overview
Writing Plans creates comprehensive implementation plans broken into bite-sized tasks (2-5 minutes each). Each task includes exact file paths, complete code, verification steps, and a clear TDD flow. The approach emphasizes documenting everything the engineer needs, following DRY, YAGNI, and frequent commits.
How This Skill Works
Start from a spec, break it into tasks with precise file paths and expected outcomes. For each task, write a failing test, verify the failure, then implement minimal code to pass, verify success, and commit. The plan includes a header (Goal, Architecture, Tech Stack), tasks with complete code, TDD steps, and persistence via .tasks.json. After planning, choose a handoff method (Subagent-Driven or Batch Execution) and execute using the babysitter process.
When to Use It
- After design approval (brainstorming) and before coding.
- When you have specs/requirements for multi-step work.
- Before any implementation begins.
- When the work requires explicit task-level dependencies and verification steps.
- When planning handoffs (Subagent-Driven or Batch Execution) with human checkpoints.
Quick Start
- Step 1: Break the spec into bite-sized tasks (2-5 minutes each) and list exact file paths.
- Step 2: For each task, write a failing test, verify the failure, then implement minimal code to pass.
- Step 3: Run tests, commit frequently, and persist progress to .tasks.json; review handoff options.
Best Practices
- Document everything the engineer needs.
- Apply DRY, YAGNI, and TDD principles.
- Break work into bite-sized tasks (2-5 minutes each).
- Include exact file paths, complete code, and verification steps in each task.
- Persist tasks in .tasks.json and commit frequently.
Example Use Cases
- Plan to implement a multi-step login feature with spec-driven tasks and tests.
- Plan to integrate an API client with endpoints and mocks, using a TDD flow.
- Plan to build a UI component with states and accessibility tests.
- Plan a data migration with staged steps and verification checks.
- Plan a batch processing job with ordered tasks and dependency tracking.
