New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Writing Plans

by RedWoodOG in RedWoodOG/Hermes-Desktop

A skill your agent uses when you have a spec or requirements for a multi-step task.

MITAuto-check passedAgent Workflows

Install Writing Plans

skills CLI
$ npx skills add RedWoodOG/Hermes-Desktop --skill writing-plans -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install RedWoodOG/Hermes-Desktop writing-plans --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/RedWoodOG/Hermes-Desktop.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/software-development/writing-plans .claude/skills/writing-plans && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
writing-plans
GitHub stars
177
Used in
3 other repos
Token cost
~1.8k tokens
SKILL.md length
571 words
Files
1
Skills in repo
62
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when you have a spec or requirements for a multi-step task.

  • Works in 7 steps: Understand Requirements → Explore the Codebase → Design Approach → …
  • You have a spec
  • SKILL.md covers Overview, When to Use, Bite-Sized Task Granularity and Plan Document Structure, plus 5 more sections
  • Calls git and pytest

What it does

Writing Plans is an agent skill from RedWoodOG/Hermes-Desktop. Use when you have a spec or requirements for a multi-step task. Creates comprehensive implementation plans with bite-sized tasks, exact file paths, and complete code examples.

Its SKILL.md is about 1.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Agent Workflows, covering Planning. The licence is MIT.

When your agent uses it

  • You have a spec
  • Requirements for a multi-step task

Example prompts

  • “/writing-plans”

Requirements

  • Python 3

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Understand Requirements
  2. Explore the Codebase
  3. Design Approach
  4. Write Tasks
  5. Add Complete Details
  6. Review the Plan
  7. Save the Plan

What it can do on your machine

Read from SKILL.md and the folder at commit be46b39. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • pytest

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Writing Plans loads about 1.8k tokens when it runs. Until then it costs about 47 tokens; SKILL.md has 571 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~47
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from RedWoodOG/Hermes-Desktop at commit be46b39, republished under its MIT licence (© RedWoodOG). 571 words, ~1,823 tokens.

Download SKILL.mdSave it as .claude/skills/writing-plans/SKILL.md (or your agent's skills folder).
name
writing-plans
description
Use when you have a spec or requirements for a multi-step task. Creates comprehensive implementation plans with bite-sized tasks, exact file paths, and complete code examples.
version
1.1.0
author
Hermes Agent (adapted from obra/superpowers)
license
MIT

Writing Implementation Plans

Overview

Write comprehensive implementation plans assuming the implementer has zero context for the codebase and questionable taste. Document everything they need: which files to touch, complete code, testing commands, docs to check, how to verify. Give them bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.

Assume the implementer is a skilled developer but knows almost nothing about the toolset or problem domain. Assume they don't know good test design very well.

Core principle: A good plan makes implementation obvious. If someone has to guess, the plan is incomplete.

When to Use

Always use before:

  • Implementing multi-step features
  • Breaking down complex requirements
  • Delegating to subagents via subagent-driven-development

Don't skip when:

  • Feature seems simple (assumptions cause bugs)
  • You plan to implement it yourself (future you needs guidance)
  • Working alone (documentation matters)

Bite-Sized Task Granularity

Each task = 2-5 minutes of focused work.

Every step is one action:

  • "Write the failing test" — step
  • "Run it to make sure it fails" — step
  • "Implement the minimal code to make the test pass" — step
  • "Run the tests and make sure they pass" — step
  • "Commit" — step

Too big:

markdown
### Task 1: Build authentication system
[50 lines of code across 5 files]

Right size:

markdown
### Task 1: Create User model with email field
[10 lines, 1 file]

### Task 2: Add password hash field to User
[8 lines, 1 file]

### Task 3: Create password hashing utility
[15 lines, 1 file]

Plan Document Structure

Header (Required)

Every plan MUST start with:

markdown
# [Feature Name] Implementation Plan

> **For Hermes:** Use subagent-driven-development skill 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]

---
Task Structure

Each task follows this format:

markdown
### Task N: [Descriptive Name]

**Objective:** What this task accomplishes (one sentence)

**Files:**
- Create: `exact/path/to/new_file.py`
- Modify: `exact/path/to/existing.py:45-67` (line numbers if known)
- Test: `tests/path/to/test_file.py`

**Step 1: Write 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_specific_behavior -v`
Expected: FAIL — "function not defined"

**Step 3: Write minimal implementation**

```python
def function(input):
    return expected
