Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Git History Analyzer

    1

    Extract engineering metrics, bus factor risks, and code hotspots from git history.

    $1.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Git History Analyzer

    Git History Analyzer

    Example session with this skill installed

    Run a git history analysis for the last 6 months on the src/ directory and identify hotspots and bus factor risks.

    • Read your context and instructions
    • Compiled the git history analyzer
    • Generated the data export

    I have analyzed the git history for src/ over the past 6 months. The analysis processed 452 commits from 8 authors, identifying 3 high-risk hotspots and 2 files with a bus factor of 1.

    Repository Health Report (src/)

    MetricValueRisk Level
    Top Hotspotsrc/auth/provider.tsHigh (42 changes)
    Highest Churnsrc/api/endpoints.tsMedium (+1,200 / -850)
    Bus Factor (Total)3Medium
    Temporal Couplingsrc/utils/db.ts & src/models/user.ts85% correlation

    Key Findings

    Knowledge Silo: src/auth/provider.ts is 92% owned by dev-alpha. If this contributor is unavailable, the authentication logic has zero redundancy.

    Architectural Debt: src/utils/db.ts and src/models/user.ts are coupled. 17 out of 20 commits to the utility file required a simultaneous change to the user model, suggesting a leaky abstraction.

    Bug Hotspot: src/api/endpoints.ts shows high churn with a fix-to-feature commit ratio of 0.6, indicating frequent regressions.

    Next steps

    • Review the insights/bus_factor.csv for a full list of single-owner files.
    • Consider a pair-programming session for src/auth/ to distribute knowledge.
    • Refactor src/utils/db.ts to decouple it from the user model.

    bus_factor.csv

    CSV · data export

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Engineering managers and leads often struggle to identify technical debt and bus factor risk until a developer leaves or a deployment fails. This skill mines git logs to transform raw commit history into actionable repository health metrics.

    What it does

    • Hotspot detection identifies files with high change frequency that are likely candidates for refactoring.
    • Bus factor analysis calculates line ownership per file to surface single-point-of-failure risks.
    • Temporal coupling finds hidden dependencies by tracking files that are frequently committed together.
    • Churn tracking measures the ratio of lines added versus deleted to monitor codebase stability.
    • Author distribution maps knowledge silos across directories based on commit volume and recency.

    How it works

    1. Targeting specifies the time range or specific subdirectories to analyze within the local repository.
    2. Extraction runs the analysis engine to parse git logs, blame data, and commit metadata.
    3. Reporting generates a Markdown summary of hotspots, risks, and activity trends.
    4. Data Export produces CSV files for deeper analysis in external spreadsheet or visualization tools.

    Frameworks & tools

    This skill utilizes git CLI, python3, and standard shell utilities to process repository metadata.

    Why this beats prompting it yourself

    Standard LLM prompts cannot access the full history of a local repository or perform complex statistical aggregations on thousands of commits. This skill automates the heavy lifting of git log parsing and applies specific logic to calculate metrics like bus factor and temporal coupling accurately.

    Use cases

    • Auditing a legacy codebase to find the most bug-prone modules for refactoring.
    • Assessing team knowledge distribution before a major organizational change.
    • Identifying hidden architectural dependencies that cause regression errors.
    • Onboarding new developers by showing them which files are high-activity hotspots.

    Known limitations

    Requires a local git repository and Python 3. Accuracy of author metrics depends on consistent git mailmap configurations.

    Requires a local git repository and Python 3. Analysis accuracy depends on git mailmap consistency for author aliasing.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Terminal / Shell
    Read Files
    Listed1 month ago
    Updated1 month ago

    What's inside

    Frequently Asked Questions

    This skill analyzes local git logs and blame data to calculate engineering health metrics like bus factor, code hotspots, and temporal coupling that standard LLMs cannot access or process on their own.

    You will receive the complete skill package, including the git analysis engine, pre-configured reporting templates, and documentation for exporting metrics to CSV or Markdown formats.

    The skill requires a local Git repository, Python 3, and the Git CLI installed on the environment where your AI agent or runner is active.

    Yes, you can specify individual subdirectories or define specific time ranges (e.g., the last six months) to focus your analysis on specific project phases or legacy modules.

    The skill uses Git's internal metadata to track authorship; for the most accurate results in teams where members use multiple email addresses, we recommend having a standard .mailmap file in your repository.

    This skill is designed to work with any AI agent or platform that supports local tool execution and Python-based file processing.

    New in Code Quality & Review