Call Chain Skill for Claude

Traces execution paths through the code graph with criticality scoring and Mermaid charts. Use when understanding how a function propagates through the system.

818 tokens

context cost

the whole folder, loaded on every use

files

instructions only

copies elsewhere

how many repositories repackaged it

324

stars on the repo

on the repository, not the skill itself

Install

one command, takes just this skill from the repository

npx skills add https://github.com/athola/claude-night-market --skill call-chain

The instruction itself

6 sections, as written by the author

Call Chain Tracing

Trace execution flows through the codebase using the

code knowledge graph.

When NOT To Use

Static import relationships (use cartograph:dependency-graph)
Scoring the risk of a change (use pensive:blast-radius)

Prerequisites

This skill requires the gauntlet plugin for graph

data. Discover it:

GRAPH_QUERY=$(find ~/.claude/plugins -name "graph_query.py" -path "*/gauntlet/*" 2>/dev/null | head -1)

If gauntlet is not installed: Fall back to static

analysis. Use grep to trace function calls and build

a Mermaid diagram manually from import/call patterns.

Skip graph-specific steps.

If installed but no graph.db: Tell the user to run

/gauntlet-graph build.

Steps

Accept target: Get a function name or entry point

from the user (or trace all entry points).

Run flow tracing (requires gauntlet):

   python3 "$GRAPH_QUERY" --action flows --depth 15

To filter by entry point:

   python3 "$GRAPH_QUERY" --action flows --entry "main"

Fallback (no gauntlet): Trace calls with rg (or grep):

   # Prefer rg (ripgrep) for speed; fall back to grep
   if command -v rg &>/dev/null; then
     rg -n "function_name\(" --type py . | head -20
   else
     grep -rn "function_name(" --include="*.py" . | head -20
   fi

Build the call tree manually from search results.

Display as indented tree:

   main() [criticality: 0.72]
     -> validate_input()
       -> parse_config()
     -> process_data()
       -> db.execute_query()
       -> cache.store()
     -> send_response()

Generate Mermaid flowchart:

   flowchart LR
     main --> validate_input
     main --> process_data
     main --> send_response
     validate_input --> parse_config
     process_data --> db.execute_query
     process_data --> cache.store

Show criticality breakdown:
File spread: how many files the flow touches
Security sensitivity: auth/crypto code in the path
Test coverage gaps: untested nodes in the flow

Criticality Scoring

| Factor | Weight | Meaning |

|--------|--------|---------|

| File spread | 0.30 | Touches many files |

| Security | 0.25 | Contains auth/crypto code |

| External calls | 0.20 | Unresolved dependencies |

| Test gap | 0.15 | Untested nodes in flow |

| Depth | 0.10 | Deep call chains |

Exit Criteria

[ ] Indented call tree displayed for the target function with

criticality scores in the form [criticality: N.NN]

[ ] Mermaid flowchart LR generated with edges representing

each caller-to-callee relationship in the traced path

[ ] Criticality breakdown table shown covering: file spread,

security sensitivity, external calls, test gap, and depth

[ ] If gauntlet is not installed, fallback to static rg/grep

analysis is used and the absence of graph data is noted

[ ] If gauntlet is installed but graph.db is absent, user is

told to run /gauntlet-graph build before the skill halts

Other skills for the same job

different authors, same section of the catalogue

MCP Builder

by anthropics

vendor ×13

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

Automatically creates user-facing changelogs from git commits by analyzing commit history, categorizing changes, and transforming technical commits into clear, customer-friendly release notes. Turns hours of manual changelog writing into minutes of automated generation.

774 tokens

Finishing A Development Branch

by ZhanlinCui

×7

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

Vercel React Native Skills

by vercel-labs

vendor ×6

React Native and Expo best practices for building performant mobile apps. Use when building React Native components, optimizing list performance, implementing animations, or working with native modules. Triggers on tasks involving React Native, Expo, mobile performance, or native platform APIs.

39k tokens

Vercel React Best Practices

by ratacat

×5

React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.

Next.js best practices - file conventions, RSC boundaries, data patterns, async APIs, metadata, error handling, route handlers, image/font optimization, bundling

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

1k tokens

How to use it

Copy the folder

Take athola/call-chain from the repository into ~/.claude/skills for personal use, or into .claude/skills inside a project.

Check the name does not clash

The agent identifies a skill by the name field in its header. Two skills with the same name cannot sit side by side — one of them will be ignored.