```

**Step 4: Run test to verify pass**

Run: `pytest tests/path/test.py::test_specific_behavior -v`
Expected: PASS

**Step 5: Commit**

```bash
git add tests/path/test.py src/path/file.py
git commit -m "feat: add specific feature"
```

Writing Process

Step 1: Understand Requirements

Read and understand:

  • Feature requirements
  • Design documents or user description
  • Acceptance criteria
  • Constraints
Step 2: Explore the Codebase

Use Hermes tools to understand the project:

python
# Understand project structure
search_files("*.py", target="files", path="src/")

# Look at similar features
search_files("similar_pattern", path="src/", file_glob="*.py")

# Check existing tests
search_files("*.py", target="files", path="tests/")

# Read key files
read_file("src/app.py")
Step 3: Design Approach

Decide:

  • Architecture pattern
  • File organization
  • Dependencies needed
  • Testing strategy
Step 4: Write Tasks

Create tasks in order:

  1. Setup/infrastructure
  2. Core functionality (TDD for each)
  3. Edge cases
  4. Integration
  5. Cleanup/documentation
Step 5: Add Complete Details

For each task, include:

  • Exact file paths (not "the config file" but src/config/settings.py)
  • Complete code examples (not "add validation" but the actual code)
  • Exact commands with expected output
  • Verification steps that prove the task works
Step 6: Review the Plan

Check:

  • Tasks are sequential and logical
  • Each task is bite-sized (2-5 min)
  • File paths are exact
  • Code examples are complete (copy-pasteable)
  • Commands are exact with expected output
  • No missing context
  • DRY, YAGNI, TDD principles applied
Show full SKILL.md (223 more words)Show less
Step 7: Save the Plan
bash
mkdir -p docs/plans
# Save plan to docs/plans/YYYY-MM-DD-feature-name.md
git add docs/plans/
git commit -m "docs: add implementation plan for [feature]"

Principles

DRY (Don't Repeat Yourself)

Bad: Copy-paste validation in 3 places Good: Extract validation function, use everywhere

YAGNI (You Aren't Gonna Need It)

Bad: Add "flexibility" for future requirements Good: Implement only what's needed now

python
# Bad — YAGNI violation
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.preferences = {}  # Not needed yet!
        self.metadata = {}     # Not needed yet!

# Good — YAGNI
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
TDD (Test-Driven Development)

Every task that produces code should include the full TDD cycle:

  1. Write failing test
  2. Run to verify failure
  3. Write minimal code
  4. Run to verify pass

See test-driven-development skill for details.

Frequent Commits

Commit after every task:

bash
git add [files]
git commit -m "type: description"

Common Mistakes

Vague Tasks

Bad: "Add authentication" Good: "Create User model with email and password_hash fields"

Incomplete Code

Bad: "Step 1: Add validation function" Good: "Step 1: Add validation function" followed by the complete function code

Missing Verification

Bad: "Step 3: Test it works" Good: "Step 3: Run pytest tests/test_auth.py -v, expected: 3 passed"

Missing File Paths

Bad: "Create the model file" Good: "Create: src/models/user.py"

Execution Handoff

After saving the plan, offer the execution approach:

"Plan complete and saved. Ready to execute using subagent-driven-development — I'll dispatch a fresh subagent per task with two-stage review (spec compliance then code quality). Shall I proceed?"

When executing, use the subagent-driven-development skill:

  • Fresh delegate_task per task with full context
  • Spec compliance review after each task
  • Code quality review after spec passes
  • Proceed only when both reviews approve

Remember

Bite-sized tasks (2-5 min each)
Exact file paths
Complete code (copy-pasteable)
Exact commands with expected output
Verification steps
DRY, YAGNI, TDD
Frequent commits

A good plan makes implementation obvious.

© RedWoodOG, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/software-development/writing-plans of RedWoodOG/Hermes-Desktop.

Open the folder on GitHubat commit be46b39

Used in 3 other repositories

We found 4 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 3 other GitHub owners. This page covers the copy in RedWoodOG/Hermes-Desktop, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Writing Plans next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Writing Plans compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Writing Plans this skillRedWoodOG/Hermes-Desktop1773 repos~1.8kAutomated safety check: PassMIT
Executing Plans Inlineobra/superpowers297k2 repos~5.1kAutomated safety check: PassMIT
Interview Meaddyosmani/agent-skills105k6 repos~3.8kAutomated safety check: PassMIT
OpenSpec Guided OnboardingFission-AI/OpenSpec72k1 repos~4.5kAutomated safety check: PassMIT
Writing Plansgeeksblabla/stateofdev.ma16358 repos~661Automated safety check: PassNone
Subagent Driven DevelopmentAsvarox/allkaraoke26138 repos~1.2kAutomated safety check: PassNone

Similar skills

  • Executing Plans Inline

    obra/superpowers

    Has the agent carry out an implementation plan itself, task by task in the current session, keeping a ledger, proving each step with a test and ending with one whole-branch review.

    297k GitHub starsUsed in 2 repos~5.1k tokens
    Agent WorkflowsAuto-check passed

  • Interview Me

    addyosmani/agent-skills

    Asks one question at a time, each with a best guess attached, until the agent is about 95 percent sure what you really want, before any plan, spec or code.

    105k GitHub starsUsed in 6 repos~3.8k tokens
    Agent WorkflowsAuto-check passed

  • OpenSpec Guided Onboarding

    Fission-AI/OpenSpec

    Walks you through a complete OpenSpec workflow cycle with narration while doing real work in your codebase.

    72k GitHub starsUsed in 1 repo~4.5k tokens
    Agent WorkflowsAuto-check passed

  • Writing Plans

    geeksblabla/stateofdev.ma

    A skill your agent uses when design is complete and you need detailed implementation tasks for engineers with zero codebase context - creates comprehensive implementation plans with exact file…

    163 GitHub starsUsed in 58 repos~661 tokens
    Agent WorkflowsAuto-check passed

  • Subagent Driven Development

    Asvarox/allkaraoke

    A skill your agent uses when executing implementation plans with independent tasks in the current session

    261 GitHub starsUsed in 38 repos~1.2k tokens
    Agent WorkflowsAuto-check passed

  • Planning With Files

    jd-opensource/JoySafeter

    Implements Manus-style file-based planning for complex tasks.

    314 GitHub starsUsed in 19 repos~1.8k tokens
    Agent WorkflowsAuto-check: notes

More from RedWoodOG/Hermes-Desktop

All 62 skills in this repo

  • Excalidraw

    RedWoodOG/Hermes-Desktop

    Create hand-drawn style diagrams using Excalidraw JSON format.

    177 GitHub starsUsed in 5 repos~1.8k tokens
    Auto-check passed

  • Obliteratus

    RedWoodOG/Hermes-Desktop

    Remove refusal behaviors from open-weight LLMs using OBLITERATUS — mechanistic interpretability techniques (diff-in-means, SVD, whitened SVD, LEACE, SAE decomposition, etc.) to excise guardrails…

    177 GitHub starsUsed in 5 repos~3.8k tokens
    Auto-check passed

  • Ascii Video

    RedWoodOG/Hermes-Desktop

    Production pipeline for ASCII art video — any format. An agent skill from RedWoodOG/Hermes-Desktop.

    177 GitHub starsUsed in 2 repos~3.2k tokens
    Auto-check passed

  • Systematic Debugging

    RedWoodOG/Hermes-Desktop

    A skill your agent uses when encountering any bug, test failure, or unexpected behavior.

    177 GitHub starsUsed in 6 repos~2.6k tokens
    Auto-check passed

  • Test Driven Development

    RedWoodOG/Hermes-Desktop

    A skill your agent uses when implementing any feature or bugfix, before writing implementation code.

    177 GitHub starsUsed in 6 repos~2.4k tokens
    Auto-check passed

  • Claude Code

    RedWoodOG/Hermes-Desktop

    Delegate coding tasks to Claude Code (Anthropic's CLI agent).

    177 GitHub starsUsed in 4 repos~784 tokens
    Auto-check passed

Categories

Questions about Writing Plans

What does Writing Plans do?

A skill your agent uses when you have a spec or requirements for a multi-step task. Writing Plans is an agent skill from RedWoodOG/Hermes-Desktop. Use when you have a spec or requirements for a multi-step task.

When should I use Writing Plans?

Writing Plans fits situations like: you have a spec; requirements for a multi-step task.

How do I install Writing Plans in Claude Code?

Run `npx skills add RedWoodOG/Hermes-Desktop --skill writing-plans -a claude-code`. Or copy the skill folder (skills/software-development/writing-plans in RedWoodOG/Hermes-Desktop) into .claude/skills/writing-plans in your project. Claude Code loads it when a task matches its description.

How do I install Writing Plans in Codex?

Run `npx skills add RedWoodOG/Hermes-Desktop --skill writing-plans -a codex`. Or copy the skill folder (skills/software-development/writing-plans in RedWoodOG/Hermes-Desktop) into .agents/skills/writing-plans in your project. Codex loads it when a task matches its description.

Can I use Writing Plans in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add RedWoodOG/Hermes-Desktop --skill writing-plans -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/writing-plans, .gemini/skills/writing-plans, .github/skills/writing-plans and .opencode/skills/writing-plans in your project.

What does Writing Plans need to run?

Going by SKILL.md and its folder, Writing Plans needs the command-line tools its instructions call (git and pytest). Our summary lists: Python 3.

Does Writing Plans access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Writing Plans safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Writing Plans use?

Writing Plans is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Writing Plans use?

About 1.8k tokens (SKILL.md is roughly 7.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Writing Plans?

Skills that share tags, products or a category with Writing Plans: Executing Plans Inline (obra/superpowers, 297k stars), Interview Me (addyosmani/agent-skills, 105k stars), OpenSpec Guided Onboarding (Fission-AI/OpenSpec, 72k stars) and Writing Plans (geeksblabla/stateofdev.ma, 163 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Writing Plans?

RedWoodOG (a GitHub user) maintains it in RedWoodOG/Hermes-Desktop, which has 177 GitHub stars. The repository holds 62 skills in this directory. The repository was last updated on May 30, 2026.

Source: RedWoodOG/Hermes-Desktop on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.