Stop Stuffing 20,000 Lines into CLAUDE.md: 10 Skills That Slash Context Costs

If you're still cramming two thousand lines of architecture rules, linter configs, and API conventions into a single CLAUDE.md file, you're paying a steep token tax on every single conversation. Worse, before the model even reaches your actual intent, all that bloated redundancy has already diluted its attention mechanism.

According to a systematic breakdown by Bilibili creator CodeRash with Gaurav, the way senior engineers use Claude Code is undergoing a fundamental shift: from monolithic system prompts to the open Agent Skills specification (skill.md) and dedicated plugins. The core logic is progressive disclosure — at session start the model reads only a ~50-token YAML front matter description, and only when a task actually triggers a skill does it load the full workflow instructions, delegating mechanical work to deterministic Python or Node scripts inside the skill folder.

This article breaks down 10 skills worth installing immediately, along with the specific mechanisms each uses to cut token waste.

Progressive Disclosure: Why Skills Cost Less Than Cramming Prompts

The traditional approach piles all rules into one file and loads everything on every conversation. A well-engineered skill, by contrast, follows a four-part structure: skill.md (the name and trigger description in YAML front matter + routing instructions), scripts (deterministic Python/Node/bash helper scripts that Claude calls), references (deep documentation loaded on demand), and assets (templates and schemas).

Take scaffolding a new backend endpoint. Rather than having the model generate 800 lines of boilerplate token by token every time (slow, expensive, prone to drift), let the Skill Creator codify your workflow into a routing file with a deterministic generation script in scripts. Next time it's a ~80-token script call, and all the reasoning tokens go to custom business logic. This is the underlying logic of cost optimization, and the prerequisite for understanding every skill that follows.

YAML front matter is the metadata block at the top of a Markdown file, surrounded by ---, typically using key-value pairs to describe document properties. In the Agent Skills specification, it carries the skill's name and trigger description, so the model only needs to scan these few dozen tokens to decide whether the current task relates to the skill — without loading the body. This "check the table of contents first, read the body later" mechanism is exactly what lets progressive disclosure dramatically cut context costs, and it makes skill files both human-readable and machine-routable.

Deterministic scripts are programs whose behavior is predictable and which always produce the same output for the same input — in contrast to token-by-token sampling by a model. Putting mechanical work like boilerplate generation, file parsing, and chart rendering into Python/Node/bash scripts inside the skill folder means the model only spends a few tokens to invoke them and read structured results, avoiding generation drift and concentrating the reasoning budget on the business logic that actually needs judgment.

Coding Workflow: Addy Osmani's Agent Skills

Ranking first is Addy Osmani's agent skills repository, which according to the video has surpassed 100k stars and is regarded as the gold standard for advanced engineering coding workflows. It packages 25 individual skills mapped to 9 slash commands, covering the full lifecycle: spec, plan, build, test, review, simplify, ship, and more.

Three design choices let it balance token efficiency with determinism. First, progressive disclosure; second, each skill embeds an "anti-rationalization table" — listing the excuses models commonly use to skip steps, paired with hard rebuttals to stop the agent from taking shortcuts; third, offloading mechanical work to scripts.

As for the skills you'll use most day to day: interview me / idea-refine forces you to expose hidden assumptions through sharp one-at-a-time questions before you write a single line of code, converging on a minimal spec instead of letting the model hallucinate 500 lines of assumptions; planning and task breakdown reads your codebase conventions and outputs an atomic task list with acceptance criteria; code simplification strips cognitive complexity while keeping inputs/outputs, side effects, and error ordering unchanged and without modifying tests; code review runs a five-axis review — correctness, security, maintainability, performance, and more — before merging.

Codebase Exploration: Graphify Turns Your Repo into a Knowledge Graph

The second-biggest token black hole is codebase exploration. Drop Claude Code into a brownfield repo or a multi-service architecture, and it'll typically run grep, find, and cat across forty files — and by the time it understands the database relationships and API routes, 80,000 tokens are already gone.

Graphify is an open-source skill that converts your entire project folder into a queryable semantic knowledge graph. It doesn't just parse TypeScript or C# ASTs — it also reads SQL schemas, architecture PDFs, Markdown notes, even UI scripts, extracting semantic entities and linking them into three kinds of output: an interactive graph.html dependency visualization, a linked Obsidian architecture vault, and a compressed structural summary that Claude can query directly.

A concrete scenario: after modifying a Supabase-based investor verification table, you want to know the blast radius across the Node.js API on Fly.io and the React frontend. Claude reads the graph nodes and immediately sees downstream consumers — according to the video, cutting exploration tokens by over 80% while avoiding breaking changes on edge routes.

AST (Abstract Syntax Tree) is a tree representation of source code's syntactic structure, where each node corresponds to a language construct — a function declaration, a conditional branch, or a type annotation — stripped of irrelevant details like whitespace and comments. With ASTs, Graphify can extract call and reference relationships among functions, classes, and modules across languages like TypeScript and C#, rather than doing mere text matching; combined with non-code sources like SQL schemas and architecture docs, it ultimately assembles a semantic entity network covering the entire repository.

