performance Shipped
What this lens looks for
Judge a Claude Code extension on speed and token efficiency across three principles. Use shell scripts for deterministic work: any repeatable operation with a known outcome — file scaffolding, git operations, build/lint/type-check, search-and-replace and file moves, environment setup, metrics collection (counting lines, measuring sizes) — should be a script, not a model call; reserve the model for judgment, content generation, analysis that needs understanding, and adapting to the unexpected; in skills extract deterministic steps into invoked scripts, in hooks put deterministic automation (PreToolUse validation, PostToolUse formatting/linting), in agents call scripts rather than reasoning through known operations (an agent running wc -l beats one that reads and counts). Model selection tradeoffs: before downgrading a subtask to a smaller model, measure rather than assume three things — token efficiency (smaller models can compensate with verbose output, retries, or more tool calls, erasing the savings), latency (multiple attempts or correction can make wall-clock worse), and correctness (edge cases may force human intervention or a retry on the larger model); downgrading fits template filling, simple extraction from well-formatted input, formatting with explicit rules, and small-set classification; stay on the larger model for reasoning about code/architecture, tasks where a wrong answer costs more than the savings, and chained tasks where errors compound; when unclear, surface the tradeoff and ask the user — never silently downgrade. Progressive disclosure of context: .claude/rules/ and CLAUDE.md inject into the system prompt on every turn so their cost compounds, while content loaded via tool calls (file reads, skill invocation) is paid once at point of use; tier 1 always-on (rules, CLAUDE.md) carries only one-line directives and pointers and SHOULD be under 200 lines / ~8KB (narrow-workflow rules under 10 lines); tier 2 on-demand (skills, agent prompts) loads guidelines/checklists/procedures only when the step needs them; tier 3 deep reference is read only when investigating a specific question; rules MUST stay at the minimum directive and point to a checklist path rather than inlining it; skills SHOULD structure each step to load its own context and SHOULD NOT front-load all steps' reference material; agents MUST receive narrow task-specific instructions and SHOULD NOT carry background context "in case"; CLAUDE.md SHOULD hold only project identity, directory structure, and workflow pointers, with detailed procedures moved into skills and enforcement into rules.
What its verifier checks
Deterministic, repeatable operations (scaffolding, git, build/lint, file manipulation, metrics) are implemented as shell scripts rather than model reasoning; the model is reserved for judgment, content generation, and analysis; hooks carry the deterministic validation/formatting automation; any model downgrade is justified by measured token efficiency, latency, and correctness rather than assumed, and unclear cases are raised with the user instead of silently downgraded; rule and CLAUDE.md files stay under ~200 lines / ~8KB with narrow-workflow rules kept minimal; rules carry one-line pointers to checklists instead of inlining them; skills load each step's context on demand rather than front-loading all steps' reference material; agent prompts are narrow and task-specific without speculative background context; CLAUDE.md holds only identity, structure, and pointers, with procedures pushed to skills and enforcement to rules.