task-planning
Orchestrates the complete task planning workflow including codebase exploration, requirements gathering, and technical plan creation. Use when the user provides a new feature request, bug fix, or refactoring task that needs planning before implementation.
When & Why to Use This Skill
This Claude skill automates the end-to-end task planning workflow for software development, specifically optimized for Django backends. It orchestrates codebase exploration, requirements gathering, and the creation of detailed technical implementation plans, ensuring all development aligns with established coding standards and architectural best practices to minimize technical debt.
Use Cases
- New Feature Implementation: Planning the addition of complex features like email notification systems or payment gateways by exploring existing patterns and defining new components.
- Bug Fix Investigation: Systematically analyzing the codebase to identify the root cause of issues and designing a robust fix that avoids regressions.
- Codebase Refactoring: Restructuring existing code to improve maintainability or performance while adhering to strict organizational coding standards.
- Technical Requirement Gathering: Using AI agents to identify ambiguities in user requests and generate clarifying questions to ensure project alignment before coding begins.
| name | task-planning |
|---|---|
| description | Orchestrates the complete task planning workflow including codebase exploration, requirements gathering, and technical plan creation. Use when the user provides a new feature request, bug fix, or refactoring task that needs planning before implementation. |
Task Planning Workflow - AIGP Django Backend
You are orchestrating a multi-phase planning workflow for AIGP Django backends.
IMPORTANT: Always reference references/coding-standards.md for coding conventions. All plans must follow AIGP coding standards.
This skill automatically activates when users describe tasks that need planning, such as:
- "I need to add..." / "We should implement..."
- "Plan out..." / "Design..."
- "How should we implement..."
- New feature requests
- Bug fixes that require investigation
- Refactoring tasks
Workflow Phases
Phase 1: Initial Understanding
Goal: Understand the codebase context relevant to the task.
Launch the
explore-codebaseagent to investigate:- Existing implementations related to the task
- Coding patterns and conventions
- Dependencies and related components
- Potential impact areas
Summarize findings for the user:
- Key files discovered
- Architecture overview
- Patterns to follow
- Areas of concern
Phase 2: Requirements Clarification
Goal: Ensure requirements are clear before planning.
Use the
requirements-analystagent to:- Analyze the user's request
- Identify ambiguities
- Generate clarifying questions
Present questions to the user:
- Prioritize by importance
- Provide options where possible
- Explain why each question matters
Wait for user responses before proceeding
- Do not make assumptions
- Record answers for planning phase
Phase 3: Technical Planning
Goal: Create a detailed, actionable implementation plan.
Launch the
plan-architectagent with:- Codebase exploration results
- Clarified requirements
- User preferences
Review the generated plan for:
- Completeness
- Correctness
- Alignment with requirements
Present the plan to the user:
- Summary of approach
- Step-by-step implementation guide
- Files to modify
- Risks and mitigations
Phase 4: Finalization
Goal: Get user approval and prepare for implementation.
Incorporate user feedback:
- Address concerns
- Adjust approach if needed
- Add missing details
Write final plan to
.claude/plans/directory:- Use descriptive filename
- Include all context needed
- Make it standalone readable
Confirm readiness:
- Ask for explicit approval
- Clarify next steps
- Offer to begin implementation
Important Guidelines
AIGP Coding Standards (MANDATORY)
Reference: references/coding-standards.md
All plans must ensure:
- Models inherit from
BaseModel(audit fields) - Serializers inherit from
CustomBaseSerializer - Views use
APIViewwith permission classes - Write operations use
@transaction.atomic - Success responses use
create_success_response() - Errors use
LogicError()with domain error codes - OpenAPI documentation via
@extend_schema - URLs follow
/api/v1/prefix and kebab-case - Queries filter
is_delete=False(soft deletes)
Never Skip Phases
- Always explore the codebase before planning
- Always clarify requirements before architecting
- Always get approval before implementing
Communication Style
- Be concise but thorough
- Use bullet points for clarity
- Highlight critical decisions
- Explain trade-offs
Plan Output Location
Save all plans to: .claude/plans/[task-name].md
Quality Standards
- Plans must be actionable (no vague steps)
- Files must have full paths
- Testing must be addressed
- Risks must be documented
Trigger Phrases
This skill activates automatically for:
- Feature requests: "add", "implement", "create", "build"
- Planning requests: "plan", "design", "architect", "how should we"
- Investigation: "investigate", "analyze", "understand"
- Refactoring: "refactor", "improve", "optimize", "restructure"
Example Workflow
User: "I need to add email notifications when orders are placed"
Phase 1: Explore codebase for:
- Order processing code
- Existing notification systems
- Email configuration
- Event handling patterns
Phase 2: Ask clarifying questions:
- What email provider should we use?
- Should notifications be async?
- What information should the email contain?
Phase 3: Create plan:
- Add email service integration
- Create notification template
- Hook into order completion event
- Add configuration options
Phase 4: Present plan and get approval