TLDR Deep Analysis

Analyze code functions via AST, call graph, CFG, DFG, and program slicing.

8|1|Updated Jan 4, 2026
One-click install
npx skills add https://github.com/scooter-lacroix/Maestro --skill tldr-deep-analysis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: TLDR Deep Analysis
Source: https://github.com/scooter-lacroix/Maestro/tree/main/maestro/skills/analysis/tldr-deep
Command: npx skills add https://github.com/scooter-lacroix/Maestro --skill tldr-deep-analysis

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill provides a comprehensive, multi-layered analysis of individual functions within a codebase, enabling deep understanding and efficient debugging.

Core Features & Use Cases

  • Multi-Layered Analysis: Examines function structure (AST), call graphs, control flow (CFG), data flow (DFG), and program slices.
  • Debugging & Refactoring: Ideal for understanding complex logic, identifying dependencies, and pinpointing issues.
  • Use Case: When a critical bug is suspected in a complex function, use this Skill to break down its execution path, data dependencies, and external calls to quickly isolate the root cause.

Quick Start

Analyze the function named 'calculate_totals' in the current project in detail.

Frequently Asked Questions about TLDR Deep Analysis

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I perform a multi-layered function analysis using AST, CFG, and DFG?

Multi-layered function analysis using AST, CFG, and DFG is performed by executing the 'tldr' tool to break down a specified function's structure, execution paths, and data dependencies for debugging.

What is the best way to debug a complex function by tracing its execution path and data flow?

Debugging a complex function by tracing its execution path and data flow is best achieved through program slicing and Data Flow Graph (DFG) analysis, which isolate specific variables and dependencies to pinpoint root causes.

How does program slicing help with code review and refactoring?

Program slicing helps with code review and refactoring by extracting relevant program subsets based on specific data dependencies, allowing you to analyze function complexity and isolate variables without reviewing unrelated code.

Can I use the tldr tool to analyze external dependencies within a function?

Yes, you can use the tldr tool to analyze external dependencies within a function by generating a call graph that maps out external calls and function dependencies to identify potential issues during debugging.

Do I need any specific environment setup to run a deep code analysis on my project?

You need the 'tldr' tool installed in your environment to run a deep code analysis, as this Skill requires the tldr tool for execution to perform Abstract Syntax Tree and Control Flow Graph extractions.

Why does analyzing a function's Abstract Syntax Tree help identify bugs?

Analyzing a function's Abstract Syntax Tree helps identify bugs by exposing the precise structural hierarchy of the code, enabling you to detect structural anomalies and understand complex logic before refactoring.