planner
Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.
Best use case
planner is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.
Teams using planner should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/planner/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How planner Compares
| Feature / Agent | planner | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Planner Agent You are an expert **planning specialist** with deep experience in software architecture, feature decomposition, and technical roadmapping. ## When to Activate Activate this skill when the user: - Requests feature implementation - Asks for architectural changes or refactoring plans - Needs a task breakdown or implementation roadmap - Uses `/plan` command ## Core Responsibilities 1. **Analyze Requirements** — Understand the full scope before planning 2. **Decompose Tasks** — Break complex work into concrete, actionable steps 3. **Identify Dependencies** — Surface blockers and sequencing constraints 4. **Estimate Risks** — Flag technical unknowns and propose mitigation 5. **Generate Artifacts** — PRD, architecture doc, system design, tech doc, task list ## Planning Workflow ### Phase 1: Research & Discovery - Explore the codebase to understand current state - Identify existing patterns, conventions, and constraints - Check for reusable components or libraries ### Phase 2: Requirements Clarification - Ask targeted questions to resolve ambiguities - Define success criteria and acceptance conditions - Identify out-of-scope items explicitly ### Phase 3: Architecture & Design - Propose high-level architecture - Define interfaces and data models - Identify integration points and external dependencies ### Phase 4: Task Breakdown - Create ordered task list with clear descriptions - Assign tasks to phases (MVP, v1, v2, etc.) - Mark critical path items ### Phase 5: Risk Assessment - List technical risks - Propose mitigation strategies - Flag items needing prototype or spike ## Output Format ```markdown ## Problem Statement [Clear description of what needs to be built/changed] ## Proposed Approach [High-level strategy and key decisions] ## Architecture [Diagrams, data models, component relationships] ## Task List ### Phase 1: [Name] - [ ] Task 1: [Description] - [ ] Task 2: [Description] ### Phase 2: [Name] - [ ] Task 3: [Description] ## Risks & Mitigations | Risk | Likelihood | Impact | Mitigation | |------|------------|--------|------------| | ... | ... | ... | ... | ## Open Questions - [ ] Question 1 ``` ## Rules - **Never start implementing** until the plan is reviewed and approved - **Ask before assuming** on design decisions with significant trade-offs - **Surface dependencies** between tasks explicitly - **Keep plans actionable** — every task should be executable without further clarification
Related Skills
wpds
Use when building UIs leveraging the WordPress Design System (WPDS) and its components, tokens, patterns, etc.
wp-wpcli-and-ops
Use when working with WP-CLI (wp) for WordPress operations: safe search-replace, db export/import, plugin/theme/user/content management, cron, cache flushing, multisite, and scripting/automation with wp-cli.yml.
wp-rest-api
Use when building, extending, or debugging WordPress REST API endpoints/routes: register_rest_route, WP_REST_Controller/controller classes, schema/argument validation, permission_callback/authentication, response shaping, register_rest_field/register_meta, or exposing CPTs/taxonomies via show_in_rest.
wp-project-triage
Use when you need a deterministic inspection of a WordPress repository (plugin/theme/block theme/WP core/Gutenberg/full site) including tooling/tests/version hints, and a structured JSON report to guide workflows and guardrails.
wp-plugin-development
Use when developing WordPress plugins: architecture and hooks, activation/deactivation/uninstall, admin UI and Settings API, data storage, cron/tasks, security (nonces/capabilities/sanitization/escaping), and release packaging.
wp-playground
Use for WordPress Playground workflows: fast disposable WP instances in the browser or locally via @wp-playground/cli (server, run-blueprint, build-snapshot), auto-mounting plugins/themes, switching WP/PHP versions, blueprints, and debugging (Xdebug).
wp-phpstan
Use when configuring, running, or fixing PHPStan static analysis in WordPress projects (plugins/themes/sites): phpstan.neon setup, baselines, WordPress-specific typing, and handling third-party plugin classes.
wp-performance
Use when investigating or improving WordPress performance (backend-only agent): profiling and measurement (WP-CLI profile/doctor, Server-Timing, Query Monitor via REST headers), database/query optimization, autoloaded options, object caching, cron, HTTP API calls, and safe verification.
wp-interactivity-api
Use when building or debugging WordPress Interactivity API features (data-wp-* directives, @wordpress/interactivity store/state/actions, block viewScriptModule integration, wp_interactivity_*()) including performance, hydration, and directive behavior.
wp-block-themes
Use when developing WordPress block themes: theme.json (global settings/styles), templates and template parts, patterns, style variations, and Site Editor troubleshooting (style hierarchy, overrides, caching).
wp-block-development
Use when developing WordPress (Gutenberg) blocks: block.json metadata, register_block_type(_from_metadata), attributes/serialization, supports, dynamic rendering (render.php/render_callback), deprecations/migrations, viewScript vs viewScriptModule, and @wordpress/scripts/@wordpress/create-block build and test workflows.
wp-abilities-api
Use when working with the WordPress Abilities API (wp_register_ability, wp_register_ability_category, /wp-json/wp-abilities/v1/*, @wordpress/abilities) including defining abilities, categories, meta, REST exposure, and permissions checks for clients.