prompt-driven-development

Transform rough ideas into detailed design documents with implementation plans. Use when a user wants to develop an idea into a complete specification, create a design document from a concept, plan a feature implementation, or mentions "PDD", "prompt-driven development", "idea to design", "design doc from idea", or wants to systematically refine requirements before building. Guides through requirements clarification, research, detailed design, and implementation planning.

5 stars

Best use case

prompt-driven-development is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Transform rough ideas into detailed design documents with implementation plans. Use when a user wants to develop an idea into a complete specification, create a design document from a concept, plan a feature implementation, or mentions "PDD", "prompt-driven development", "idea to design", "design doc from idea", or wants to systematically refine requirements before building. Guides through requirements clarification, research, detailed design, and implementation planning.

Teams using prompt-driven-development should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/prompt-driven-development/SKILL.md --create-dirs "https://raw.githubusercontent.com/m31uk3/ai-skills/main/skills/prompt-driven-development/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/prompt-driven-development/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How prompt-driven-development Compares

Feature / Agentprompt-driven-developmentStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Transform rough ideas into detailed design documents with implementation plans. Use when a user wants to develop an idea into a complete specification, create a design document from a concept, plan a feature implementation, or mentions "PDD", "prompt-driven development", "idea to design", "design doc from idea", or wants to systematically refine requirements before building. Guides through requirements clarification, research, detailed design, and implementation planning.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

SKILL.md Source

# Prompt-Driven Development

Transform rough ideas into detailed designs with implementation plans through systematic requirements clarification, research, and iterative refinement.

## Parameters

- **rough_idea** (required): The initial concept to develop. Accept via:
  - Direct text input
  - File path to a local file
  - URL to a resource
- **project_dir** (optional, default: `.sop/planning`): Base directory for all project files

**Constraints:**
- Ask for all required parameters upfront in a single prompt
- Confirm successful acquisition before proceeding
- Never overwrite an existing project directory - ask for a new path if it exists

## Workflow

### Step 1: Create Project Structure

Create the directory structure:
```
{project_dir}/
├── rough-idea.md          # Original concept
├── idea-honing.md         # Requirements Q&A
├── research/              # Research findings
├── design/                # Design documents
│   └── detailed-design.md
├── implementation/        # Implementation plans
│   └── plan.md
└── summary.md             # Final summary
```

Prompt user to add files to context: `/context add {project_dir}/**/*.md`

### Step 2: Initial Process Planning

Ask user preference:
- Start with requirements clarification (default)
- Start with preliminary research
- Provide additional context first

Explain the process is iterative - they can move between steps as needed. Wait for explicit direction before proceeding.

### Step 3: Requirements Clarification

**Critical constraints:**
- Ask ONE question at a time, wait for response
- Never pre-populate answers or list multiple questions
- Follow this exact process per question:
  1. Formulate question
  2. Append to `idea-honing.md`
  3. Present to user
  4. Wait for complete response (may require dialogue)
  5. Record answer to `idea-honing.md`
  6. Formulate next question

Cover: edge cases, user experience, technical constraints, success criteria. Offer research when questions arise that need investigation.

See [references/templates.md](references/templates.md) for idea-honing format.

### Step 4: Research

1. Identify areas needing research
2. Propose research plan to user, ask for:
   - Additional topics
   - Specific resources to check
   - Areas where user has expertise
3. Document findings in `{project_dir}/research/` (one file per topic)
4. Include mermaid diagrams for architectures and data flows
5. Link to sources and references
6. Check in periodically with user on findings
7. Offer to return to requirements if new questions emerge

### Step 5: Iteration Checkpoint

Summarize current state and ask user:
- Proceed to detailed design?
- Return to requirements clarification?
- Conduct additional research?

Support iterating as many times as needed. Never proceed to design without explicit confirmation.

### Step 6: Create Detailed Design

Create `{project_dir}/design/detailed-design.md` with sections:
- Overview
- Detailed Requirements (consolidated from idea-honing)
- Architecture Overview (with mermaid diagrams)
- Components and Interfaces
- Data Models
- Error Handling
- Testing Strategy
- Appendices (Technology Choices, Research Findings, Alternatives)

See [references/templates.md](references/templates.md) for detailed design template.

Review with user and iterate. Offer to return to earlier steps if gaps emerge.

### Step 7: Develop Implementation Plan

Create `{project_dir}/implementation/plan.md`:
- Checklist at top for tracking progress
- Numbered steps, each with:
  - Clear objective
  - Implementation guidance
  - Test requirements
  - Integration with previous work
  - **Demo** - explicit description of demoable functionality

**Key principle:** Each step must result in working, demoable functionality. Prioritize test-driven development and early core functionality.

See [references/templates.md](references/templates.md) for implementation plan template.

### Step 8: Summarize Results

