create-spec

Convert planning conversations into structured spec files with atomic tasks.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/arka6fx/pixify --skill create-spec-arka6fx
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: create-spec
Source: https://github.com/arka6fx/pixify/tree/main/.agents/skills/create-spec
Command: npx skills add https://github.com/arka6fx/pixify --skill create-spec-arka6fx

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Planning conversations often become disorganized and difficult to translate into concrete, runnable work. This skill converts conversations into a structured feature specification with self-contained task files organized into parallel execution waves, making handoffs and implementation scalable.

Core Features & Use Cases

  • Decompose a feature into atomic, self-contained tasks that can be implemented independently.
  • Organize tasks into waves to enable safe parallel work and avoid file conflicts.
  • Produce a specs/{feature}/ folder with a README, requirements, action-required, and tasks/, all fully self-contained for automation.

Quick Start

Create a spec by describing a feature and let the skill generate a complete specs/{feature}/ folder structure ready for implementation.

Frequently Asked Questions about create-spec

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

FAQPage Schema
How do I decompose a feature plan into parallel tasks for multiple agents?

To decompose a feature plan into parallel tasks, you transform planning conversations into a structured set of self-contained task files organized into safe execution waves. This prevents file conflicts and enables multiple agents to implement work independently.

How do I structure feature specifications to avoid implementation conflicts?

You structure feature specifications by generating a specs/{feature}/ folder containing a README, requirements, action-required, and tasks/ directory. Tasks are organized into sequential waves to ensure safe parallel execution without overlapping file modifications.

What is wave-based task decomposition in software planning?

Wave-based task decomposition is a planning mechanism that breaks a feature into atomic, self-contained work items organized into sequential execution waves. This structure allows multiple agents to implement tasks in parallel within a wave while safely managing cross-wave dependencies.

Can I generate a full specs directory structure directly from a feature planning conversation?

Yes, you can generate a complete specs directory structure directly from a feature planning conversation. The process captures requirements and outputs a fully self-contained folder structure with detailed implementation instructions ready for automated execution.

Do I need any specific frameworks to organize atomic work items into execution waves?

No specific frameworks are required to organize atomic work items into execution waves. The process relies entirely on transforming your existing planning conversations into structured markdown files without any external dependencies.

When should I not use parallel execution waves for task decomposition?

You should avoid using parallel execution waves for task decomposition when feature requirements are ambiguous or when tasks cannot be isolated into atomic, self-contained work items without creating heavy cross-dependencies that would cause file conflicts during implementation.