Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act. Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.

AI Mistake Prevention — Failure modes to avoid on every task:

• Check downstream references before deleting. Deleting components causes documentation and code staleness cascades. Map all referencing files before removal.
• Verify AI-generated content against actual code. AI hallucinates APIs, class names, and method signatures. Always grep to confirm existence before documenting or referencing.
• Trace full dependency chain after edits. Changing a definition misses downstream variables and consumers derived from it. Always trace the full chain.
• Trace ALL code paths when verifying correctness. Confirming code exists is not confirming it executes. Always trace early exits, error branches, and conditional skips — not just happy path.
• When debugging, ask "whose responsibility?" before fixing. Trace whether bug is in caller (wrong data) or callee (wrong handling). Fix at responsible layer — never patch symptom site.
• Assume existing values are intentional — ask WHY before changing. Before changing any constant, limit, flag, or pattern: read comments, check git blame, examine surrounding code.
• Verify ALL affected outputs, not just the first. Changes touching multiple stacks require verifying EVERY output. One green check is not all green checks.
• Holistic-first debugging — resist nearest-attention trap. When investigating any failure, list EVERY precondition first (config, env vars, DB names, endpoints, DI registrations, data preconditions), then verify each against evidence before forming any code-layer hypothesis.
• Surgical changes — apply the diff test. Bug fix: every changed line must trace directly to the bug. Don't restyle or improve adjacent code. Enhancement task: implement improvements AND announce them explicitly.
• Surface ambiguity before coding — don't pick silently. If request has multiple interpretations, present each with effort estimate and ask. Never assume all-records, file-based, or more complex path.

Graph Trace — Full System Flow

Trace connections from a target node through multiple edge types using BFS. Shows the complete chain: API endpoints → commands → entity events → bus messages → cross-service consumers.

When to Use

• "What happens when X is called/created/updated?" →

  --direction downstream

• "What calls/triggers X?" →

  --direction upstream

• "Show me the full flow through X" →

  --direction both

  (best when entry point is a middle file like a controller or command handler)
• Impact analysis — understand what's affected by a code change
• Cross-service tracing — follow MESSAGE_BUS edges to see which services consume events

Prerequisites

Graph must exist (

.code-graph/graph.db

/graph-build

Workflow

Step 1: Identify the target

If the user specifies a file path, use it directly. If the query is semantic:

1. Grep first to find entry point files related to the user's query
2. Use the discovered file as the trace target

Step 2: Choose direction

downstream

upstream

both

Step 3: Run trace

# Downstream trace (default) — what does this trigger?
python .claude/scripts/code_graph trace <target> --json

# Upstream trace — what calls/triggers this?
python .claude/scripts/code_graph trace <target> --direction upstream --json

# Bidirectional — full flow through this point
python .claude/scripts/code_graph trace <target> --direction both --json

# Custom depth (default: 3)
python .claude/scripts/code_graph trace <target> --direction both --depth 5 --json

# Filter to specific edge types
python .claude/scripts/code_graph trace <target> --edge-kinds CALLS,MESSAGE_BUS --json

Step 4: Present results

The trace returns a multi-level BFS tree:

{
  "status": "ok",
  "direction": "both",
  "levels": [
    { "depth": 0, "nodes": [...], "edges": [] },
    { "depth": 1, "nodes": [...], "edges": [{ "kind": "CALLS", ... }] },
    { "depth": 2, "nodes": [...], "edges": [{ "kind": "MESSAGE_BUS", ... }] }
  ]
}

Present results grouped by depth level. Highlight cross-service MESSAGE_BUS edges — these show the flow spreading to other microservices.

Step 5: Handle ambiguous targets

If trace returns

status: "ambiguous"

search

python .claude/scripts/code_graph search <keyword> --kind Function --json

Then retry with the full qualified name.

Edge Types Traced

CALLS

TRIGGERS_EVENT

PRODUCES_EVENT

MESSAGE_BUS

TRIGGERS_COMMAND_EVENT

API_ENDPOINT

CLI Reference

trace <target> [--direction downstream|upstream|both] [--depth N] [--edge-kinds KIND1,KIND2] [--node-mode file|function|class|all] [--json]

--direction

downstream

--depth

3

--edge-kinds

--node-mode

all

file

function

class

all

--json

Examples

# What happens when a user is created? (trace from command handler downstream)
python .claude/scripts/code_graph trace src/Services/Accounts/Commands/CreateUser/CreateUserCommandHandler.cs --json

# What calls this API controller? (trace upstream to find frontend callers)
python .claude/scripts/code_graph trace src/Services/Growth/Controllers/GoalController.cs --direction upstream --json

# Full flow through an entity event handler (upstream triggers + downstream consumers)
python .claude/scripts/code_graph trace src/Services/Employee/UseCaseEvents/EmployeeCreatedEventHandler.cs --direction both --json

# File-level overview (10-30x less noise — great first pass before drilling into functions)
python .claude/scripts/code_graph trace src/Services/Growth/Controllers/GoalController.cs --direction both --node-mode file --json

Anti-Patterns

• Don't trace without

  --json

  — structured output is needed for parsing
• Don't trace with depth > 5 — results get noisy; use edge-kinds filter instead
• Don't skip grep-first — if you don't know the file path, grep for it first
• Don't use for single-hop queries — use

  callers_of

  or

  importers_of

  instead (faster)

Related Skills

• /graph-query

  — Individual query patterns (callers_of, importers_of, etc.)

• /graph-blast-radius

  — Change-driven impact analysis from git diff

• /graph-build

  — Build or rebuild the graph

• /graph-connect-api

  — Frontend-to-backend API endpoint matching

Closing Reminders

• MANDATORY IMPORTANT MUST ATTENTION break work into small todo tasks using

  TaskCreate

  BEFORE starting
• MANDATORY IMPORTANT MUST ATTENTION search codebase for 3+ similar patterns before creating new code
• MANDATORY IMPORTANT MUST ATTENTION cite

  file:line

  evidence for every claim (confidence >80% to act)
• MANDATORY IMPORTANT MUST ATTENTION add a final review todo task to verify work quality <!-- SYNC:critical-thinking-mindset:reminder -->
• MUST ATTENTION apply critical thinking — every claim needs traced proof, confidence >80% to act. Anti-hallucination: never present guess as fact. <!-- /SYNC:critical-thinking-mindset:reminder --> <!-- SYNC:ai-mistake-prevention:reminder -->
• MUST ATTENTION apply AI mistake prevention — holistic-first debugging, fix at responsible layer, surface ambiguity before coding, re-read files after compaction. <!-- /SYNC:ai-mistake-prevention:reminder -->