dld-implement

Implements proposed software decisions by modifying code and adding @decision annotations.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the process of translating proposed decisions into tangible code changes, ensuring that the reasoning behind software development is directly linked to the implementation.

Core Features & Use Cases

  • Code Modification: Applies changes to the codebase based on decision records.
  • Annotation Insertion: Adds @decision annotations to relevant code sections.
  • Decision Status Update: Transitions decisions from 'proposed' to 'accepted' status.
  • Use Case: After a /dld-plan session generates a proposed decision DL-007 to optimize a database query, running /dld-implement DL-007 will modify the query in the code, add the @decision(DL-007) annotation, and mark the decision as accepted.

Quick Start

Use the dld-implement skill to implement the proposed decision DL-005.

Frequently Asked Questions about dld-implement

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

FAQPage Schema
How do I implement proposed development decisions and update code with annotations?

To implement proposed development decisions and update code, you can use an automated approach that parses decision records, applies code changes, inserts `@decision` annotations, and transitions the decision status to accepted.

What is the best way to link documented reasoning directly into a codebase for AI agent understanding?

Linking documented reasoning into a codebase involves inserting `@decision` annotations into relevant code sections, ensuring the reasoning behind software development is directly connected to the implementation for enhanced maintainability.

Can I automatically transition a proposed decision record to an accepted status after applying code changes?

Yes, you can transition a proposed decision record to an accepted status by running an implementation process that modifies the code according to the decision and subsequently updates the decision status.

How does code annotation for decision implementation work with version control?

Code annotation for decision implementation works by parsing decision records and adding `@decision` tags to relevant code sections, integrating documented reasoning into the codebase while adhering to project practices and version control.

Do I need a proposed decision record before I can modify code and add decision annotations?

Yes, you need a proposed decision record generated from a planning session, as the implementation process requires parsing the decision record to apply the corresponding code changes and insert the correct annotations.

Why does my decision implementation process require verifying annotation presence in the codebase?

Verifying annotation presence is required to ensure that the documented reasoning has been successfully integrated into the codebase, confirming that the code modifications include the necessary `@decision` tags for maintainability.