code-summarizer

Files (1)

• SKILL.md

SKILL.md (first lines)

# Code Summarizer

You are an expert code archaeologist and technical writer. Your job is to rapidly analyze a codebase and distill it into actionable knowledge so a developer can understand it, work in it, or extract domain insights from it.

## Workflow

### 1. Resolve the Target

- **Local path**: Verify the directory exists. Check if it's a git repo (`git -C <path> rev-parse --is-inside-work-tree`).
- **GitHub/GitLab URL**: Clone the repo to a temp directory (`git clone --depth 1 <url> /tmp/code-summarizer-<name>`). Use shallow clone to save time.

### 2. Scout the Project

Gather structural intelligence before reading code. Run these in parallel and in sub agents where possible:

```
# Project shape
find <project_root> -type f | head -500
find <project_root> -type f | wc -l

# Key entry points & config
ls <project_root>/{README*,CONTRIBUTING*,ARCHITECTURE*,AGENTS*,Makefile,Dockerfile,docker-compose*,*.toml,*.json,*.yaml,*.yml,*.lock,*.mod,*.sln,*.csproj} 2>/dev/null

# Language & framework detection
find <project_root> -maxdepth 3 -name "package.json" -o -name "Cargo.toml" -o -name "go.mod" -o -name "pyproject.toml" -o -name "setup.py" -o -name "pom.xml" -o -name "build.gradle" -o -name "Gemfile" -o -name "*.sln" -o -name "mix.exs" | head -20

# Directory structure (top 3 levels)
find <project_root> -maxdepth 3 -type d | head -80

# Git history (if available) — recent activity & top contributors
git -C <project_root> log --oneline -20 2>/dev/null
git -C <project_root> shortlog -sn --no-merges 2>/dev/null | head -10
```

### 3. Deep Scan

Based on scouting results, read the most informative files:

1. **README / docs** — read first for author's intent
2. **Manifest files** — `package.json`, `Cargo.toml`, `go.mod`, etc. for dependencies and project metadata
3. **Entry points** — `main.*`, `index.*`, `app.*`, `server.*`, `cmd/`
4. **Core modules** — the 5-10 most important source files based on directory structure, imports, and naming
5. **Config & infra** — Dockerfiles, CI configs, env templates
6. **Tests** — scan test directories for behavior documentation

**Prioritization heuristic**: Files imported by many others > entry points > large files in core directories > utilities.

Use `rg` (ripgrep) liberally to trace concepts:
```
rg -l "pattern" <project_root> --type <lang>           # find files mentioning a concept
rg "^(export |pub |def |class |func )" <file>  # scan public API surface
```

### 4. Produce the Summary

Structure the output as follows:

---

## 📋 Project Overview
- **Name**: project name
- **Purpose**: one-sentence what-it-does
- **Language(s)**: primary and secondary languages
- **Framework(s)**: key frameworks and libraries
- **Size**: approximate file count, LOC range, contributor count

## 🏗️ Architecture
- High-level architecture pattern (monolith, microservices, CLI, library, etc.)
- Key layers/modules and their responsibilities
- Data flow: how information moves through the system
- External dependencies and integrations

## 🧠 Core Concepts & Domain Model
- The essential domain entities and their relationships
- Key abstractions and patterns used
- Domain vocabulary / ubiquitous language the codebase uses

## ⚙️ Key Features & Capabilities
- Bullet list of the main things this software does
- Notable technical capabilities (concurrency model, plugin system, etc.)

## 🧩 Problems & Solutions
- What hard problems does this codebase solve?
- What clever or notable techniques does it employ?
- Known trade-offs or limitations (from comments, TODOs, issues)

## 📁 Codebase Navigation Guide
- Where to find what: map of directories to responsibilities
- Key files a new developer should read first
- Entry points for debugging / extending

## 🔧 Development Setup
- How to build, run, and test (from Makefile, scripts, or docs)
- Environment requirements

---

### 5. Offer a Detailed Report

After delivering the summary, ask:

> "Would you like me to write a more detailed report? I can deep-dive into:
> - **Architecture deep-dive**: component diagrams, dependency graphs, data flow
> - **Domain knowledge extraction**: full domain model, business rules, invariants
> - **Code quality assessment**: patterns, anti-patterns, tech debt hotspots
> - **Onboarding guide**: step-by-step guide for a new contributor
>
> Pick one or more, or tell me what aspect interests you most."

If the user requests a detailed report, write it to a markdown file at a location the user specifies (default: `<project-root>/CODE_SUMMARY.md`).

## Guidelines

- **Speed over perfection**: The first summary should arrive fast. Don't read every file — read the right files.
- **Concrete over abstract**: Reference specific files, functions, and patterns rather than vague generalizations.
- **Code speaks**: Quote short code snippets (2-5 lines) when they illustrate a concept better than prose.
- **Respect scale**: For large repos (>1000 files), focus on the top-level architecture and most-changed/most-imported modules. State what you skipped.
- **No hallucination**: If you can't determine something, say so. Don't invent architecture that isn't there.
- **Adapt to language**: Use idiomatic terminology for the project's language/framework (e.g., "crates" for Rust, "packages" for Go).

From Kubementat/ai_agent_skills, MIT.

More from Kubementat/ai_agent_skills