dld-audit

Scan codebases for drift between documented decisions and code annotations.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill identifies discrepancies between documented decisions and the actual codebase, ensuring that code changes align with their intended reasoning and preventing technical debt.

Core Features & Use Cases

  • Drift Detection: Scans for annotations in code that point to non-existent or outdated decisions.
  • Reference Validation: Checks if decision records reference code that has been removed or significantly altered.
  • Use Case: After a series of code refactors, use this Skill to ensure all @decision annotations still correctly map to active, accepted decisions, and that decision records accurately reflect the current code state.

Quick Start

Run the dld-audit skill to scan for any drift between your code and its documented decisions.

Frequently Asked Questions about dld-audit

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

FAQPage Schema
How do I detect code drift from documented decisions in my codebase?

To detect code drift from documented decisions, you can scan your codebase for discrepancies between code annotations and decision records. This process identifies orphaned annotations, stale references, and undocumented changes by tracking modifications since the last audit.

What is decision logging drift and how does it cause technical debt?

Decision logging drift occurs when actual code changes no longer align with their intended documented reasoning. This discrepancy creates technical debt because developers may rely on outdated decision records or orphaned code annotations that fail to accurately reflect the current codebase state.

How do I validate code annotations against decision records after refactoring?

You validate code annotations against decision records by running an audit script that compares active annotations with existing records. This checks if decision records reference removed code and ensures all annotations correctly map to accepted decisions after a series of refactors.

Does dld-audit require git to scan for orphaned code annotations?

Yes, dld-audit requires git and shell scripting for execution to scan for orphaned code annotations. It relies on git to track modifications since the last audit and identify undocumented changes within your codebase.

How do I find stale references and undocumented changes in my codebase?

You find stale references and undocumented changes by running an audit that compares code annotations against decision records. This scan identifies discrepancies where decision records point to removed code or where recent code modifications lack proper decision documentation.

What's the best way to maintain decision records during continuous code refactoring?

The best way to maintain decision records during refactoring is to run regular drift detection audits. By scanning for orphaned annotations and validating references, you ensure your documented decisions consistently align with the actual codebase and prevent accumulated technical debt.