What is the TLDR stack?

A set of CLI tools that produce a token-efficient overview by extracting file trees, code structure, call graphs, and complexity data.

What output does the overview produce?

A structured report with sections for Project Overview, Structure, Architecture (Call Graph), and Complexity Hot Spots plus a token cost summary.

Can I customize language and file extensions?

Yes. Pass language and extension parameters (e.g., --lang python, --ext .py) to tailor the report.

tldr-overview

npx machina-cli add skill parcadei/Continuous-Claude-v3/tldr-overview --openclaw

Files (1)

SKILL.md

1.8 KB

TLDR Project Overview

Get a token-efficient overview of any project using the TLDR stack.

Trigger

/overview or /tldr-overview
"give me an overview of this project"
"what's in this codebase"
Starting work on an unfamiliar project

Execution

1. File Tree (Navigation Map)

tldr tree . --ext .py    # or .ts, .go, .rs

2. Code Structure (What Exists)

tldr structure src/ --lang python --max 50

Returns: functions, classes, imports per file

3. Call Graph Entry Points (Architecture)

tldr calls src/

Returns: cross-file relationships, main entry points

4. Key Function Complexity (Hot Spots)

For each entry point found:

tldr cfg src/main.py main  # Get complexity

Output Format

## Project Overview: {project_name}

### Structure
{tree output - files and directories}

### Key Components
{structure output - functions, classes per file}

### Architecture (Call Graph)
{calls output - how components connect}

### Complexity Hot Spots
{cfg output - functions with high cyclomatic complexity}

---
Token cost: ~{N} tokens (vs ~{M} raw = {savings}% savings)

When NOT to Use

Already familiar with the project
Working on a specific file (use targeted tldr commands instead)
Test files (need full context)

Programmatic Usage

from tldr.api import get_file_tree, get_code_structure, build_project_call_graph

# 1. Tree
tree = get_file_tree("src/", extensions={".py"})

# 2. Structure
structure = get_code_structure("src/", language="python", max_results=50)

# 3. Call graph
calls = build_project_call_graph("src/", language="python")

# 4. Complexity for hot functions
for edge in calls.edges[:10]:
    cfg = get_cfg_context("src/" + edge[0], edge[1])

Source

git clone https://github.com/parcadei/Continuous-Claude-v3/blob/main/.claude/skills/tldr-overview/SKILL.mdView on GitHub

Overview

Get a token-efficient snapshot of any codebase using the TLDR stack. It summarizes structure, architecture, and hot spots into a concise report, helping you onboard quickly and accelerate reviews.

How This Skill Works

It runs four TLDR commands: tldr tree to build a file map, tldr structure to list functions, classes, and imports, tldr calls to map cross-file relationships, and tldr cfg to highlight high-complexity entry points. The tool then assembles a structured report with sections like Project Overview, Structure, Architecture, and Complexity Hot Spots.

When to Use It

Onboarding a new team member to an unfamiliar codebase.
Performing a quick repo audit before starting a project or PR.
Preparing a handoff to another developer or team.
Conducting a lightweight architecture review or design discussion.
Analyzing the impact of recent changes by identifying hotspots.

Quick Start

Step 1: Generate a file tree: tldr tree . --ext .py
Step 2: Inspect code structure: tldr structure src/ --lang python --max 50
Step 3: Build call graph and identify hotspots: tldr calls src/; tldr cfg src/main.py main

Best Practices

Run across the whole repo to capture global structure and dependencies.
Specify language and extensions to focus results (e.g., --lang python, --ext .py).
Review the Architecture (Call Graph) section to understand cross-file relationships.
Check Complexity Hot Spots to identify potential refactoring needs.
Use the token cost output to gauge report size and iteration effort.

Example Use Cases

Overview a Python microservice before a kickoff.
Snapshot a legacy monolith to guide modernization.
Audit a React frontend to assess module coupling.
Document a data-pipeline repository for data engineers.
Prepare a CLI tool for an efficient handoff to another dev.

Frequently Asked Questions

Add this skill to your agents