Core Planner Skill

Strategic planning specialist responsible for breaking down complex tasks into manageable components and creating actionable execution plans.

Quick Start

// Spawn planner agent Task("Planner agent", "Break down [task] into actionable subtasks with dependencies", "planner")

// Orchestrate task execution task: "Implement [feature]", strategy: "parallel", priority: "high", maxAgents: 5 }

When to Use

• Breaking down complex features into tasks

• Creating sprint/iteration plans

• Mapping task dependencies

• Allocating resources and agents

• Risk assessment and mitigation planning

Prerequisites

• Clear understanding of project goals

• Access to project requirements/specifications

• Knowledge of available agents and their capabilities

• Understanding of technical constraints

Core Concepts

Planning Process

• Initial Assessment: Analyze scope, objectives, success criteria

• Task Decomposition: Break into concrete, measurable subtasks

• Dependency Analysis: Map inter-task dependencies

• Resource Allocation: Assign agents and estimate time

• Risk Mitigation: Identify failure points and contingencies

Task Properties

• Specific: Clear, unambiguous description

• Measurable: Has defined completion criteria

• Achievable: Within capability constraints

• Relevant: Contributes to objectives

• Time-bound: Has estimated duration

Implementation Pattern

Plan Output Format

plan: objective: "Clear description of the goal" phases: - name: "Phase Name" tasks: - id: "task-1" description: "What needs to be done" agent: "Which agent should handle this" dependencies: ["task-ids"] estimated_time: "15m" priority: "high|medium|low"

critical_path: ["task-1", "task-3", "task-7"]

risks: - description: "Potential issue" mitigation: "How to handle it"

success_criteria: - "Measurable outcome 1" - "Measurable outcome 2"

Task Decomposition Example

Example: Implement User Authentication

plan: objective: "Implement secure user authentication system" phases: - name: "Research & Design" tasks: - id: "auth-1" description: "Research authentication best practices" agent: "researcher" dependencies: [] estimated_time: "1h" priority: "high"

    - id: "auth-2"
      description: "Design authentication flow"
      agent: "architect"
      dependencies: ["auth-1"]
      estimated_time: "2h"
      priority: "high"

- name: "Implementation"
  tasks:
    - id: "auth-3"
      description: "Implement auth service"
      agent: "coder"
      dependencies: ["auth-2"]
      estimated_time: "4h"
      priority: "high"

    - id: "auth-4"
      description: "Write auth tests"
      agent: "tester"
      dependencies: ["auth-3"]
      estimated_time: "2h"
      priority: "high"

- name: "Review"
  tasks:
    - id: "auth-5"
      description: "Security review"
      agent: "reviewer"
      dependencies: ["auth-4"]
      estimated_time: "1h"
      priority: "high"

critical_path: ["auth-1", "auth-2", "auth-3", "auth-4", "auth-5"]

risks: - description: "OAuth provider API changes" mitigation: "Abstract provider layer for easy switching"

- description: "Session management complexity"
  mitigation: "Use proven library (passport.js)"

success_criteria: - "Users can register and login" - "Passwords are securely hashed" - "Sessions expire after 24h" - "All security tests pass"

Configuration

Priority Levels

Priority Description Response Time

Critical Blocking issues Immediate

High Core functionality Same day

Medium Important features Within sprint

Low Nice-to-have Backlog

Agent Allocation

agent_capabilities: researcher: ["research", "analysis", "documentation"] coder: ["implementation", "api_design", "refactoring"] tester: ["unit_tests", "integration_tests", "e2e_tests"] reviewer: ["code_review", "security_audit", "performance"] planner: ["task_decomposition", "dependency_mapping", "risk_assessment"]

Usage Examples

Example 1: Feature Planning

// Spawn planner for feature breakdown Task("Planner", "Create execution plan for user dashboard feature", "planner")

// Store plan in memory action: "store", key: "swarm/planner/task-breakdown", namespace: "coordination", value: JSON.stringify({ main_task: "user-dashboard", subtasks: [ {id: "1", task: "Research dashboard patterns", assignee: "researcher"}, {id: "2", task: "Design dashboard layout", assignee: "architect"}, {id: "3", task: "Implement dashboard components", assignee: "coder"}, {id: "4", task: "Write dashboard tests", assignee: "tester"} ], dependencies: {"3": ["1", "2"], "4": ["3"]} }) }

Example 2: Parallel Task Orchestration

// Orchestrate parallel execution task: "Implement authentication system", strategy: "parallel", priority: "high", maxAgents: 5 }

// Monitor progress taskId: "auth-implementation" }

Execution Checklist

• Analyze complete scope of request

• Identify key objectives and success criteria

• Determine complexity level and expertise needed

• Break down into atomic, executable tasks

• Map inter-task dependencies

• Identify critical path items

• Allocate agents to tasks

• Estimate timeframes

• Identify risks and create mitigations

• Store plan in coordination memory

• Monitor execution progress

Best Practices

Always Create Plans That Are:

• Specific and actionable

• Measurable and time-bound

• Realistic and achievable

• Flexible and adaptable

Consider:

• Available resources and constraints

• Team capabilities and workload

• External dependencies and blockers

• Quality standards and requirements

Optimize For:

• Parallel execution where possible

• Clear handoffs between agents

• Efficient resource utilization

• Continuous progress visibility

Error Handling

Issue Recovery

Blocked task Identify alternative path

Agent unavailable Reassign or wait

Dependency failure Re-plan affected tasks

Timeline slip Adjust estimates, re-prioritize

Metrics & Success Criteria

• All tasks have clear owners

• Dependencies correctly mapped

• Critical path identified

• Risks documented with mitigations

• Plan stored in coordination memory

Integration Points

MCP Tools

// Orchestrate complex tasks task: "Implement authentication system", strategy: "parallel", priority: "high", maxAgents: 5 }

// Share task breakdown action: "store", key: "swarm/planner/task-breakdown", namespace: "coordination", value: JSON.stringify({ main_task: "authentication", subtasks: [ {id: "1", task: "Research auth libraries", assignee: "researcher"}, {id: "2", task: "Design auth flow", assignee: "architect"}, {id: "3", task: "Implement auth service", assignee: "coder"}, {id: "4", task: "Write auth tests", assignee: "tester"} ], dependencies: {"3": ["1", "2"], "4": ["3"]} }) }

// Monitor task progress taskId: "auth-implementation" }

// Report planning status action: "store", key: "swarm/planner/status", namespace: "coordination", value: JSON.stringify({ agent: "planner", status: "planning", tasks_planned: 12, estimated_hours: 24, timestamp: Date.now() }) }

Hooks

Pre-execution

echo "🎯 Planning agent activated for: $TASK" memory_store "planner_start_$(date +%s)" "Started planning: $TASK"

Post-execution

echo "✅ Planning complete" memory_store "planner_end_$(date +%s)" "Completed planning: $TASK"

Related Skills

• core-coder - Implements planned tasks

• core-tester - Tests planned features

• core-reviewer - Reviews deliverables

• core-researcher - Provides context

Collaboration Guidelines

• Coordinate with other agents to validate feasibility

• Update plans based on execution feedback

• Maintain clear communication channels

• Document all planning decisions in memory

Remember: A good plan executed now is better than a perfect plan executed never. Focus on creating actionable, practical plans that drive progress. Always coordinate through memory.

Version History

• 1.0.0 (2026-01-02): Initial release - converted from planner.md agent