skills.rest
ntsk
ntskCOMMUNITY
Explore all skills by this author →
Website𝕏@ntsk__GitHub

decision-archaeology

Trace git blame, commits, PRs, and issues to explain code decisions.

3|2|Updated Nov 12, 2017
Search Tags:#read-only#commit-history#PR-traceability#code-rationale#git-blame#issue-trace
One-click install
npx skills add https://github.com/ntsk/dotfiles --skill decision-archaeology
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: decision-archaeology
Source: https://github.com/ntsk/dotfiles/tree/main/.claude/skills/decision-archaeology
Command: npx skills add https://github.com/ntsk/dotfiles --skill decision-archaeology

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you investigate why code was written a certain way by tracing decision history through git blame, commit logs, PRs, and issues to understand the reasoning behind code changes.

Core Features & Use Cases

  • Identify code and target lines: Locate the exact portion of code to understand context.
  • Trace introducing commits: Use git blame to find the commit that introduced changes.
  • Link PRs and issues: Check commit messages for references to PRs or issues to uncover discussions.
  • Summarize rationale: Produce a concise rationale of why a change was made.

Quick Start

Provide the target file path and, optionally, a line range to analyze. The Skill will generate a decision-archaeology report outlining the who, when, why of the change.

Frequently Asked Questions about decision-archaeology

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

FAQPage Schema
How do I trace why a specific line of code was written?▼

Use git blame to identify the commit that introduced the line, then check the commit message and linked PR or issue for the decision rationale. Decision archaeology traces through commit history, PRs, and issues to uncover the reasoning behind code changes and document the full context.

Can I understand code decisions across multiple commits and PRs?▼

Yes. Decision archaeology traces decision history through git blame, commit logs, PRs, and issues to connect related changes. It outputs a standardized report detailing the timeline, decision rationale, and key references across your repository.

What information does a decision archaeology report include?▼

A decision archaeology report details the target file and lines, timeline of changes, decision rationale explaining why the code was written that way, and key references including commit messages, PR discussions, and linked issues that provide context.

How do I start analyzing code rationale for a specific file?▼

Provide the target file path and optionally a line range. The Skill generates a decision archaeology report showing who made the change, when it was introduced, why it was made by tracing commits and linked discussions, and relevant references.

Does this work for understanding decisions in maintenance scenarios?▼

Yes. Decision archaeology is designed for maintenance and investigation scenarios where you need to understand the historical context behind existing code. It traces decision history across repositories to explain why code was written a certain way.

Related Skills

Explore More Software Engineering Skills→
proto-at-blockproto-at-block
219

git-commit

Create signed, atomic git commits with comprehensive messages.

Official
Advanced
dralgorhythmdralgorhythm
111

context-management

Capture decisions, ADRs, and documentation for structured project handoffs.

Community
Basic
danievanzyldanievanzyl
1

ralph-commit

Create structured git commits with decisions, files, and blockers.

Community
Intermediate
iDako7iDako7

architecture-decision-records

Capture architectural decisions as structured ADR documents during coding and design sessions.

Community
Intermediate