Use when design is complete and you need detailed implementation tasks - creates tracked MCP issues with exact file paths, complete code examples, and verification steps. Optional reference plan file for architecture overview.
Creates detailed TDD implementation plans with bite-sized tasks, exact file paths, complete code examples, and verification commands. Use after design is complete to break work into tracked MCP issues for autonomous execution.
/plugin marketplace add samjhecht/wrangler/plugin install wrangler@samjhecht-pluginsThis skill inherits all available tools. When active, it can use any tool Claude has access to.
MANDATORY: When using this skill, announce it at the start with:
š§ Using Skill: writing-plans | [brief purpose based on context]
Example:
š§ Using Skill: writing-plans | [Provide context-specific example of what you're doing]
This creates an audit trail showing which skills were applied during the session.
Write comprehensive implementation plans assuming the engineer has zero context for our codebase. 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.
MCP issues are the source of truth - each tracked task contains complete implementation details.
Optionally create:
.wrangler/plans/YYYY-MM-DD-PLAN_<spec>.md) - Architecture overview and design decisions (reference only)Works in main branch OR worktree (no preference)
Headless mode: If run as subagent, do not stop to ask for feedback during execution.
Each step is one action (2-5 minutes):
Plan files are OPTIONAL - use when architecture/design context needs documentation.
Create optional plan file when ANY of these are true:
ā 10+ issues/tasks - Need architectural overview to understand big picture ā Multiple interconnected components - Need system diagram and component relationships ā Significant design decisions - Need to document rationale and alternatives considered ā Complex patterns/conventions - Need reference material that applies across multiple tasks ā Onboarding context needed - Future agents/sessions would struggle understanding issues in isolation
Skip plan file when:
ā < 5 simple tasks - Straightforward implementation, issues are sufficient ā No architectural complexity - Changes are localized and self-explanatory ā Obvious approach - No design decisions requiring rationale
Plan file should contain:
# [Feature Name] Implementation Plan
> **For Claude:** REQUIRED SUB-SKILL: Use /wrangler:implement to implement this plan task-by-task.
**Goal:** [One sentence describing what this builds]
**Architecture:** [2-3 sentences about approach]
**Tech Stack:** [Key technologies/libraries]
**Implementation tracking:** See MCP issues (project: [specification filename])
---
Each issue MUST contain:
NOT in issues:
Think deeply about task ordering:
MCP issues contain ALL implementation details. For each task, call issues_create with complete information:
{
title: "Task N: [Short action-oriented title]",
description: `## Description
[What this task implements - refer to specification]
## Context
Reference: [specification filename]
[Relevant architectural context and design decisions]
## Files
- Create: \`path/to/new/file.ts\`
- Modify: \`path/to/existing.ts:45-67\`
- Test: \`path/to/test.ts\`
## Implementation Steps
**Step 1: Write the failing test**
\`\`\`typescript
// Complete test code
describe('feature', () => {
it('should behave correctly', () => {
// Exact test implementation
});
});
\`\`\`
**Step 2: Run test to verify it fails**
Run: \`npm test -- path/to/test.ts\`
Expected: FAIL with "[expected error message]"
**Step 3: Write minimal implementation**
\`\`\`typescript
// Complete implementation code
export function feature() {
// Exact minimal implementation
}
\`\`\`
**Step 4: Run test to verify it passes**
Run: \`npm test -- path/to/test.ts\`
Expected: PASS
**Step 5: Commit**
\`\`\`bash
git add path/to/test.ts path/to/file.ts
git commit -m "feat: add specific feature"
\`\`\`
## Acceptance Criteria
- [ ] Test written and failing (RED)
- [ ] Implementation passes test (GREEN)
- [ ] Code refactored if needed (REFACTOR)
- [ ] All tests passing
- [ ] Committed with clear message
## Dependencies
- Requires completion of: Task [N-1]
`,
type: "issue",
status: "open",
priority: "medium", // or high/low based on criticality
labels: ["plan-step", "implementation"],
project: "[specification filename]",
wranglerContext: {
agentId: "plan-executor",
parentTaskId: "", // if breaking down larger issue
estimatedEffort: "[time estimate if known]"
}
}
Important:
issues_update if you need to refine an issue after creation (don't create duplicates)issues_list filtered by project: [specification filename] to verify all issues createdissues_updateAfter creating issues, offer execution choice:
"Plan complete:
.wrangler/plans/YYYY-MM-DD-PLAN_<spec>.md (architecture reference)Execution options:
Ready to implement?
Use /wrangler:implement with one of these scopes:
/wrangler:implement (auto-infers from plan file in context)/wrangler:implement issues 1-N (specific issue range)/wrangler:implement plan-filename.md (explicit plan file)The implement skill will:
If you discover during planning that a task needs refinement:
// Instead of creating new issue
issues_update({
id: "[issueId]",
priority: "high", // change priority
description: "[updated description]", // add more detail
labels: ["plan-step", "implementation", "complex"] // add label
})
issues_list)When working from a specification created with writing-specifications skill:
Master defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requiring fault tolerance and safety.