writing-implementation-tasks

Generate atomic implementation task breakdowns with dependency ordering and verification steps.

Updated Mar 7, 2026
One-click install
npx skills add https://github.com/mazrean/agent-skills --skill writing-implementation-tasks
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-implementation-tasks
Source: https://github.com/mazrean/agent-skills/tree/main/skills/writing-implementation-tasks
Command: npx skills add https://github.com/mazrean/agent-skills --skill writing-implementation-tasks

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps break down complex features into a series of small, manageable, and independently verifiable implementation tasks, ensuring a clear and ordered path for development.

Core Features & Use Cases

  • Task Decomposition: Divides large features into atomic tasks suitable for single commits.
  • Dependency Management: Clearly defines and orders tasks based on their interdependencies.
  • Verification: Ensures each task has clear, executable verification steps.
  • Use Case: When starting a new feature, use this Skill to generate a tasks-{feature-name}.md file that outlines each step an agent needs to take, from data modeling to final integration testing, ensuring a logical and efficient implementation flow.

Quick Start

Use the writing-implementation-tasks skill to create a task breakdown for the new user authentication feature.

Frequently Asked Questions about writing-implementation-tasks

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I break down a software feature into actionable implementation tasks?

To break down a software feature into implementation tasks, decompose the work into atomic, single-commit units with clear dependency ordering and executable verification steps. This creates a structured markdown file outlining each step from data modeling to integration testing.

What is an implementation plan for spec-driven development?

An implementation plan for spec-driven development is a structured markdown task breakdown that divides features into independently verifiable tasks. It defines task dependencies, scope, and verification commands to ensure a logical and efficient development flow.

How do I define task dependencies and implementation order for a new feature?

Define task dependencies and implementation order by analyzing interdependencies between decomposed tasks. Generate a structured breakdown that sequences atomic tasks logically, ensuring each step has clear scope and executable verification commands before moving to the next.

Can I use this task breakdown approach for agile workflow decomposition?

Yes, you can use this task breakdown approach for agile workflow decomposition. It generates agent-optimized task lists with atomic scope and dependency ordering, fitting agile development by ensuring each task is independently verifiable and suitable for a single commit.

What format does the implementation task breakdown use?

The implementation task breakdown uses a structured markdown format with specific sections for progress tracking, task details, scope, and verification commands. It generates a tasks markdown file to guide the development flow.

When do I need to generate an implementation task breakdown?

You need to generate an implementation task breakdown when starting a new feature or when user mentions work decomposition, implementation plan, or spec-driven development. It helps manage complex features by creating a clear, ordered path of independently verifiable tasks.