Code history

Skill 2ykwang/agent-skills/skills/code-history

Trace the git history of specific code — when a function, pattern, or file was added, modified, or removed, and the intent behind each change. Use when the user asks when or why a piece of code changed, wants the evolution of a function, or needs the commit or PR that introduced a behavior. Read-only; not for plain git log or a single line's last author.From its SKILL.md

Install

npx -y skills add 2ykwang/agent-skills --skill code-history

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

17 stars17 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

4.9 KB, as published. Nobody here has run it

Code History

Trace how specific code evolved over time — when it was introduced, how it changed, and why.

Use this skill when

Understanding how a function or method evolved over time
Tracking when a specific code pattern was introduced or changed
Finding which commit/PR introduced, modified, or removed a piece of code
Investigating why code changed and what motivated each revision

Do not use this skill when

The user wants to modify code (this skill is read-only)
The user wants general git log without a specific target
The user only needs git blame for a single line's last author
The user only wants to see a specific commit's diff (git show is sufficient)

This skill is read-only. Never modify any files or run write commands.

Instructions

Tool Usage

Purpose	Tool	Command / Pattern
Search code pattern history	Bash	`git log -p --all -S '<pattern>'`
Trace function line history	Bash	`git log -L :'<func>':<file> --no-patch`
Trace file history	Bash	`git log --follow --oneline -- <path>`
Find pattern location	Grep	Search for pattern across codebase
Read file context	Read	Read surrounding code for understanding
Link commit to PR	Bash	`gh pr list --search '<sha>' --state all`

Step 1: Identify the Target

Parse $ARGUMENTS to determine what to trace:

Input type	Example	Detection
Code pattern	`user["type"] == "ADMIN"`	Contains operators, quotes, brackets
Function/method name	`ensure_valid_state`	Single identifier, no operators
File path	`src/auth/services.py`	Contains `/` or file extension
Ambiguous	Something else	Ask the user to clarify

If the input is a function name, locate the file it belongs to using Grep to search for the definition pattern.

Step 2: Collect History

First, measure the history size:

git log --oneline --all -S '<pattern>' | wc -l

Then choose the appropriate strategy:

If commits ≤ 30: read full history with git log -p --all -S '<pattern>'

If commits > 30: narrow scope with -- <file_path> or --since="1 year ago". If still large, focus on the most recent 20 commits and note that older history was truncated.

By target type:

Code patterns: git log -p --all -S '<pattern>'
Functions: supplement with git log -L :'<function_name>':<file_path> --no-patch --oneline
Files: git log --follow --oneline -- <file_path>

Step 3: Link to PRs

For each relevant commit, extract the PR reference:

From commit message: parse PR number if present (e.g., (#123), Merge pull request #123)
Via gh CLI (if available): gh pr list --search '<commit-sha>' --state all --json number,title,url --limit 1

If gh is not installed or fails, rely on commit message parsing only and note it.

Step 4: Analyze Changes

For each commit in the history, classify:

Dimension	Values
Change type	Added / Modified / Refactored / Moved / Deleted / Restored
Intent	Bug fix / Feature / Refactoring / Performance / Cleanup / Migration
Scope	Targeted (commit directly addresses this code) / Incidental (side effect of a larger change)

Determine intent from: commit message, PR title, and diff context. If intent is unclear, state that explicitly rather than guessing.

Step 5: Output

Timeline table:

## Change History: `<target>`

| # | Date | Author | Commit | PR | Change |
|---|------|--------|--------|----|--------|
| 1 | YYYY-MM-DD | name | `abcdef1` | #N title | Added — initial implementation |
| 2 | YYYY-MM-DD | name | `abcdef2` | #N title | Modified — added validation |
| 3 | YYYY-MM-DD | name | `abcdef3` | #N title | Refactored — extracted to util |

Detailed analysis (for each significant change):

Before/after diff summary
Change intent (based on commit message/PR)
Functional impact — what changed in behavior or interface

Insights (only when directly supported by evidence in the history):

Summarize the evolution arc (e.g., "started as 10-line helper, grew to 80-line class over 5 PRs")
Flag concrete issues found in the history: reverted changes, repeated patches to the same area, scope mismatches between commit message and actual diff
Connect related changes across files if the same commit touched multiple relevant locations