agentleFS
nielsmadannielsmadan/skills/skills/review-history/SKILL.md

review-history

Skill1 starsChanged 2 months agoMITView on GitHub

Analyze how code changed over time. Use when investigating regressions, understanding why code was written a certain way, or finding when a behavior changed.

The file

We split this skill into the rules it gives an agent

9 rules. About 0 are common, 8 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈8

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    If a file path is given, use it directly

    line 31
  2. Distinctive:

    If a feature/function name, locate relevant files using this strategy:

    line 32
  3. Distinctive:

    Run these in parallel:

    line 40
  4. Distinctive:

    If the initial window returns fewer than 3 commits, double the window and retry once

    line 70
  5. Distinctive:

    Check if this problem occurred before:

    line 74
  6. Distinctive:

    Search logs for relevant keywords:

    line 79
  7. Distinctive:

    Key Code Introduction: Use git log -S results to identify when the function/feature first appeared and its last substantive change (skip …

    line 92
  8. Very specific:

    Solution: Use git reflog to find the original commit before the squash or rebase.

    line 132
  9. Distinctive:

    If a past issue log matches, read it fully - it may contain the solution

    line 141

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md
<!-- Generated from https://github.com/nielsmadan/agentic-coding — edits here are overwritten. -->

Review History

Investigate how code evolved over time to understand current behavior or find regressions.

Usage

/review-history src/auth/login.ts
/review-history the authentication flow
/review-history UserProfile component

Gotchas

  • git log -S finds commits where the string was added OR removed. A commit that deleted a function surfaces as equally relevant to the one that added it — verify the direction of change.
  • Squash merges erase commit-level traceability. git reflog only works locally and expires — if another contributor squashed and force-pushed, the original commits are unrecoverable.

Workflow

Step 1: Identify Target Files

From the provided topic, identify the relevant files:

  • If a file path is given, use it directly
  • If a feature/function name, locate relevant files using this strategy:
    1. Grep for the exact function/class name to find where it is defined and used
    2. Glob for files with the feature name in the path (e.g., **/*payment*)
    3. Prioritize source files over test files; include tests only if investigating test behavior
    4. Limit to the 5 most relevant files to keep the analysis focused

Step 2: Git History Analysis

Run these in parallel:

Recent commits touching the area:

git log --oneline -20 -- <file_or_directory>

Detailed blame for key sections:

# For files > 200 lines: target the specific function or section under investigation.
# Use Grep to find the line range first, then:
git blame -L <start>,<end> <file>

# For files ≤ 200 lines: blame the entire file:
git blame <file>

Find when specific code was introduced:

git log -S "<search_term>" --oneline -- <file>

Check for recent refactors:

git log --oneline --since="3 months ago" -- <file_or_directory>

Adjust the time window based on context:

  • Investigating a recent regression: use --since="2 weeks ago"
  • Understanding a feature's evolution: use --since="6 months ago" or omit --since entirely
  • If the initial window returns fewer than 3 commits, double the window and retry once

Step 3: Search Past Issue Logs

Check if this problem occurred before:

  1. List past issue logs:
    • Glob pattern: docs/log/*.md
  2. Search logs for relevant keywords:
    • Grep pattern: {keywords} path: docs/log/

Look for:

  • Similar error messages
  • Same file/function names
  • Related symptoms

Step 4: Synthesize Findings

Populate the report using these methods:

  • Recent Changes: List commits from git log, most recent first. Include only commits that touch the target code.
  • Key Code Introduction: Use git log -S results to identify when the function/feature first appeared and its last substantive change (skip formatting-only commits).
  • Related Past Issues: Direct matches from Step 3. If none found, state "None found in docs/log/".
  • Regression Risk: Compare current behavior against commit history. If code worked before a specific commit and broke after, name that commit. If no clear regression point, state "No clear regression identified — behavior may be by design."

Report:

## History Analysis: {target}

### Recent Changes
| Date | Commit | Author | Summary |
|------|--------|--------|---------|
| {date} | {hash} | {author} | {message} |

### Key Code Introduction
- `{function/feature}` introduced in {commit} on {date}
- Last modified: {commit} by {author}

### Related Past Issues
{any matching docs/log entries, or "None found"}

### Regression Risk
{assessment: was this working before? when did it break?}

Examples

Trace when a payment bug was introduced:

/review-history processPayment

Uses git log -S and git blame to trace the payment processing function, identifies the commit that changed the rounding logic three weeks ago, and cross-references with past issue logs to confirm this is when the billing discrepancy started.

Understand why validation works a certain way:

/review-history src/validators/address.ts

Analyzes the git history of the address validator, surfaces the original commit that added the unusual postal code regex along with its commit message explaining a partner API requirement, and checks past issue logs for related context.

Troubleshooting

Relevant commit was squashed or rebased away

Solution: Use git reflog to find the original commit before the squash or rebase. If the reflog has expired, search for the change using git log -S "<code_snippet>" --all to locate it in any branch or dangling commit.

History is too large to analyze effectively

Solution: Narrow the scope by passing a specific file path or function name instead of a broad directory. Use --since with git log to limit the time window, or focus on a single author's contributions with --author.

Notes

  • Focus on commits from the last 3-6 months unless investigating older issues
  • Pay attention to refactors, dependency updates, and merge commits
  • If a past issue log matches, read it fully - it may contain the solution

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.