Writing Implementation Plans
Break complex features into bite-sized tasks with exact file paths, code, and verification.
The skill itself only requests to generate implementation plans, no dangerous operations like deletion, overwriting, or data transfer, and explicitly requires commits to local git repository (no external push). However, the skill does not mention user confirmation mechanism, and may rely on external services or tools during execution, but data flow transparency is not specified; no red-line risks found. Deduction: no sensitive data handling instructions, no explicit user confirmation step.
The skill provides detailed task structure templates and checklists, self-consistency is good, happy path is clear. However, static review cannot execute verification; and error handling on abnormal inputs is not described, e.g., ambiguous codebase or tool call failures. Deduction: no executable verification, incomplete error handling description.
The skill clearly defines use cases (multi-step features, complex requirements, delegation to subagents) and when not to use (simple features, self-implementation), target users are clear (skilled developers unfamiliar with the domain). However, lacks explicit non-fit boundaries, no Chinese version, which may affect trigger precision and usability for Chinese users; also no mention of connectivity to mainland networks. Deduction: incomplete boundary description, lack of multilingual support.
The skill is well-structured with clear title, task structure, common mistakes, and process steps; version, author, and license are clear; provides checklists and maintenance guidance. However, lacks installation notes, known limitations, update path, and changelog. Deduction: missing these maintainability elements.
The skill provides clear steps and templates, can generate well-structured implementation plans, fulfilling core objective. However, static review cannot verify output directly usable, and no actual examples or comparative benefit evidence provided. Deduction: no verifiable output examples, not reaching directly usable standard.
The skill claims adaptation from open-source project, but no verifiable tests or third-party execution evidence provided. Only static review, cannot independently verify effectiveness. Deduction: no test evidence and independent verification.
- The skill is purely documentation-based, no sensitive data handling, but no user confirmation prompt, users should be aware of authorization.
- Although claimed based on TDD and best practices, no verification examples are provided, check plan reasonableness before execution.
- Skill available only in English, Chinese users may need translation, trigger accuracy may be affected.
- Skill assumes user familiarity with git and environment; if external service dependencies are needed, network restrictions may apply.
What does this skill do, and when should you use it?
The writing-plans skill from the DojoAgents repository focuses on crafting high-quality implementation plans. It guides developers to decompose features into tasks of 2-5 minutes, each with precise file paths, complete copy-pasteable code, exact commands with expected output, and verification steps, while adhering to DRY, YAGNI, and TDD principles. Adapted from obra/superpowers, it targets skilled developers who lack context and aims to make implementation obvious. It is ideal for subagent-driven development and ensures plans are actionable without guesswork.
This skill directs the user to write a structured implementation plan: analyze requirements, explore the codebase (using search/read tools), design the approach, create an ordered list of bite-sized tasks, provide exact file paths and complete code for each, include precise test and commit commands, review the plan against a checklist, and save it to docs/plans/ with a commit. It emphasizes thoroughness to eliminate ambiguity and supports execution via subagents.
- A developer preparing to implement a multi-step feature needs a detailed blueprint.
- A tech lead breaking down a complex requirement into tasks assignable to subagents.
- A solo developer documenting their work for future reference, ensuring maintainability.
- A project manager providing team members with precise file paths and verification steps.
- Avoiding mistakes when a feature seems simple but assumptions are risky.
What are this skill's strengths and limitations?
- Promotes bite-sized tasks (2-5 min) to reduce cognitive overload.
- Demands exact file paths and complete code, eliminating guesswork.
- Enforces TDD, DRY, YAGNI, and frequent commits for quality.
- Provides a clear template that is easy to reuse across projects.
- Works well with subagent-driven development, increasing automation efficiency.
- Writing exhaustive plans is time-consuming; overkill for very simple tasks.
- Assumes user has codebase exploration skills; specific tools are not bundled.
- Examples use Python/pytest/git, which may not translate to other stacks.
- Since it's part of a monorepo, isolating the skill may require extra steps not documented.
How do you install this skill?
The skill resides in the DojoAgents repository under dojoagents/skills/built_in/writing-plans/SKILL.md. As a monorepo, you need to clone or download the whole repository, then copy the writing-plans skill folder into your Agent Skills client's skill directory (e.g., Claude Code). Exact installation steps for standalone usage are not documented, but standard Agent Skills installation (placing the folder with SKILL.md in the skills path) applies.
How do you use this skill?
In an Agent Skills-compatible client like Claude Code, invoke the skill and request an implementation plan for a feature. Example trigger prompt: "Use writing-plans skill to write an implementation plan for [feature]." The skill will guide you to produce a Markdown file with header, tasks, file paths, code, commands, and verification steps. For execution, it recommends using subagent-driven-development to dispatch each task.