gitnexus-impact-analysis

Maps blast radius of code changes using gitnexus_impact and gitnexus_detect_changes to report risk.

1|Updated Feb 18, 2026
One-click install
npx skills add https://github.com/s0lci700/OVERLAYS --skill gitnexus-impact-analysis-s0lci700
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: gitnexus-impact-analysis
Source: https://github.com/s0lci700/OVERLAYS/tree/main/.claude/skills/gitnexus/gitnexus-impact-analysis
Command: npx skills add https://github.com/s0lci700/OVERLAYS --skill gitnexus-impact-analysis-s0lci700

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This tool helps engineers understand what will break or be affected when they modify code by analyzing dependencies and downstream call paths.

Core Features & Use Cases

  • Blast-radius mapping: identify direct and indirect dependents and affected processes.
  • Pre-change risk assessment: predict potential failures before edits by mapping changes to execution flows.
  • Change-impact workflow: integrate with gitnexus_impact, read processes, and generate a risk report to guide reviews.

Quick Start

Run gitnexus_impact with a target and direction, then run gitnexus_detect_changes to map changes and generate a risk report.

Frequently Asked Questions about gitnexus-impact-analysis

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

FAQPage Schema
How do I assess code change impact and blast radius before modifying a module?

To assess code change impact and blast radius, you need to identify direct and indirect dependents within your repository. This process maps modifications to execution flows, predicting potential downstream failures before you edit.

What is blast radius mapping for code changes and when do I need it?

Blast radius mapping identifies direct and indirect dependents affected by code modifications. You need this pre-change risk assessment when evaluating a function, module, or dependency to prevent breaking downstream functionality.

How do I map dependencies to predict potential failures before editing a function?

You map dependencies to predict failures by analyzing downstream call paths and execution flows. This identifies what relies on your target function, generating a risk report to guide reviews before modifications.

Can I analyze downstream call paths and affected processes without external dependencies?

Yes, you can analyze downstream call paths and affected processes without external dependencies. The workflow reads processes directly from the repository to detect changes and report risk independently.

What is the best way to generate a risk report for reviewing code modifications?

The best way to generate a risk report is to map impact via a target and direction, then detect changes within the repository. This workflow produces a report guiding your pre-change reviews.

Why does modifying a dependency break downstream functionality in my repository?

Modifying a dependency breaks downstream functionality when indirect call paths rely on it. Analyzing the blast radius maps these execution flows, revealing what relies on the module to prevent unexpected failures.