skills.rest
Haaaiawd
HaaaiawdCOMMUNITY
Explore all skills by this author →
GitHub

git-forensics

Analyze Git commit history to detect temporal coupling and code hotspots.

142|24|Updated Jan 19, 2026
Search Tags:#code quality#git#architecture#code analysis#refactoring#coupling#hotspots
One-click install
npx skills add https://github.com/Haaaiawd/Antigravity-Workflow-System --skill git-forensics-haaaiawd
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: git-forensics
Source: https://github.com/Haaaiawd/Antigravity-Workflow-System/tree/main/.agent/skills/git-forensics
Command: npx skills add https://github.com/Haaaiawd/Antigravity-Workflow-System --skill git-forensics-haaaiawd

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill helps identify hidden architectural problems and areas of high development effort by analyzing Git history, revealing files that are frequently changed together (logical coupling) and modules that are complex and frequently modified (hotspots).

Core Features & Use Cases

  • Temporal Coupling Analysis: Detects files that are modified together in commits, even if they don't have direct code dependencies, highlighting potential architectural decay.
  • Hotspot Identification: Pinpoints complex code sections that are frequently changed, indicating areas prone to bugs and high maintenance cost.
  • Use Case: Before refactoring, use this Skill to understand which parts of the codebase are most intertwined and which modules are the most "painful" to work with, allowing for targeted improvements.

Quick Start

Run the git forensics skill to analyze code coupling for the repository.

Frequently Asked Questions about git-forensics

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

FAQPage Schema
How do I find temporal coupling between files in a Git repository?▼

Code hotspots are identified by analyzing Git history for modules with both high churn and high complexity. This pinpoints frequently modified, complex code sections that are prone to bugs and high maintenance costs.

What's the best way to prioritize refactoring efforts using Git history?▼

Prioritize refactoring by using Git history analysis to uncover intertwined code and high-churn modules. Targeting these painful areas ensures focused improvements where architectural decay and maintenance costs are highest.

Do I need Python and Git command-line tools to analyze code coupling?▼

Yes, you need Git command-line tools and Python scripts to execute the coupling analysis. The process relies on these scripts and the lizard dependency to calculate code complexity and parse commit history.

How does Git commit history reveal hidden architectural dependencies?▼

Git commit history reveals hidden architectural dependencies by tracking temporal coupling, which detects files modified together in commits. This exposes logical connections and architectural decay not visible in static code analysis.

Related Skills

Explore More Software Engineering Skills→
AVIDS2AVIDS2
618

memorix-git-memory

Search and inspect Git commit history to retrieve project memory.

Community
Intermediate
snqbsnqb
1

hotspot-detective

Identify high-churn files in Git repositories using churn and complexity signals.

Community
Intermediate
spacholski1225spacholski1225
2

Dependency Mapping

Analyze codebase dependencies to reveal coupling and refactoring risks.

Community
Advanced
santosomarsantosomar
1

component-boundary-identifier

Analyze dependency graphs to identify natural component boundaries in monolithic codebases.

Community
Advanced