SuperCharged-Claude-Code-Upgrade/skills/autonomous-planning/SKILL.md

name, description

name	description
autonomous-planning	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.