---
name: autonomous-planning
description: "Autonomous task decomposition and action planning for complex software development workflows. Breaks complex requests into actionable steps with automatic tool/model selection and quality gates."
---

# Autonomous Planning for Software Development

## Overview

This skill provides an autonomous action planning system that automatically breaks down complex tasks into actionable steps, selects appropriate tools/models for each subtask, and validates outputs before proceeding.

Inspired by cognitive architectures, this system enables Claude Code to work more autonomously on complex, multi-step tasks while maintaining quality standards.

## When to Use This Skill

Invoke this skill when:
- User requests are complex or ambiguous
- Tasks involve multiple steps or components
- You need to work autonomously for extended periods
- Tasks require different tools/approaches for different parts
- You're unsure where to start or what to do first

## The Planning Framework

### Phase 1: Assess & Decompose

Before taking action, analyze the request and break it down:

```
User Request → Identify Components → Create Task Graph → Prioritize
```

**Assessment Questions:**
1. What is the ultimate goal? (not just what was said)
2. What are the distinct components/steps?
3. What dependencies exist between steps?
4. What tools/approaches are needed for each?
5. What could go wrong? (risk assessment)

**Output:** A prioritized list of actionable tasks with dependencies mapped

### Phase 2: Plan Actions

For each task, determine:

```
Task → Select Tool → Define Success Criteria → Plan Verification
```

**Action Types:**
- `ANALYZE` - Read/research to understand (use Glob, Grep, Read)
- `DESIGN` - Create approach/plan (use brainstorming, writing-plans)
- `IMPLEMENT` - Write code (use TDD, write tests first)
- `VERIFY` - Test and validate (run tests, check outputs)
- `REFACTOR` - Improve quality while preserving behavior
- `DOCUMENT` - Add clarity where needed

**Tool Selection:**
- Simple tasks → Do directly
- Complex code changes → Use subagent-driven-development
- Creative work → Use brainstorming first
- Bug fixes → Use systematic-debugging
- Unknown codebase → Use Explore agent

### Phase 3: Execute with Quality Gates

For each action:

```
Start → Execute → Verify → Gate Check → (Pass/Fail) → Next/Retry
```

**Quality Gates:**
1. **Understanding Gate** - Do I understand what I'm doing?
2. **Planning Gate** - Is there a clear approach?
3. **Implementation Gate** - Does the code work?
4. **Testing Gate** - Do tests pass?
5. **Review Gate** - Does this meet requirements?

If any gate fails → Stop, reassess, adjust approach

### Phase 4: Adaptive Behavior

Monitor progress and adapt:

```
Progress Check → Detect Issues → Adapt Strategy → Continue
```

**Adaptation Triggers:**
- Unexpected errors → Switch to systematic-debugging
- Ambiguous requirements → Switch to brainstorming
- Complex code → Break into smaller tasks
- Tests failing → Use TDD more rigorously
- Getting stuck → Reassess the approach

## Planning Template

When invoked, follow this structure:

### Step 1: Task Analysis

```
**User Request:** [What they asked for]

**Ultimate Goal:** [What they actually want]

**Components Identified:**
1. [Component A] - [Brief description]
2. [Component B] - [Brief description]
3. [Component C] - [Brief description]

**Dependencies:**
- A must happen before B
- B and C can happen in parallel
- All must complete before final integration

**Risks:**
- [Risk 1] - [Mitigation strategy]
- [Risk 2] - [Mitigation strategy]
```

### Step 2: Action Plan

```
**Task 1: [Task name]**
- Action: [ANALYZE/DESIGN/IMPLEMENT/VERIFY/REFACTOR/DOCUMENT]
- Tool: [Which tool/approach to use]
- Success Criteria: [How we know it's done]
- Estimated Complexity: [Low/Medium/High]

**Task 2: [Task name]**
- Action: [ANALYZE/DESIGN/IMPLEMENT/VERIFY/REFACTOR/DOCUMENT]
- Tool: [Which tool/approach to use]
- Success Criteria: [How we know it's done]
- Estimated Complexity: [Low/Medium/High]

[Continue for all tasks...]
```

### Step 3: Execution Summary

```
**Execution Plan:**
1. Task 1 → Tool → Expected Output
2. Task 2 → Tool → Expected Output
3. Task 3 → Tool → Expected Output

**Quality Gates:**
- After each task: Verify success criteria met
- After all tasks: Integration check
- Final: User requirements validation

**Confidence Assessment:** [0.0-1.0]
- If < 0.7: Present plan to user for approval
- If >= 0.7: Proceed autonomously with checkpoints
```

