call-trace
Skill1 starsChanged 4 months agoMITView on GitHub
Trace the full call chain in both directions — callers (upstream) and callees (downstream) — around a target piece of code, reading whole method bodies for deep context. Use when asked to "get a full/complete understanding", to trace callers, assess blast radius, or understand how something is used before changing shared or foundational code, or when working through PR review feedback.
In this repository21 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- ai-commentsSkill
- ai-draftSkill
- ai-nextSkill
- ai-postSkill
- draft-prSkill
- dto-mappingSkill
- handoffSkill
- hum-commentsSkill
- jira-dcSkill
- meeting-summarySkill
- plan-from-issueSkill
- plan-nextSkill
- plan-reviewSkill
- plan-saveSkill
- pr-commentsSkill
- pr-statsSkill
- review-sessionSkill
- skill-builderSkill
- validator-generatorSkill
- templateSkill
The file
We split this skill into the rules it gives an agent
3 rules. About 0 are common, 3 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈3
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
- Distinctive: line 26
Before changing shared or foundational code where the impact isn't obvious.
- Distinctive: line 60
Stay inside the current repo by default: If a caller or callee lives in another service/package, note it by name and stop there.
- Distinctive: line 71
When the trace is done, summarize the chain in both directions (entry points → target → leaves) and call out the side effects you found.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 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.
Files
Call Trace: map the full call chain in both directions
You are gathering deep context around a target piece of code before it's changed or assessed — tracing every caller above it (upstream) and every callee below it (downstream). Your job is to build a complete picture of how the code is reached and what it touches, then stop. This is a context-gathering skill: you read and map, you do not edit.
The failure mode this skill exists to prevent is shallow tracing — reading a 20-line window around each call site and missing the side effects, early returns, and branches that live in the rest of the method. Read whole method bodies, always; partial windows produce confident-but-wrong analysis.
When to use this skill
- "Get a full / complete understanding" of how something works, or any close variant.
- Tracing callers, assessing blast radius, or understanding how a method is used.
- Before changing shared or foundational code where the impact isn't obvious.
- Working through PR review feedback — trace each review item independently.
When NOT to use this skill
- You only need a single definition or a quick lookup — just Read/Grep it; a full bidirectional trace is overkill.
- You're about to make a small, well-understood, local change — don't manufacture a trace for it.
- You need to edit code — this skill only gathers context; move to the change once the trace is done.
Upward trace (callers)
- Find callers.
Grepfor every call site of the target method/function across the repo. - Read whole bodies. For each caller,
Readthe entire containing method — signature to end. Never just a window around the call site. - Recurse upward. Identify what calls that method and repeat, building the chain toward the entry points.
- Stop at an entry point or dead end:
- A request/route handler — the app's inbound edge (HTTP, RPC, GraphQL resolver).
- A background or scheduled entry point (job runner, message/queue consumer, cron/timer task, worker loop).
- A CLI command, or the program's
main/startup entry point. - A test.
- A public API surface with no callers inside this repo.
- A method invoked only via dependency-injection/reflection/registration with no static callers — note it and stop.
Downward trace (callees)
- List callees. From the target, identify every non-trivial method/function it calls. Skip standard-library and noise calls (collection/string helpers, logging, simple getters).
- Read whole bodies.
Readthe full body of each callee. - Recurse downward into their callees until a dead end: the data-access/persistence layer, an external client (HTTP/SDK/queue publish), third-party or standard-library code, or a pure helper with no further branching.
Rules
What to do
- Read whole method bodies — always. Signature to end. The side effects and branches that matter are rarely next to the call site.
- Parallelize by depth. Issue all
Readcalls at the same depth in a single batched tool block; never serialize reads that don't depend on each other. - Stay inside the current repo by default. If a caller or callee lives in another service/package, note it by name and stop there. Cross a repo/service boundary only when the user explicitly asks.
What NOT to do
- NEVER read narrow windows around a call site — it is the cardinal sin here; it produces shallow analysis and missed side effects.
- Don't chase trivial callees (standard-library/collection helpers, logging) — they add noise, not understanding.
- Don't delegate to subagents by default. Agent summaries sacrifice the raw-code fidelity this skill exists to preserve. Fan out only when (a) the call graph is very wide and most branches are clearly irrelevant, or (b) the user opted into a cross-repo trace.
Format discipline
- Token usage and speed are not concerns here — accuracy and full context are the only priorities.
- When the trace is done, summarize the chain in both directions (entry points → target → leaves) and call out the side effects you found. Then stop — do not start editing.
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
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.

