Skip to main content
skill CX Codex

codebase-packager — Claude Code skill for code context

The codebase-packager Claude Code skill prepares large repositories for AI coding tasks. It builds digests, packs source context, and traces connections across files.

MIT 105 installs ★ 29 updated 2026-08-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill codebase-packager -a claude-code
Open on GitHub

What codebase-packager does

The skill shapes repository context for work with large codebases. Repomix bundles files and compresses them into signatures, Gitingest creates repository digests, and llm-tldr analyzes dependencies and call graphs. It also supports meaning-based code search, file structure extraction, and dead-code detection.

Tasks use commands such as repomix, gitingest, and tldr; for example, tldr impact functionName . traces callers. The workflow also covers scanning Repomix context bundles for keys and personal data. Small single-file tasks and debugging a finished implementation fall outside its use cases.

What it helps with

  • compress project directories into AI context
  • create a digest of an unfamiliar repository
  • trace dependencies across files and function calls
  • search for logic despite inconsistent naming
  • find unreachable functions and circular dependencies

Example prompts for the agent

  • Pack src/** into context with Repomix compression.
  • Create a repository digest in digest.txt.
  • Trace the callers of functionName and assess the change impact.

How to install codebase-packager

1Skills CLI (Vercel)

npx skills add oakoss/agent-skills --skill codebase-packager -a claude-code

2Manually: put the files in place

~/.claude/skills/codebase-packager/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/codebase-packager/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about codebase-packager

How do I install codebase-packager in Claude Code?

Run npx skills add oakoss/agent-skills --skill codebase-packager -a claude-code. The skill file is installed at ~/.claude/skills/codebase-packager/SKILL.md.

What does codebase-packager do?

It prepares compact context for large repositories by creating digests, bundling source files, and analyzing links between files and functions.

Which tools does codebase-packager use?

It uses Repomix to package context, Gitingest to create repository digests, and llm-tldr for code and dependency analysis.

Source text

SKILL.md · MIT
---
name: codebase-packager
description: 'Performs semantic code intelligence and token optimization through context engineering and automated context packing. Use when reducing token overhead for large codebases, creating repository digests with Gitingest, packaging code context with Repomix, or tracing cross-file dependencies with llm-tldr.'
license: MIT
metadata:
  author: oakoss
  version: '1.1'
---

# TLDR Expert

## Overview

Achieves high-fidelity codebase comprehension at a fraction of the token cost through semantic layers, structured digests, and advanced context packaging. Combines Repomix for context packing, Gitingest for repository digests, and llm-tldr for graph-based code analysis.

**When to use:** Reducing prompt overhead for large codebases, onboarding to unfamiliar repositories, mapping cross-file dependencies, creating AI-optimized context bundles.

**When NOT to use:** Small single-file tasks, final implementation debugging (read the full file), real-time code editing.

## Quick Reference

| Pattern            | Tool / Command                          | Key Points                                             |
| ------------------ | --------------------------------------- | ------------------------------------------------------ |
| Context packing    | `repomix --include "src/**" --compress` | Package subdirectories into AI-optimized bundles       |
| Signatures only    | `repomix --include "src/**" --compress` | Compression extracts signatures via Tree-sitter        |
| Repository digest  | `gitingest . -o digest.txt`             | Prompt-friendly summary for quick onboarding           |
| Dependency context | `tldr context funcName --project .`     | LLM-ready context for a function with 95% token saving |
| Caller tracing     | `tldr impact functionName .`            | Reverse call graph to assess change blast radius       |
| Forward call graph | `tldr calls .`                          | Build forward call graph across the project            |
| Semantic search    | `tldr semantic "session expiry" .`      | Find logic by meaning when naming is inconsistent      |
| Architecture audit | `tldr arch .`                           | Detect circular deps, layer violations, dead code      |
| Dead code finder   | `tldr dead .`                           | Find unreachable functions with zero callers           |
| File extraction    | `tldr extract src/file.ts`              | Extract AST (functions, classes, imports) from a file  |
| Secret scanning    | Repomix built-in secretlint             | Ensure context bundles contain no keys or PII          |

## Common Mistakes

| Mistake                                                     | Correct Pattern                                                                |
| ----------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Reading entire large files without checking structure first | Run `tldr extract` to get signatures before reading full files                 |
| Using `grep` for dependency tracing across files            | Use `tldr impact` for reverse call graph that understands dynamic imports      |
| Packing `node_modules` or `dist` into context bundles       | Configure Repomix ignore-list to exclude generated and vendor directories      |
| Assuming semantic search results are exhaustive             | Verify top matches against actual source and cross-reference with `rg`         |
| Running Repomix without compression on large directories    | Use `--compress` flag to stay within context window limits                     |
| Including irrelevant context that dilutes signal quality    | Follow top-down priority: index, signatures, core logic, then adjacent context |

## Delegation

- **Repository structure discovery**: Use `Explore` agent to map directory layout and identify key modules before building context bundles
- **Multi-step context packing workflow**: Use `Task` agent to run Gitingest digest, Repomix compression, and llm-tldr indexing in sequence
- **Architecture analysis and planning**: Use `Plan` agent to design context engineering strategy for large monorepos

## References

- [Context Engineering Patterns](references/context-engineering-patterns.md) -- packing strategies, XML tagging, signal-to-noise optimization, warm-up prompts
- [Repomix and Gitingest Mastery](references/repomix-gitingest-mastery.md) -- configuration, compression mode, digest generation, Tree-sitter extraction
- [Semantic Graph Analysis](references/semantic-graph-analysis.md) -- llm-tldr CLI tools, impact analysis, semantic search, architectural audits

© oakoss · MIT · oakoss/agent-skills

Similar skills

SKILL.md skills catalog →

From the same set106

The whole set →
turborepo This Claude Code skill helps configure Turborepo in JavaScript and TypeScript monorepos. Use it to set up task pipelines, caching, package filters, and CI workflows. CX Codex +1 108installs realtime-sync realtime-sync guides agents through designing low-latency sync using WebTransport, CRDT conflict resolution, and batched AI token streaming. CX Codex +1 108installs plan-first-development The plan-first-development Claude Code skill structures project planning and tracks progress across sessions. It activates for new projects, major features, and work split into phases. CX Codex +1 107installs tracer-bullets The tracer-bullets Claude Code skill splits multi-layer work into end-to-end slices. Each slice is checked before work moves on. CX Codex +1 107installs expert-instruction The expert-instruction Claude Code skill helps design system instructions for AI agents. It covers agent roles, behavioral limits, response formats, and tool-use guidance. CX Codex +1 106installs skill-management skill-management — a Claude Code skill for creating, reviewing, and validating skills against the Agent Skills standard. It comes into play during structure checks, description edits, and manifest comparisons. CX Codex +1 105installs meta-agent-creator The meta-agent-creator Claude Code skill helps define custom subagents and configure their settings. Use it to shape task delegation and control which tools an agent can access. CX Codex +1 104installs localization-engineer localization-engineer is a Claude Code skill that guides internationalization and localization architecture. It structures ICU messages, CLDR plurals, RTL layouts, and multilingual SEO. CX Codex +1 103installs

Project sponsors

Companies that keep this analytics open