From godmode
Use when you have a spec or requirements for a multi-step task, before touching code
npx claudepluginhub noobygains/godmode --plugin godmodeThis skill uses the workspace's default tool permissions.
Produce thorough implementation plans written for an engineer with zero familiarity with the codebase and unreliable design instincts. Spell out everything: which files to touch per task, exact code, testing procedures, relevant documentation, how to verify each step. Deliver the plan as granular, self-contained tasks. DRY. YAGNI. TDD. Frequent commits.
Creates TDD implementation plans for multi-step features from specs, with granular tasks, exact file paths, code/tests/commands, and git commits. Use before coding.
Mandates invoking relevant skills via tools before any response in coding sessions. Covers access, priorities, and adaptations for Claude Code, Copilot CLI, Gemini CLI.
Share bugs, ideas, or general feedback.
Produce thorough implementation plans written for an engineer with zero familiarity with the codebase and unreliable design instincts. Spell out everything: which files to touch per task, exact code, testing procedures, relevant documentation, how to verify each step. Deliver the plan as granular, self-contained tasks. DRY. YAGNI. TDD. Frequent commits.
Assume the engineer is technically competent but knows almost nothing about the project's tooling or problem domain. Assume their test design skills are weak.
Announce at start: "I'm applying the task-planning skill to build the implementation plan."
Context: This should run in a dedicated worktree (created during the intent-discovery phase).
Save plans to: docs/plans/YYYY-MM-DD-<feature-name>.md
NO IMPLEMENTATION WITHOUT A PLAN FIRST
No exceptions. No workarounds. No shortcuts.
Required:
Not required:
Tempted to think "this is too simple for a plan"? If it touches more than one file, write the plan.
Before writing a plan, confirm ALL of these:
Any item unclear? Stop. Return to intent-discovery or consult your human partner. Do NOT write a plan with gaps -- gaps become defects.
| Rationalization | What Is Actually True |
|---|---|
| "Too simple for a plan" | Simple tasks contain hidden complexity. Plans take 5 minutes. Debugging takes hours. |
| "I'll figure it out as I go" | That is called hacking. You will miss edge cases and skip verification steps. |
| "The spec IS the plan" | Specs describe WHAT. Plans describe HOW, step by step, with file paths and commands. |
| "I already know what to do" | Excellent. Write it down. If it is obvious, the plan writes itself in 2 minutes. |
| "Plans slow me down" | Rework slows you down. Plans prevent rework. Net time saved every time. |
| "I'll add the plan after" | A plan written after implementation is documentation, not a plan. It cannot prevent mistakes already made. |
Never:
Always:
Each step is one action (2-5 minutes):
Every plan MUST open with this header:
# [Feature Name] Implementation Plan
> **For Claude:** REQUIRED SUB-SKILL: Use godmode:task-runner to implement this plan task-by-task.
**Goal:** [One sentence describing what this builds]
**Architecture:** [2-3 sentences about the approach]
**Tech Stack:** [Key technologies/libraries]
---
### Task N: [Component Name]
**Files:**
- Create: `exact/path/to/file.py`
- Modify: `exact/path/to/existing.py:123-145`
- Test: `tests/exact/path/to/test.py`
**Step 1: Write the failing test**
```python
def test_specific_behavior():
result = function(input)
assert result == expected
```
**Step 2: Run test to verify failure**
Run: `pytest tests/path/test.py::test_name -v`
Expected: FAIL with "function not defined"
**Step 3: Write minimal implementation**
```python
def function(input):
return expected
```
**Step 4: Run test to verify it passes**
Run: `pytest tests/path/test.py::test_name -v`
Expected: PASS
**Step 5: Commit**
```bash
git add tests/path/test.py src/path/file.py
git commit -m "feat: add specific feature"
```
godmode:test-first)After saving the plan, offer the user a choice:
"Plan complete and saved to docs/plans/<filename>.md. Two execution options:
1. Delegated Execution (this session) - I dispatch a fresh subagent per task, review between tasks, fast iteration
2. Separate Session - Open a new session with task-runner, batch execution with checkpoints
Which approach?"
If Delegated Execution chosen:
If Separate Session chosen:
Required workflow skills:
digraph plan_construction {
rankdir=TB;
node [shape=box, style=filled, fontname="Helvetica"];
start [label="Task received", shape=ellipse, fillcolor="#e0e0e0"];
check_scope [label="Multi-step?\nMultiple files?", shape=diamond, fillcolor="#ffffcc"];
no_plan [label="No plan needed\nJust do it", fillcolor="#ccffcc"];
gate [label="Entry Protocol\nAll 6 items verified?", shape=diamond, fillcolor="#ffffcc"];
go_back [label="Return to\nintent-discovery\nor ask human", fillcolor="#ffcccc"];
write_header [label="Write plan header\nGoal / Architecture / Stack", fillcolor="#cce5ff"];
write_tasks [label="Write granular tasks\nFiles / Test / Implement / Verify / Commit", fillcolor="#cce5ff"];
review [label="Review plan\nAll paths exact?\nAll code complete?", shape=diamond, fillcolor="#ffffcc"];
fix_plan [label="Fill gaps\nin plan", fillcolor="#ffcccc"];
save [label="Save to\ndocs/plans/", fillcolor="#ccffcc"];
handoff [label="Offer execution\nchoice to human", fillcolor="#ccffcc"];
start -> check_scope;
check_scope -> no_plan [label="no"];
check_scope -> gate [label="yes"];
gate -> go_back [label="gaps"];
gate -> write_header [label="all verified"];
go_back -> gate [label="resolved"];
write_header -> write_tasks;
write_tasks -> review;
review -> fix_plan [label="gaps found"];
fix_plan -> review;
review -> save [label="complete"];
save -> handoff;
}