Create `{project_dir}/summary.md`:
- List all artifacts created
- Overview of design and implementation plan
- Suggested next steps
- Areas needing refinement

Present summary to user.

## Troubleshooting

**Requirements stall:** Suggest moving to different aspect, provide examples, summarize progress, or conduct research.

**Research limitations:** Document gaps, suggest alternatives, ask user for context, continue with available info.

**Design complexity:** Break into smaller components, focus on core first, suggest phased approach.

Related Skills

Skill Development

5
from m31uk3/ai-skills

This skill should be used when the user wants to "create a skill", "add a skill to plugin", "write a new skill", "improve skill description", "organize skill content", or needs guidance on skill structure, progressive disclosure, or skill development best practices for Claude Code plugins.

Hook Development

5
from m31uk3/ai-skills

This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.

Command Development

5
from m31uk3/ai-skills

This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.

Agent Development

5
from m31uk3/ai-skills

This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.

writing-eval-sloptastic

5
from m31uk3/ai-skills

Quantitative framework for detecting AI-generated "slop" in prose through systematic analysis of structural, lexical, rhetorical, and logical patterns. Use when analyzing text authenticity, evaluating writing quality, detecting AI-generated content, or assessing whether prose has characteristic AI patterns like excessive parallelism, abstraction laddering, chiasmus abuse, platitudes, tautologies, or rhetorical overengineering.

validated-knowledge-synthesis

5
from m31uk3/ai-skills

Transform raw, unorganized information into actionable knowledge through systematic validation. Use when users want to synthesize information from multiple sources (documents, URLs, transcripts, notes) into structured knowledge documents. Supports three document types - curated context (default, optimized for recall), guidance (implementation-focused narrative), and reference (quick lookup). Combines convergent synthesis with tension preservation to maintain productive contradictions. Triggers on requests like "synthesize this information", "create knowledge document from these sources", "transform these notes into actionable guidance", or "help me organize this research".

transcribing-youtube

5
from m31uk3/ai-skills

Download and transcribe YouTube videos into clean, deduplicated Markdown documents with chapter headings. Wraps yt-dlp to fetch subtitles (manual or auto-generated), removes the rolling-text triplication artifacts from auto-subs, inserts chapter markers from video metadata, and produces both a timestamped transcript and a prose-only version. Use when the user wants to: (1) transcribe a YouTube video, (2) get a transcript or subtitles from YouTube, (3) create an InfoNugget from a video, (4) extract text from a YouTube URL or video ID, or (5) mentions yt-dlp, YouTube transcript, or video subtitles.

synthesize-knowledge-graph

5
from m31uk3/ai-skills

Transform source materials into K-DAGs (Knowledge DAGs) — modular, curated domain knowledge structured as directed acyclic graphs with typed edges, mermaid visualization, and prose context. Use when users want to build knowledge graphs from documents, synthesize multiple sources into structured ontologies, intersect existing K-DAGs to discover emergent relationships, or create machine-readable knowledge structures that resist context rot. Triggers on: 'build a knowledge graph', 'create a K-DAG', 'intersect these knowledge sources', 'map the relationships between these documents', 'synthesize an ontology from these sources'.

skill-resiliency

5
from m31uk3/ai-skills

This skill should be used when the user asks to "add resiliency to a skill", "make this skill more robust", "improve error handling", "add validation mechanisms", "create self-correcting behavior", or discusses determinism, robustness, error correction, or homeostatic patterns in Agent Skills. Applies biological resiliency principles from Michael Levin's work to Agent Skill design.

codebase-summary

5
from m31uk3/ai-skills

Analyze a codebase and generate comprehensive documentation including architecture, components, interfaces, workflows, and dependencies. Creates an AI-optimized knowledge base (index.md) and can consolidate into AGENTS.md, README.md, or CONTRIBUTING.md. Use when the user wants to document a codebase, create AGENTS.md, understand system architecture, generate developer documentation, or asks to "summarize the codebase".

Plugin Structure

5
from m31uk3/ai-skills

This skill should be used when the user asks to "create a plugin", "scaffold a plugin", "understand plugin structure", "organize plugin components", "set up plugin.json", "use ${CLAUDE_PLUGIN_ROOT}", "add commands/agents/skills/hooks", "configure auto-discovery", or needs guidance on plugin directory layout, manifest configuration, component organization, file naming conventions, or Claude Code plugin architecture best practices.

Plugin Settings

5
from m31uk3/ai-skills

This skill should be used when the user asks about "plugin settings", "store plugin configuration", "user-configurable plugin", ".local.md files", "plugin state files", "read YAML frontmatter", "per-project plugin settings", or wants to make plugin behavior configurable. Documents the .claude/plugin-name.local.md pattern for storing plugin-specific configuration with YAML frontmatter and markdown content.