agentleFS
neeraj181-dotneeraj181-dot/ClaudeSkills/.claude/skills/change-cartographer/SKILL.md

change-cartographer

Skill0 starsChanged 3 months agoApache-2.0View on GitHub

Map the full impact of a proposed code change before modifying anything — identify all files, components, routes, APIs, state, database objects, tests, and configurations that could be affected. Classifies affected areas as DIRECT, INDIRECT, POTENTIAL, or UNRELATED. Produces a visual impact map. Use when the user is about to make a change and wants to understand "what else could this break?" before proceeding.

The file

We split this skill into the rules it gives an agent

2 rules. About 0 are common, 2 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Ask for specifics if the request is vague.

    line 40
  2. Distinctive:

    Test files for the modified code.

    line 49

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 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

Change Cartographer

Creator: Neeraj Project: ClaudeSkills

Map the full blast radius of a proposed change before modifying a single file.

Core principle: every change has ripple effects. The files you edit are rarely the only files affected. Imports, callers, tests, configuration, state, and downstream consumers all matter. Mapping the impact first prevents "fix one thing, break three others."

This skill is read-only. It produces an impact map. It does not make changes.


When to activate

Activate when:

  • The user proposes a change and wants to understand its scope.
  • The change touches a shared module, utility, type definition, or interface.
  • The user says "what else would this affect?" or "what could break?"
  • A refactoring, migration, or architectural change is being considered.
  • The user wants confidence before making a risky change.

Phase 1 — Understand the proposed change

Clarify exactly what the user wants to change:

  • Which file(s) will be modified?
  • What specific change is being made?
  • Is it a rename, deletion, interface change, behavior change, or addition?

Ask for specifics if the request is vague.

Phase 2 — Direct impact (Layer 0)

Identify files that will definitely need to change:

  • The file(s) being modified.
  • Files that directly import from the modified file.
  • Files that directly call functions/methods from the modified file.
  • Test files for the modified code.

For each, explain why it is directly affected.

Phase 3 — Indirect impact (Layer 1)

Identify files that depend on the directly affected files:

  • Files that import from Layer 0 files.
  • Files that call functions from Layer 0 files.
  • Components that render Layer 0 components.
  • Routes that use Layer 0 handlers.
  • Tests for Layer 0 code.

These may or may not need changes — but they are at risk.

Phase 4 — Potential impact (Layer 2)

Identify areas that might be affected:

  • Shared state that the changed code reads or writes.
  • Database queries generated by the changed code.
  • API responses shaped by the changed code.
  • Configuration that the changed code reads.
  • External services called by the changed code.
  • Cron jobs or background tasks that use the changed code.

These require investigation but may not need changes.

Phase 5 — Unrelated areas

Explicitly list major areas of the project that are NOT affected:

This is as important as listing affected areas — it prevents unnecessary caution in unrelated parts of the system.

Phase 6 — Build the impact map

Produce a visual dependency chain:

REQUESTED CHANGE
  ↓
[File A] — DIRECT (being modified)
  ↓
[Component B] — DIRECT (imports File A)
  ↓
[Route C] — INDIRECT (uses Component B)
  ↓
[API D] — POTENTIAL (Route C calls API D)
  ↓
[Database E] — POTENTIAL (API D queries Database E)

Phase 7 — Classify and summarize

For each affected area:

AreaFileClassificationReasonRisk
......DIRECT / INDIRECT / POTENTIAL / UNRELATED...High / Medium / Low

Provide a summary:

  • Total files affected: N
  • Direct: N files
  • Indirect: N files
  • Potential: N files
  • Unrelated: N areas confirmed safe

Phase 8 — Risk assessment

For the overall change:

  • Risk level: Low / Medium / High / Critical
  • Reason: why this risk level
  • Recommended precautions: what to watch for
  • Suggested testing: what to test after the change

What this skill does NOT do

  • Does not make changes (read-only).
  • Does not refactor code (that is refactor-engineer).
  • Does not enforce boundaries (that is safe-scope).
  • Does not audit the whole project (that is code-auditor).

This skill answers one question: "What else could this change break?"


Final output

# Impact Map
# Direct Impact
# Indirect Impact
# Potential Impact
# Unrelated Areas
# Risk Assessment
# Recommended Precautions

Guardrails: never modify files during mapping; distinguish confirmed impact from potential impact; explicitly confirm what is NOT affected; ground every finding in actual code inspection; do not guess at import chains — trace them; keep the map visual and easy to scan; and never claim an area is unrelated without verifying.

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.