context-map

Map dependencies and blast radius before modifying code or pipelines.

Updated Apr 8, 2026
One-click install
npx skills add https://github.com/yiwei79/azoth --skill context-map-yiwei79
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: context-map
Source: https://github.com/yiwei79/azoth/tree/main/.opencode/skills/context-map
Command: npx skills add https://github.com/yiwei79/azoth --skill context-map-yiwei79

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Map blast radius and dependency graphs before multi-file or cross-cutting work; assess risk and pre-stage dependencies at the start of a pipeline stage or unfamiliar area.

Core Features & Use Cases

  • Provides a structured approach to identifying direct targets, mapping upstream and downstream dependencies, and assessing blast radius to reduce risk when implementing changes.
  • Enables pre-change scoping and decision checkpoints, preventing cascading failures in codebases and pipelines.
  • Use Case: Before refactoring a module or renaming APIs across modules, generate a map of affected files and dependencies to guide planning.

Quick Start

Start context mapping at the beginning of a change to identify targets, dependencies, and blast radius before implementation.

Frequently Asked Questions about context-map

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

FAQPage Schema
What is a blast radius analysis for code changes and when do I need it?

Blast radius analysis identifies upstream and downstream dependencies before modifying code. You need it when entering unfamiliar codebases or starting pipeline stages to assess risk, guide scope decisions, and prevent cascading failures across modules.

How do I map dependencies before refactoring a module or renaming APIs?

To map dependencies before refactoring, identify direct targets and trace their upstream and downstream connections to generate a dependency graph. This formalizes blast radius assessment and establishes decision checkpoints for safe, well-scoped work.

Can I use dependency mapping for cross-cutting multi-file changes in pipelines?

Yes, you can apply dependency mapping at the start of a pipeline stage to pre-stage targets and assess cross-cutting blast radius. It formalizes risk assessment and scope decisions for multi-file changes to prevent cascading pipeline failures.

What's the best way to pre-map changes and tame risk in unfamiliar code?

The best way to tame risk is generating a structured context map that identifies targets, dependencies, and blast radius before implementation. This approach formalizes decision checkpoints and pre-stages dependencies for safe modifications.

Why does modifying code without a dependency graph cause cascading failures?

Modifying code without a dependency graph causes cascading failures because upstream and downstream dependencies remain unidentified. Pre-mapping blast radius and establishing decision checkpoints formalizes risk assessment to prevent unanticipated scope creep.

Should I assess blast radius before every code change or only for large refactors?

Assess blast radius before multi-file or cross-cutting work, such as renaming APIs across modules. While not required for every minor edit, applying dependency mapping at the start of pipeline stages or unfamiliar areas ensures safe, well-scoped work.