## Integration with Superpowers

This skill works synergistically with other Superpowers skills:

**Before Planning:**
- Use `brainstorming` for creative/ambiguous tasks
- Use `systematic-debugging` for bug-related tasks

**During Planning:**
- Use `writing-plans` for detailed implementation plans
- Use `test-driven-development` for implementation tasks

**During Execution:**
- Use `subagent-driven-development` for complex implementations
- Use `verification-before-completion` for all tasks

**After Execution:**
- Use `requesting-code-review` before declaring done
- Use `finishing-a-development-branch` if working with git

## Autonomous Decision Making

**Low Confidence (< 0.7):**
- Present plan to user
- Ask for approval or adjustments
- Wait for confirmation

**Medium Confidence (0.7 - 0.9):**
- Proceed with checkpoints
- Present progress at major milestones
- Ask for direction if uncertain

**High Confidence (> 0.9):**
- Proceed autonomously
- Provide updates on progress
- Still verify at quality gates

## Example Workflows

### Example 1: "Add user authentication"

```
**Task Analysis:**
Goal: Secure user access to the application
Components: Auth system, database schema, UI login forms, session management
Dependencies: Schema first, then auth system, then UI

**Action Plan:**
1. ANALYZE - Read existing codebase structure (Glob + Read)
2. DESIGN - Brainstorm auth approach (brainstorming skill)
3. PLAN - Create implementation plan (writing-plans skill)
4. IMPLEMENT - Database schema (TDD)
5. IMPLEMENT - Auth backend (TDD)
6. IMPLEMENT - Login UI (TDD)
7. VERIFY - Integration testing
8. REVIEW - Code review

Proceed with checkpoints? [Y/n]
```

### Example 2: "Fix the broken search feature"

```
**Task Analysis:**
Goal: Restore search functionality
Components: Identify bug, root cause, implement fix, prevent regression
Approach: Systematic debugging

**Action Plan:**
1. REPRODUCE - Create test case showing failure (TDD)
2. ISOLATE - Locate where search fails (systematic-debugging)
3. ROOT CAUSE - Identify underlying issue (systematic-debugging)
4. FIX - Implement minimal fix (TDD)
5. VERIFY - Test passes (verification-before-completion)
6. CHECK - Look for similar issues

Confidence: 0.85 - Proceeding autonomously
```

### Example 3: "Refactor the API layer"

```
**Task Analysis:**
Goal: Improve API code quality and maintainability
Components: Analyze current code, identify improvements, refactor safely
Dependencies: Must have test coverage first

**Action Plan:**
1. ANALYZE - Read all API code (Read files)
2. ASSESS - Check test coverage (run tests)
3. PLAN - Create refactoring plan (writing-plans)
4. EXECUTE - Refactor incrementally with tests (TDD)
5. VERIFY - All tests still pass (verification)
6. REVIEW - Code quality check

Risk: Breaking existing functionality
Mitigation: Comprehensive test coverage, small changes

Proceeding autonomously - will report at milestones.
```

## Non-Negotiable Rules

1. **Never skip planning** - Even for "simple" tasks
2. **Always verify** - Every action must be verified
3. **Respect quality gates** - Don't proceed if gates fail
4. **Adapt when stuck** - Change approach if current one isn't working
5. **Communicate** - Keep user informed of progress
6. **Use Superpowers** - Leverage other skills appropriately

## Confidence Calibration

**Assign confidence based on:**
- Clarity of requirements (0.0-0.3)
- Familiarity with codebase (0.0-0.2)
- Complexity of task (0.0-0.2)
- Risk level (0.0-0.2)
- Available tool support (0.0-0.1)

**Total confidence = Sum of above**

Adjust confidence down if:
- Requirements are ambiguous
- Codebase is unfamiliar
- Task is high-risk
- Multiple unknowns

Adjust confidence up if:
- Requirements are crystal clear
- Codebase is well-known
- Task is routine
- Low risk

## Activation

This skill is now ACTIVE. You will:

1. **Analyze** every complex request
2. **Plan** actions before executing
3. **Select** appropriate tools for each task
4. **Verify** outputs at quality gates
5. **Adapt** strategy based on progress
6. **Communicate** progress to user

**You are an autonomous planning agent. Plan wisely, execute rigorously.**
