home / skills / doanchienthangdev / omgkit / writing-plans
This skill creates structured implementation plans with task breakdown, dependencies, risks, and file-level details to guide complex feature development.
npx playbooks add skill doanchienthangdev/omgkit --skill writing-plansReview the files below or copy the command above to add this skill to your agents.
---
name: writing-plans
description: AI agent creates structured implementation plans with task breakdown, dependency mapping, risk assessment, and file-level detail. Use when planning features, projects, or complex implementations.
---
# Writing Plans
## Quick Start
1. **Summarize** - Executive summary with goals, non-goals, background
2. **Design** - High-level approach, architecture diagram, key decisions
3. **Break Down** - Tasks in 2-4 hour chunks with file locations
4. **Map Dependencies** - Identify critical path and parallel opportunities
5. **Assess Risks** - Likelihood x Impact matrix with mitigations
6. **Estimate** - Three-point estimation with buffers
## Features
| Feature | Description | Guide |
|---------|-------------|-------|
| Plan Structure | Comprehensive template | Summary, design, tasks, testing, risks |
| Task Breakdown | Manageable work units | 2-4 hours, single owner, clear criteria |
| Dependency Mapping | Sequence and parallelize | Critical path, hard/soft dependencies |
| Risk Assessment | Anticipate problems | Likelihood x Impact matrix |
| Effort Estimation | Realistic timing | Three-point: (O + 4M + P) / 6 |
| File-Level Detail | Exact code locations | New files, modifications, line numbers |
## Common Patterns
```
# Plan Structure
# Plan: [Feature Name]
## Metadata
- Status: Draft | Approved | In Progress
- Estimated Duration: [X days]
- Priority: P0 | P1 | P2
## Goals & Non-Goals
Goals: [What this WILL accomplish]
Non-Goals: [What this will NOT address]
## Design Overview
[High-level approach, architecture diagram]
## Implementation Tasks
### Phase 1: [Foundation] - [X days]
#### Task 1.1: [Name]
- Description: [What]
- Estimate: [X hours]
- Files: `src/file.ts:45-60`
- Dependencies: None
- Acceptance Criteria:
- [ ] [Criterion 1]
- [ ] [Criterion 2]
## Risks & Mitigations
| Risk | Likelihood | Impact | Mitigation |
|------|------------|--------|------------|
| [Risk] | High | High | [Strategy] |
```
```
# Dependency Diagram
[START]
|
+----------+----------+
| | |
[Task 1] [Task 2] [Task 3] <- Parallel
| | |
+-----+----+ |
| |
[Task 4] [Task 5]
| |
+-------+-------+
|
[Task 6] <- Integration
|
[COMPLETE]
Critical Path: 1 -> 4 -> 6 (determines min duration)
```
```
# Effort Estimation
Three-Point: (Optimistic + 4*MostLikely + Pessimistic) / 6
Example - OAuth Implementation:
- Optimistic: 4 hours (works first try)
- Most Likely: 8 hours (normal dev)
- Pessimistic: 16 hours (issues)
Estimate = (4 + 32 + 16) / 6 = 8.7 hours
Buffers:
- Individual tasks: 20%
- Phase total: 30%
- Project total: 40%
```
## Best Practices
| Do | Avoid |
|----|-------|
| Keep tasks to 2-4 hour chunks | Vague tasks ("implement feature") |
| Include exact file locations | Skipping background/context |
| Specify clear acceptance criteria | Ignoring non-functional requirements |
| Map dependencies explicitly | Underestimating integration work |
| Build in buffer for unknowns | Planning more than 2 weeks in detail |
| Include testing in the plan | Hiding risks or uncertainties |
| Review plan with stakeholders | Assuming requirements are complete |
| Update plan as you learn | Forgetting rollback plans |
## Related Skills
- `executing-plans` - Follow plans systematically
- `thinking-sequentially` - Structure reasoning for plans
- `brainstorming-ideas` - Generate options for plans
- `verifying-before-completion` - Validate plan completion
This skill creates structured implementation plans that turn feature requests and project goals into executable work. It produces an executive summary, high-level design, task breakdown with file-level detail, dependency mapping, risk assessment, and three-point estimates. Plans are optimized for engineering teams to pick up and execute with minimal ambiguity.
I start by capturing goals, non-goals, and background to set scope. Next I produce a design overview and split the work into 2–4 hour tasks with owner suggestions and exact file locations. I map dependencies, identify the critical path, create a likelihood×impact risk matrix with mitigations, and compute three-point estimates plus recommended buffers.
How granular should task estimates be?
Aim for 2–4 hour tasks so work can be completed and reviewed within a single session; larger efforts should be split into clear sub-tasks.
How are buffers applied?
Apply ~20% per individual task, ~30% per phase, and ~40% at the project level as suggested starting points; adjust based on uncertainty and team experience.