🎯

tldr-deep

🎯Skill

from parcadei/continuous-claude-v3

VibeIndex|
What it does

Generates a comprehensive 5-layer code analysis for a specific function, revealing its structure, call graph, control flow, data flow, and dependencies.

tldr-deep

Installation

Install skill:
npx skills add https://github.com/parcadei/continuous-claude-v3 --skill tldr-deep
9
Last UpdatedJan 26, 2026

Skill Details

SKILL.md

Full 5-layer analysis of a specific function. Use when debugging or deeply understanding code.

Overview

# TLDR Deep Analysis

Full 5-layer analysis of a specific function. Use when debugging or deeply understanding code.

Trigger

  • /tldr-deep
  • "analyze function X in detail"
  • "I need to deeply understand how Y works"
  • Debugging complex functions

Layers

| Layer | Purpose | Command |

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

| L1: AST | Structure | tldr extract |

| L2: Call Graph | Navigation | tldr context --depth 2 |

| L3: CFG | Complexity | tldr cfg |

| L4: DFG | Data flow | tldr dfg |

| L5: Slice | Dependencies | tldr slice |

Execution

Given a function name, run all layers:

```bash

# First find the file

tldr search "def " .

# Then run each layer

tldr extract # L1: Full file structure

tldr context --project . --depth 2 # L2: Call graph

tldr cfg # L3: Control flow

tldr dfg # L4: Data flow

tldr slice # L5: Slice

```

Output Format

```

Deep Analysis: {function_name}

L1: Structure (AST)

File: {file_path}

Signature: {signature}

Docstring: {docstring}

L2: Call Graph

Calls: {list of functions this calls}

Called by: {list of functions that call this}

L3: Control Flow (CFG)

Blocks: {N}

Cyclomatic Complexity: {M}

[Hot if M > 10]

Branches:

- if: line X

- for: line Y

- ...

L4: Data Flow (DFG)

Variables defined:

- {var1} @ line X

- {var2} @ line Y

Variables used:

- {var1} @ lines [A, B, C]

- {var2} @ lines [D, E]

L5: Program Slice (affecting line {target})

Lines in slice: {N}

Key dependencies:

- line X β†’ line Y (data)

- line A β†’ line B (control)

---

Total: ~{tokens} tokens (95% savings vs raw file)

```

When to Use

  1. Debugging - Need to understand all paths through a function
  2. Refactoring - Need to know what depends on what
  3. Code review - Analyzing complex functions
  4. Performance - Finding hot spots (high cyclomatic complexity)

Programmatic API

```python

from tldr.api import (

extract_file,

get_relevant_context,

get_cfg_context,

get_dfg_context,

get_slice

)

# All layers for one function

file_info = extract_file("src/processor.py")

context = get_relevant_context("src/", "process_data", depth=2)

cfg = get_cfg_context("src/processor.py", "process_data")

dfg = get_dfg_context("src/processor.py", "process_data")

slice_lines = get_slice("src/processor.py", "process_data", target_line=42)

```

More from this repository10

🎯
agentica-claude-proxy🎯Skill

Enables seamless integration between Agentica agents and Claude Code CLI by managing proxy configurations, tool permissions, and response formatting.

🎯
git-commits🎯Skill

Manages git commits by removing Claude attribution, generating reasoning documentation, and ensuring clean commit workflows.

🎯
debug-hooks🎯Skill

Systematically diagnose and resolve hook registration, execution, and output issues in Claude Code projects by checking cache, settings, files, and manual testing.

🎯
migrate🎯Skill

Systematically researches, analyzes, plans, implements, and reviews migrations across frameworks, languages, and infrastructure with minimal risk.

🎯
background-agent-pings🎯Skill

Enables background agent execution with system-triggered progress notifications, avoiding manual polling and context flooding.

🎯
agentica-infrastructure🎯Skill

Provides comprehensive reference and infrastructure for building sophisticated multi-agent coordination patterns and workflows with precise API specifications and tracking mechanisms.

🎯
system-overview🎯Skill

Generates a comprehensive summary of the current system's configuration, components, and key metrics across skills, agents, hooks, and other core systems.

🎯
cli-reference🎯Skill

Provides comprehensive CLI commands and flags for interacting with Claude Code, enabling headless mode, automation, and session management.

🎯
braintrust-tracing🎯Skill

Traces and correlates Claude Code session events across parent and sub-agent interactions using comprehensive Braintrust instrumentation.

🎯
morph-apply🎯Skill

Rapidly edits files using AI-powered Morph Apply API with high accuracy and speed, without requiring full file context.