home / skills / htooayelwinict / claude-config / project-planning

project-planning skill

safe

This skill helps planners create clear, step-by-step implementation plans with acceptance criteria using MCP helpers for efficient project execution.

npx playbooks add skill htooayelwinict/claude-config --skill project-planning

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.9 KB

---
name: project-planning
description: Create clear, step-by-step implementation plans with acceptance criteria using MCP helpers. EXCLUSIVE to planner agent.
allowed-tools: Read, Grep, Glob, Bash, mcp_gemini-bridge, mcp_open-bridge, mcp_codex-bridge, mcp_context7
---
# Project Planning

**Exclusive to:** `planner` agent

## MCP Helpers (Brain + Memory)

### 🧠 Gemini-Bridge (Brain) — Architecture Analysis
```
mcp_gemini-bridge_consult_gemini(
  query="Design architecture for [feature]: phases, risks, dependencies...",
  directory="."
)
```

### 🌉 Open-Bridge — Alternative Architecture Analysis
```
mcp_open-bridge_consult_gemini(
  query="Design architecture for [feature]: phases, risks, dependencies...",
  directory="."
)
```

### 📚 Context7 (Memory) — Documentation Lookup
```
mcp_context7_resolve-library-id(libraryName="laravel", query="[feature]")
mcp_context7_query-docs(libraryId="/laravel/docs", query="[specific pattern]")
```

## Supported Stacks

**PHP/Laravel:** Laravel 12, Inertia.js, React 19, TypeScript, Tailwind
**Python:** FastAPI, LangChain, LangGraph, Pydantic, pytest

## Instructions

### 1. Restate Goal
One sentence summary of what we're building.

### 2. Research
- Search codebase for similar patterns
- Identify affected files
- Note dependencies

### 3. Break Down
Create 3-5 phases, each independently testable.

## Estimation Techniques

### T-Shirt Sizing
| Size | Hours | Complexity |
|------|-------|------------|
| XS | 1-2 | Single file |
| S | 2-4 | Few files |
| M | 4-8 | Multiple files |
| L | 1-2 days | Multiple components |
| XL | 3-5 days | Full feature |

### Risk Multipliers
- Database migration: 1.5x
- Auth/security: 1.5x
- Third-party: 2x

## Risk Matrix

| Level | Criteria | Mitigation |
|-------|----------|------------|
| 🔴 High | Data loss, security, breaking | Rollback plan, staging |
| 🟡 Medium | Performance, UX regression | Feature flag |
| 🟢 Low | Cosmetic, refactor | Standard testing |

## Phase Template

```markdown
# Phase N: [Name]

## Objective
[What this accomplishes]

## Tasks
- [ ] Task with file path

## Files
| File | Action |
|------|--------|
| `path/file` | Create/Modify |

## Verification
```bash
[commands]
```

## Estimate
[X hours]
```

## plan.md Output (REQUIRED)

Always create a consolidated `plan.md` file that contains ALL phases and context:

```markdown
# Plan: [Feature Name]

## Context
[What we're building and why]

## Code Patterns to Follow
[Key patterns from codebase research]

## Phases
| # | Name | Objective | Est. |
|---|------|-----------|------|

---

## Phase 1: [Name]
### Objective
[Goal]

### Tasks
- [ ] Task with `path/to/file`

### Files
| File | Action |
|------|--------|

---

[... repeat for each phase ...]

---

## Summary
- **Total Phases**: N
- **Estimated Effort**: X hours
- **Key Risks**: [list]
```

## Examples
- "Plan a new settings page"
- "Create a migration plan for adding a column safely"

Overview

This skill creates clear, step-by-step implementation plans with acceptance criteria, estimates, and a consolidated plan.md output. It is exclusive to the planner agent and uses MCP helpers for architecture analysis and documentation lookup to ground plans in codebase context. The output emphasizes independent, testable phases, risk-aware estimates, and concrete verification steps.

How this skill works

The skill inspects the codebase and documentation using MCP helpers (Gemini-Bridge/Open-Bridge for architecture analysis and Context7 for docs lookup) to find similar patterns, impacted files, and dependencies. It then produces a multi-phase plan with objectives, task lists, file actions, verification commands, estimates (T-shirt sizing and hours), and a summary plan.md ready for review. It annotates risks and applies risk multipliers for migrations, auth, and third-party integrations.

When to use it

Planning a new feature end-to-end with deployable milestones
Preparing a safe database migration or schema change
Onboarding a cross-functional implementation with clear responsibilities
Estimating effort and risks before sprint planning or stakeholder sign-off
Creating a rollback and verification checklist for production releases

Best practices

Start with one-sentence goal restatement to align scope
Search the codebase for matching patterns and list affected files explicitly
Break work into 3–5 independently testable phases with clear verification steps
Use T-shirt sizing plus risk multipliers (DB/auth/third-party) for estimates
Produce a single plan.md containing context, phases, file actions, commands, and summary

Example use cases

Plan a new settings page with front-end and API changes, tests, and feature flag rollout
Create a migration plan to add a column safely with migration scripts, backfill, and rollback
Design a staged rollout for an auth change with feature flags and monitoring checkpoints
Draft an integration plan for a third-party payment provider including configs and error handling
Map work for converting a legacy endpoint to typed schemas with unit and integration tests

FAQ

What exact outputs will I get?

You get a consolidated plan.md with context, code patterns, a phases table, detailed phase sections (tasks, files, verification), estimates, and a risk summary.

How are estimates calculated?

Estimates use T-shirt sizing mapped to hours and apply risk multipliers (1.5× for DB/auth, 2× for third-party) where applicable.

How many phases should a plan include?

Prefer 3–5 phases so each phase remains independently testable and verifiable; complex features may need more granular sub-tasks.