Architecture Diagrams and Subagent Orchestration: Artifact Diagramming and Superpowers

Asking a model to draw an architecture or sequence diagram often costs four rounds of back-and-forth to fix Mermaid syntax, clipped labels, and black text on dark backgrounds. Artifact Diagramming loads Anthropic's internal diagramming conventions before generating the first token, enforcing three rules: use inline SVG and HTML/CSS rather than fragile Mermaid; write precise geometric coordinates and bounding boxes to avoid label collisions; and use semantic CSS variables and palette validation so everything reads clearly in both dark and light mode. Paired with a local rendering script, the model only writes declarative SVG while a deterministic script outputs production-grade PNG or WebP — zero image hallucination, zero repeated prompting.

Jesse Vincent's Superpowers (reportedly nearly 300k stars according to the video) is an opinionated, complete development methodology that tackles context pollution through subagent orchestration. The flow: intercept the prompt, force Socratic clarification and output a design spec; after approval, create an isolated branch with git worktree and verify a clean test baseline; break the spec into micro-tasks of 2 to 5 minutes; hand them to subagents — subagents first delete the code, force a failing test to be written, then implement; once the task passes code review, the subagent terminates and all the draft noise disappears with it. According to the video, the main session can stay under 15,000 tokens from kickoff all the way to the PR.

git worktree allows multiple working directories to be checked out simultaneously on the same repository, each pointing to a different branch while sharing a single object store. Superpowers uses this to create an isolated branch for each micro-task where a subagent deletes code, writes a failing test, implements, and submits for review, while the main workspace keeps a clean baseline; once the task is done, the temporary worktree is discarded, so drafts and debugging noise never flow back into the main session — keeping context pollution to a minimum.

Evidence-Driven Frontend Optimization: Web Quality Skills

Ask a general-purpose model to optimize React performance and it usually guesses: slapping useCallback and useMemo onto functions at random, wasting tokens, cluttering the code, and never improving real user latency. Addy Osmani's Web Quality Skills forces evidence-driven work.

Paired with the Chrome DevTools MCP server, it spins up a local dev server or hits a Cloudflare Pages preview URL, collects runtime traces, LCP, INP, and CLS, and strictly distinguishes "measured runtime failures" from "source-code hypotheses." It also validates agent-facing browsing signals such as structured JSON-LD, LLMs.txt, and WebMCP endpoints. The result: you pay only for the one critical rendering path bottleneck that the DevTools trace actually confirms, instead of rewriting ten components based on guesses.

Type Checking and Engineering Discipline: LSP Plugins and Cleanup Tools

In a strongly typed codebase, skip the LSP plugin and Claude will, after editing a file, run a build, wait twelve seconds, and then dump four hundred lines of noisy output into context — all to find one missing interface property. Enable the TypeScript, Rust, or C# LSP plugin and the model plugs directly into the active language server, getting line-level type errors or compiler diagnostics at the moment of the edit — fewer than 50 tokens according to the video — for a tighter feedback loop and thousands of tokens saved per session.

The cleanup phase matters too. Planotator upgrades native plan mode into an interactive, artifact-style review interface, letting you annotate and approve the architecture item by item before the model writes any implementation code; CloudMeme replaces repeatedly re-explaining architecture decisions across sessions with compressed semantic long-term memory, retrieving only the relevant history for the current module. Shipyard runs a dedicated security-audit subagent and cross-task duplicate detection before delivery, automatically merging code that duplicates existing utility functions. Two more popular skills target over-engineering: Karpati Coding Guidelines require thinking before writing, making only surgical changes, and never touching unrelated code; Caveman uses a seven-level simplification ladder to push the agent onto the laziest-but-correct minimal path while preserving safety, input validation, and accessibility. According to the video, the two can cut 30% to 40% of generated output tokens.

Treat Them as One System

A single skill solves a single problem; combined, they form a complete pipeline: understand the repo without grep using Graphify, lock down the design with Addy Osmani's spec and planner, execute with Superpowers plus LSP in isolated subagents, and finally validate with WebPerf and Shipyard before merging. For engineers working with agents every day, this is a better deal than piling another 20,000 lines into CLAUDE.md — and it's closer to reviewable, reproducible engineering discipline.

One-line Summary

Replace 20,000 lines of CLAUDE.md with progressively disclosed skills and scripts to restructure your Claude Code workflow.

Paragraph Summary

Cramming massive rules into a single CLAUDE.md makes every conversation pay a steep token tax and dilutes the model's attention. A better path is the Agent Skills specification: skill.md exposes only a ~50-token YAML front matter description, loads full instructions only when a task triggers it, and delegates mechanical work to deterministic scripts. The article breaks down 10 skills covering the coding lifecycle (Addy Osmani's 25 skills plus anti-rationalization tables), semantic codebase graphs (Graphify), spec-compliant architecture diagrams, subagent orchestration (Superpowers), evidence-driven frontend performance optimization (Web Quality Skills), LSP line-level diagnostics, and cleanup tools for planning review, long-term memory, and security auditing — emphasizing that combining them into a pipeline is the complete solution.