code-flow-tracer_skill

Overview

This skill traces code execution paths and data flow to help you understand how features and functions work end-to-end. It produces call graphs, boundary annotations, and highlights entry points, recursion, and cycles so you can see where data comes from and what triggers each action. Use it to quickly map implementations across a codebase and resolve questions about flow and dependencies.

How this skill works

You provide a natural language target—feature name, function, error path, or a data symbol—and the skill runs an automated flow analysis command against the code index. The output includes an ASCII call tree, boundary markers (API, DB, LIB, CLOUD), recursion/cycle detection, and identified entry points. Multiple analysis modes let you focus on callers, callees, data origins, or full end-to-end paths.

When to use it

• You want an end-to-end walkthrough of a feature (e.g., login, checkout).
• You need to know what runs when an event triggers (e.g., button click, webhook).
• You need to trace where a piece of data originates and how it propagates.
• You need to find who calls a specific function or what a function calls.
• You’re debugging an error path and need to map possible execution routes.

Best practices

• Start with concise natural language queries like "user login" or "who calls validateToken".
• Include specific identifiers (function names, variable names, endpoints) for precise results.
• Iterate: run callers-first then switch to callees or data-origin modes to refine the map.
• Review boundary markers to separate application logic from external systems (DB, API, cloud).
• Use the recursion and cycle detection output to spot infinite-loop risks or unexpected dependencies.

Example use cases

• Trace the login flow to find where credentials are validated and where tokens are issued.
• Map the checkout process to identify payment gateway boundaries and persistence steps.
• Find the origin of a userProfile object and every transformation applied before rendering.
• Determine what calls handleSubmit and whether it reaches the database layer.
• Analyze error handling paths to see which components can receive and surface specific failures.