dld-plan

Break down software features into discrete, loggable decision records.

4|Updated Mar 7, 2026
One-click install
npx skills add https://github.com/jimutt/dld-kit --skill dld-plan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dld-plan
Source: https://github.com/jimutt/dld-kit/tree/main/.claude/skills/dld-plan
Command: npx skills add https://github.com/jimutt/dld-kit --skill dld-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill helps developers break down large features into smaller, manageable, and well-defined decisions, ensuring that the reasoning behind each part of the code is logged and accessible.

Core Features & Use Cases

  • Interactive Planning: Guides the user through defining discrete decisions for a feature.
  • Decision Grouping: Assigns a shared tag to group related decisions for easy reference.
  • Record Creation: Generates individual Markdown files for each decision with appropriate frontmatter and body.
  • Use Case: When planning a new complex feature, use /dld-plan to systematically define each architectural choice, API interaction, or data structure modification before implementation.

Quick Start

Use the dld-plan skill to break down the feature 'Implement user authentication'.

Frequently Asked Questions about dld-plan

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

FAQPage Schema
How do I break down complex software features into discrete decisions for documentation?

To break down software features into discrete decisions, use interactive planning to define architectural choices and generate structured Markdown records with unique IDs, titles, and metadata grouped by shared tags.

What is the best way to log the reasoning behind architectural choices before implementation?

Logging reasoning involves creating structured decision records that capture metadata and rationale for each architectural choice, ensuring the logic behind your code remains accessible and well-documented.

How do I generate structured decision records with unique IDs and metadata?

Generating structured decision records requires shell scripts to handle ID generation, create individual Markdown files with appropriate frontmatter and body content, and regenerate the index for comprehensive documentation.

Does this decision logging approach require any specific dependencies or environments?

Yes, this decision logging approach requires shell scripts to facilitate ID generation, record creation, and index regeneration within your local software development environment.

When should I use interactive planning for feature breakdown in software development?

Use interactive planning for feature breakdown when planning a new complex feature and needing to systematically define each architectural choice, API interaction, or data structure modification before implementation.