Use when design is complete and you need detailed implementation tasks for engineers with zero codebase context - creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps assuming engineer has minimal domain knowledge
/plugin marketplace add udecode/dotai/plugin install plan@dotaiThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.
Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
Announce at start: "I'm using the writing-plans skill to create the implementation plan."
Save plans to: .claude/docs/plans/<feature-name>-plan.md
Testing Strategy: Auto-decide whether unit tests are needed based on complexity:
Each step is one action (2-5 minutes):
If tests are included (for complex behavior):
If no tests (for simple changes):
Every plan MUST start with this header:
# [Feature Name] Implementation Plan
**Goal:** [One sentence describing what this builds]
**Architecture:** [2-3 sentences about approach]
**Tech Stack:** [Key technologies/libraries]
**Testing Approach:** [If tests included: "TDD with deterministic unit tests for complex logic (Tasks X, Y, Z)" | If no tests: "Code review and typecheck verification - logic is straightforward and bug-free"]
---
### Task N: [Component Name]
**Files:**
- Create: `exact/path/to/file.ts`
- Modify: `exact/path/to/existing.ts:123-145`
- Test: `tests/exact/path/to/test.spec.ts`
**Step 1: Write the failing test**
```typescript
describe('specific behavior', () => {
it('should return expected result', () => {
const result = function(input);
expect(result).toBe(expected);
});
});
```
**Step 2: Run test to verify it fails**
Run: `npm run test -- test.spec.ts`
Expected: FAIL with "function is not defined"
**Step 3: Write minimal implementation**
```typescript
export function function(input: InputType): ReturnType {
return expected;
}
```
**Step 4: Run test to verify it passes**
Run: `npm run test -- test.spec.ts`
Expected: PASS
**Step 5: Commit**
```bash
git add tests/path/test.spec.ts src/path/file.ts
git commit -m "feat: add specific feature"
```
### Task N: [Component Name]
**Files:**
- Create: `exact/path/to/file.ts`
- Modify: `exact/path/to/existing.ts:123-145`
**Step 1: Implement the code**
```typescript
export function function(input: InputType): ReturnType {
return expected;
}
```
**Step 2: Verify with typecheck**
Run: `npm run typecheck`
Expected: No errors
**Step 3: Verify with lint**
Run: `npm run lint`
Expected: No errors
**Step 4: Commit**
```bash
git add src/path/file.ts
git commit -m "feat: add specific feature"
```
IMPORTANT: Plans include commit steps, but executing-plans will handle commit approval.
During Execution (not plan writing):
In this skill (plan writing):
After saving the plan, offer execution choice:
"Plan complete and saved to .claude/docs/plans/<filename>.md. Two execution options:
1. This Session (default) - Execute tasks iteratively in this session, reviewing and adjusting between tasks
2. Parallel Session - Open new session with executing-plans skill for batch execution with checkpoints
Which approach? (Press Enter for option 1)"
If This Session (default):
If Parallel Session chosen:
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.