ULW Plan
code-yeongyu/oh-my-openagent
Acts as an explore-first planning consultant that studies the codebase and writes a single decision-complete work plan before any implementation starts.
Planning agent for task breakdown and implementation planning.
Install Plan
$ npx skills add EliasOulkadi/shokunin --skill plan -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install EliasOulkadi/shokunin plan --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/EliasOulkadi/shokunin.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.pack/skills/plan .claude/skills/plan && rm -rf skills-srcUse ~/.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/
Install the "plan" agent skill from https://github.com/EliasOulkadi/shokunin/tree/master/.pack/skills/plan into .claude/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/EliasOulkadi/shokunin/tree/master/.pack/skills/planType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add EliasOulkadi/shokunin --skill plan -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install EliasOulkadi/shokunin plan --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EliasOulkadi/shokunin.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.pack/skills/plan .agents/skills/plan && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "plan" agent skill from https://github.com/EliasOulkadi/shokunin/tree/master/.pack/skills/plan into .agents/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add EliasOulkadi/shokunin --skill plan -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install EliasOulkadi/shokunin plan --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EliasOulkadi/shokunin.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.pack/skills/plan .cursor/skills/plan && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "plan" agent skill from https://github.com/EliasOulkadi/shokunin/tree/master/.pack/skills/plan into .cursor/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/EliasOulkadi/shokunin.git --path .pack/skills/plan--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add EliasOulkadi/shokunin --skill plan -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install EliasOulkadi/shokunin plan --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EliasOulkadi/shokunin.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.pack/skills/plan .gemini/skills/plan && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "plan" agent skill from https://github.com/EliasOulkadi/shokunin/tree/master/.pack/skills/plan into .gemini/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install EliasOulkadi/shokunin planInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add EliasOulkadi/shokunin --skill plan -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/EliasOulkadi/shokunin.git skills-src && mkdir -p .github/skills && cp -r skills-src/.pack/skills/plan .github/skills/plan && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "plan" agent skill from https://github.com/EliasOulkadi/shokunin/tree/master/.pack/skills/plan into .github/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add EliasOulkadi/shokunin --skill plan -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install EliasOulkadi/shokunin plan --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/EliasOulkadi/shokunin.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.pack/skills/plan .opencode/skills/plan && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "plan" agent skill from https://github.com/EliasOulkadi/shokunin/tree/master/.pack/skills/plan into .opencode/skills/plan/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "plan", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
plan- GitHub stars
- 114
- Token cost
- ~1.9k tokens
- SKILL.md length
- 852 words
- Files
- 1
- Skills in repo
- 49
- Repo updated
- First seen
- Licence
- MIT
At a glance
Planning agent for task breakdown and implementation planning.
- Works in 4 steps: Initial Understanding → Design → Review → …
- Tasks that involve Task breakdown
- SKILL.md covers Workflow, Plan Structure Template, Common Planning Patterns and Anti-Patterns, plus 3 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Plan is an agent skill from EliasOulkadi/shokunin. Planning agent for task breakdown and implementation planning. Use via spawnsubagent with skill='plan' when you need to explore a codebase and design an implementation approach before writing code.
Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: opencode
It sits in Agent Workflows, covering Task breakdown, Subagents and Planning. The repository describes itself as: 職人 Shokunin 62 AI agent skills for OpenCode, Claude Code, Cursor, Windsurf. ChromaDB memory, MCP servers, declarative self-updates. Multi-model, open source, zero cost. The licence is MIT.
When your agent uses it
- Tasks that involve Task breakdown
- Tasks that involve Subagents
- Tasks that involve Planning
Example prompts
- “/plan”
Requirements
- Compatibility (from SKILL.md): opencode
Workflow steps
4 steps, taken from the step headings in SKILL.md.
What it can do on your machine
Read from SKILL.md and the folder at commit 4c68e5b. 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
No scripts in the folder and no shell commands in SKILL.md.
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
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.
Compatibility
opencode
From compatibility in the SKILL.md frontmatter.
Context cost
Plan loads about 1.9k tokens when it runs. Until then it costs about 51 tokens; SKILL.md has 852 words of instructions outside code blocks.
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 EliasOulkadi/shokunin at commit 4c68e5b, republished under its MIT licence (© EliasOulkadi). 852 words, ~1,921 tokens.
Download SKILL.mdSave it as
.claude/skills/plan/SKILL.md (or your agent's skills folder).- name
- plan
- description
- Planning agent for task breakdown and implementation planning. Use via spawn_subagent with skill='plan' when you need to explore a codebase and design an implementation approach before writing code.
- compatibility
- opencode
- triggers
- plan, implementation plan, task breakdown, break down task, plan implementation, how to implement, technical plan, execution plan
- negatives
- write code, implement now, just do it, simple task
- license
- MIT
- metadata.version
- 1.0.0
- metadata.workflow
- system
- metadata.audience
- developers
- disable-model-invocation
- false
Entered plan mode. Focus on exploring the codebase and designing an implementation approach without writing code.
In plan mode:
- Thoroughly explore the codebase to understand existing patterns
- Identify similar features and architectural approaches
- Consider multiple approaches and their trade-offs
- Design a concrete implementation strategy
- Write the plan and return its path
DO NOT write or edit any files yet (except the plan file). This is a read-only exploration and planning phase.
Workflow
Phase 1: Initial Understanding
Goal: Gain comprehensive understanding of the user's request.
Use only research agents — no other agent types.
Understand the user's request and associated code
Launch research agents in parallel (single message, multiple calls):
- Use
skill: 'research'for all exploration agents - Use the cheapest model available
- 1 agent for isolated tasks with known files
- Multiple agents for uncertain scope, multiple codebase areas, or pattern discovery
- Max 3 agents — usually 1 is enough
- Use
Use multiple agents when:
- Task touches multiple parts of the codebase
- Large refactor or architectural change
- Many edge cases to consider
- Need to compare different approaches
Phase 2: Design
Goal: Design an implementation approach based on exploration results.
Launch 1-3 design agents in parallel:
- Default: 1 design agent for most tasks
- Skip agents: Only for trivial tasks (typo fixes, single-line changes, simple renames)
- Multiple agents: For complex tasks needing different perspectives
Example perspectives by task type:
- New feature: simplicity vs performance vs maintainability
- Bug fix: root cause vs workaround vs prevention
- Refactoring: minimal change vs clean architecture
For each agent:
- Provide comprehensive background from Phase 1
- Describe requirements and constraints
- Request a detailed implementation plan
Phase 3: Review
Goal: Review plans and ensure alignment with user's intentions.
- Read critical files identified by agents
- Verify plans align with the original request
- Do NOT call subagents here
Phase 4: Final Plan
Goal: Write the final plan. Include:
- Only the recommended approach, not alternatives
- Critical file paths to be modified
- Verification section (how to test end-to-end)
- Concise enough to scan, detailed enough to execute
Plan Structure Template
## Plan: [Feature Name]
### Summary
[1-2 sentence overview of what will be built/changed]
### Files to Modify
| File | Change |
|------|--------|
| path/to/file.ts | [what changes] |
### Implementation Steps
1. [Step 1]: [what to do, why, any gotchas]
2. [Step 2]: [what to do, why, any gotchas]
3. [Step 3]: [what to do, why, any gotchas]
### Architecture Decisions
| Decision | Choice | Rationale |
|----------|--------|-----------|
| [Decision] | [Choice] | [Why this over alternatives] |
### Risks & Mitigations
| Risk | Probability | Mitigation |
|------|-------------|------------|
| [Risk] | Low/Med/High | [Mitigation] |
### Verification
- [ ] [Test command / manual check]
- [ ] [Edge case to verify]Common Planning Patterns
| Pattern | When to use |
|---|---|
| Surgical | Small, isolated change. Read 1-2 files, write plan in 1 message. |
| Scout | Adding to existing pattern. Find 3+ similar implementations first. |
| Architect | New feature or refactor. Full phases 1-4 with multiple agents. |
| Emergency | Production bug. Skip to fix, plan doc optional. |
Anti-Patterns
| Mistake | Fix |
|---|---|
| Over-planning trivial changes | Small typo? Just fix it. Plan adds no value. |
| Under-planning complex changes | New feature across 10 files? Always go through phases 1-4. |
| Skipping verification | Always include how to test the end result. |
| Too many alternatives in final plan | Choose one. Use the plan file, not a discussion document. |
| Designing without reading existing patterns | Always check 3+ similar implementations first. |
Show full SKILL.md (397 more words)Show less
Error Handling
| Cause | Fix |
|---|---|
| Research subagent returns incomplete or empty results | The subagent may have hit a timeout or the codebase scope was too narrow. Re-launch with explicit file paths and a more focused query. If still empty, read the files directly. |
| Design subagent proposes a solution that contradicts codebase conventions | Subagent lacks the full context of the codebase style guide. Manually review the plan against 3+ existing implementations. Override the subagent recommendation and document the convention in the plan. |
| Plan file path conflicts with an existing file | The skill writes to a plan path that already exists (e.g., PLAN.md was already created). Append a timestamp: PLAN-20260518-143000.md. Ask user if they want to overwrite or keep both. |
| Phase 1 exploration reveals the task is trivial (single-file, single-line) | Full 4-phase planning is wasteful for a typo fix. Abort plan mode. Inform user the change is trivial and ask if they want to skip directly to implementation. |
| Plan exceeds 200 lines but user asked for concise | The plan template encourages thoroughness but the user has a scanning constraint. Collapse "Files to Modify" to a 3-column table. Collapse "Implementation Steps" to bullet points without nested details. |
| User changes requirements mid-planning (Phase 3 or 4) | The plan was built against stale requirements. Do not patch the existing plan. Return to Phase 1 with the new requirements. Archive the old plan with a deprecation comment. |
Checklist
- Codebase explored before writing the plan — dependencies, conventions, patterns identified
- All edge cases and failure modes documented, not just happy path
- Estimations include testing, documentation, and verification time
- Dependencies and risks explicitly called out
- Plan is reviewable independently — enough context for another developer to evaluate
Sources
- "The Pragmatic Programmer" by David Thomas and Andrew Hunt (Addison-Wesley, 20th Anniversary Edition, 2019) — tracer bullet development and prototyping principles
- "Software Architecture: The Hard Parts" by Neal Ford, Mark Richards, Pramod Sadalage, Zhamak Dehghani (O'Reilly, 2021) — architectural decision records and trade-off analysis
- "A Philosophy of Software Design" by John Ousterhout (Yaknyam Press, 2nd Edition, 2021) — deep module design and complexity management
- Google Design Docs culture (google.github.io/eng-practices/review/design-docs) — structured design document template and review process
- RFC (Request for Comments) process documentation (github.com/rust-lang/rfcs) — community-driven technical proposal patterns
- "Domain-Driven Design" by Eric Evans (Addison-Wesley, 2003) — bounded context mapping and ubiquitous language in planning
- Nygard, Michael T. "Release It! Design and Deploy Production-Ready Software" (Pragmatic Bookshelf, 2nd Edition, 2018) — stability patterns and failure mode planning
© EliasOulkadi, 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 .pack/skills/plan of EliasOulkadi/shokunin.
Open the folder on GitHubat commit 4c68e5b
Compare with similar skills
Plan 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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Plan this skillEliasOulkadi/shokunin | 114 | — | ~1.9k | Automated safety check: Pass | MIT | |
| ULW Plancode-yeongyu/oh-my-openagent | 70k | — | ~4.9k | Automated safety check: Pass | Custom licence | |
| Execute Taskanombyte93/prd-taskmaster | 605 | — | ~4.8k | Automated safety check: Notes | MIT | |
| Phased Plan Makerthedotmack/claude-mem | 99k | — | ~788 | Automated safety check: Pass | Apache-2.0 | |
| Subagent Driven DevelopmentAsvarox/allkaraoke | 261 | 38 repos | ~1.2k | Automated safety check: Pass | None | |
| Planning And Task Breakdownabashev/vfs-s3 | 106 | 8 repos | ~1.9k | Automated safety check: Pass | Apache-2.0 |
Similar skills
Execute Task
anombyte93/prd-taskmaster
Execute the next TaskMaster task using the implementation plan with CDD verification.
Phased Plan Maker
thedotmack/claude-mem
Creates a phased implementation plan that begins with documentation discovery and frames each phase to copy from docs, with verification checklists and anti-pattern guards.
Subagent Driven Development
Asvarox/allkaraoke
A skill your agent uses when executing implementation plans with independent tasks in the current session
Planning And Task Breakdown
abashev/vfs-s3
Breaks work into ordered tasks. An agent skill from abashev/vfs-s3.
ULW Plan Workflow
code-yeongyu/oh-my-openagent
Explore-first planning that turns a vague or large request into one decision-complete work plan, written only after your approval and executed by a separate worker.
More from EliasOulkadi/shokunin
All 49 skills in this repoCI CD
EliasOulkadi/shokunin
Design CI/CD pipelines for GitHub Actions, GitLab CI, and CircleCI with matrix builds, test sharding, caching, Docker layer caching, OIDC auth, deployment strategies (rolling, blue-green, canary)…
Component Forge
EliasOulkadi/shokunin
Build production-grade components for React, Vue 3, and Svelte 5 with all states (loading, empty, error, success, idle), TypeScript strict, WCAG 2.2 accessibility, server components (RSC), and…
DB Admin
EliasOulkadi/shokunin
PostgreSQL database administration — backup/restore (pgdump, PITR, WAL archiving), health monitoring (connections, bloat, cache hit ratio, dead tuples), connection pooling (PgBouncer), replication…
DB Sculptor
EliasOulkadi/shokunin
Design database schemas with Prisma/Drizzle, PostgreSQL index strategy (B-tree, GIN, GiST, BRIN, Hash), query optimization (EXPLAIN ANALYZE), migration safety (expand/contract, zero-downtime), and…
Docker
EliasOulkadi/shokunin
Optimize Docker images with multi-stage builds, distroless bases, BuildKit cache mounts, multi-arch builds, compose watch, security hardening (non-root, seccomp, capabilities drop), and…
Error Handler
EliasOulkadi/shokunin
Design error handling, structured logging, and observability with OpenTelemetry (traces, metrics, logs), error classification, recovery patterns (retry with jitter, circuit breaker, bulkhead…
Related
Categories
Questions about Plan
What does Plan do?
Planning agent for task breakdown and implementation planning. Plan is an agent skill from EliasOulkadi/shokunin. Planning agent for task breakdown and implementation planning.
When should I use Plan?
Plan fits situations like: tasks that involve Task breakdown; tasks that involve Subagents; tasks that involve Planning.
How do I install Plan in Claude Code?
Run `npx skills add EliasOulkadi/shokunin --skill plan -a claude-code`. Or copy the skill folder (.pack/skills/plan in EliasOulkadi/shokunin) into .claude/skills/plan in your project. Claude Code loads it when a task matches its description.
How do I install Plan in Codex?
Run `npx skills add EliasOulkadi/shokunin --skill plan -a codex`. Or copy the skill folder (.pack/skills/plan in EliasOulkadi/shokunin) into .agents/skills/plan in your project. Codex loads it when a task matches its description.
Can I use Plan 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 EliasOulkadi/shokunin --skill plan -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/plan, .gemini/skills/plan, .github/skills/plan and .opencode/skills/plan in your project.
What does Plan need to run?
SKILL.md names no scripts, command-line tools or credentials: Plan is instructions for the agent only. Compatibility (from SKILL.md): opencode.
Does Plan access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Plan 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 Plan use?
Plan 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 Plan use?
About 1.9k tokens (SKILL.md is roughly 7.7k 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 Plan?
Skills that share tags, products or a category with Plan: ULW Plan (code-yeongyu/oh-my-openagent, 70k stars), Execute Task (anombyte93/prd-taskmaster, 605 stars), Phased Plan Maker (thedotmack/claude-mem, 99k stars) and Subagent Driven Development (Asvarox/allkaraoke, 261 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Plan?
EliasOulkadi (a GitHub user) maintains it in EliasOulkadi/shokunin, which has 114 GitHub stars. The repository holds 49 skills in this directory. The repository was last updated on October 5, 2026.
Source: EliasOulkadi/shokunin on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.