Matt Pocock Skills v1.0: 63% Fewer Tokens With Progressive Disclosure

Matt Pocock shipped mattpocock/skills v1.0 in June 2026—the first semver major since his repo became the most-starred Agent Skills collection on GitHub (135,000+ stars, 11,700+ forks).

The headline number: 63% lower token costs via progressive disclosure—load short summaries first, pull full skill bodies only when needed.

For teams burning context on bloated SKILL.md files in every Claude Code session, v1.0 is a pattern worth copying even if you never install a single slash command. Full skill inventory and four failure modes: Matt Pocock agent skills deep dive.

TL;DR

Progressive Disclosure: Why v1.0 Matters

Early agent skills dumped entire workflows into context at session start—planning guides, TDD checklists, architecture essays—whether or not the task needed them.

Pocock's v1.0 pattern:

Session start → compact skill index (names + one-line triggers)
       │
       User or model invokes /tdd (or matched intent)
       │
       ▼
Full TDD skill body loads → agent executes with complete rules

Result: Baseline context stays lean; depth arrives on demand. Pocock reports 63% token reduction across typical sessions—meaning cheaper runs, longer conversations, and less Headroom-style compression pressure.

This mirrors web performance (lazy loading) and Karpathy's LLM Wiki index-first navigation—don't load what you have not asked for yet. The Kaggle Agent Skills whitepaper formalizes the same three-level model: metadata → body → bundled resources.

v1.0 Architecture: Shared Design Skills

The 1.0.0 changelog is the real story—not just token savings, but composition:

Breaking: Install codebase-design and domain-modeling whenever you install architecture or TDD skills—they are dependencies, not optional extras.

User-Invoked vs Model-Invoked (Official Taxonomy)

v1.0 renamed Commands / Skills to match Pocock's spec proposal:

YOU type /grill-me  (user-invoked — orchestrates)
        │
        └──► grilling  (model-invoked — discipline loop)
        └──► domain-modeling  (model-invoked — if grill-with-docs)

Rules from docs/invocation.md:

• User-invoked skills orchestrate; model-invoked skills hold reusable discipline
• A user-invoked skill may call model-invoked skills
• A user-invoked skill must never call another user-invoked skill
• Model-invoked skills can also fire automatically when the task fits

This is the production implementation of the three-tier debate below—today, "skill-invocable" is approximated by making helper skills model-invoked and accepting the token cost.

Four Failure Modes → Skill Mapping

The README frames the entire library around four problems:

Pocock positions these against GSD, BMAD, and Spec-Kit—frameworks that own the whole process. His skills stay small and composable so you keep control when the process breaks.

Ubiquitous language example (from README):

• Before: "when a lesson inside a section of a course is made 'real'..."
• After: "problem with the materialization cascade"

That one term replaces a paragraph in every future session.

New Skills in v1.0

These extend the production set we covered in Matt Pocock's agent skills for real engineers—/tdd, /to-prd, /improve-codebase-architecture, /git-guardrails-claude-code—with more systematic design tooling.

v1.0.1 patch (June 17)

teach is now reuse-first: lessons build from components in ./assets/ (stylesheets, quiz widgets, simulators). The agent reads ./assets/ before authoring and extracts new reusable pieces instead of inlining one-offs.

Full Skill Inventory (June 2026)

Engineering (user-invoked)

Engineering (model-invoked)

Productivity

Community reactions:

• @geren8te asked how "writing great skills" was authored—preferences vs research-backed
• @johnlindquist noted /review behaves like a script or subagent, not a lightweight skill
• @iocapon praised /ask-matt as a neat routing pattern
• @ShivamS1123 and educators use /teach for instruction workflows

Video walkthrough: Pocock pointed to aihero.dev for the v1.0 changes first.

The Spec Gap: Three Tiers of Invocable

Pocock's most technical v1.0 thread is not a skill—it is a spec proposal for Anthropic's Agent Skills format.

Today (simplified):

Problem: Composite workflows. Example /review:

1. Run automated checks
2. Check against spec
3. Check coding standards

Step 1 wants to be /run-automated-checks—reused by /review and callable alone. But extracting it forces model-invocable status → its description burns tokens forever, even when you only want it inside /review.

Pocock's ask: Add skill-invocable — invokable by users or parent skills only, never auto-suggested to the model, no standing description in context.

Workaround today: write descriptions like "never invoke except from other skills"—spec-legal, wasteful, honest about the hack.

@dexhorthy (HumanLayer) connected this to post-IDE tooling—skills architecture is load-bearing for the next generation of dev environments.

Install and Use

npx skills@latest add mattpocock/skills

Works across agents implementing the Agent Skills spec—Claude Code, Cursor with skills support, Codex, and compatible harnesses via skills.sh.

Required first run:

/setup-matt-pocock-skills

Configures issue tracker (GitHub / Linear / local), triage labels, and docs directory.

Suggested starter path:

1. /setup-matt-pocock-skills — once per repo
2. /tdd + codebase-design — red-green-refactor with interface discipline
3. /grill-me or /grill-with-docs — alignment before code
4. /git-guardrails-claude-code — safety rails

v1.0 additions for larger codebases:

5. domain-modeling — shared vocabulary in CONTEXT.md
6. /improve-codebase-architecture — periodic deepening scans
7. /ask-matt — when you do not know which skill fits

v1.0 vs Vibe Coding

Pocock's positioning remains consistent with his AI Coding for Real Engineers workshop:

• Skills encode constraints (TDD, planning, architecture)
• Agents get procedures, not vibes
• Token efficiency (63%) makes discipline affordable at scale

Progressive disclosure is the missing economic layer—without it, rigorous skills price themselves out of long sessions.

Summary

Matt Pocock Skills v1.0.1 is three releases in one:

1. Shared design skills — codebase-design + domain-modeling as composable primitives
2. Progressive disclosure — ~63% token reduction
3. Formal taxonomy — user-invoked orchestrators vs model-invoked discipline

The skill-invocable tier debate matters for composite skills—/review calling /run-automated-checks should not tax every session. If Anthropic adopts Pocock's three-tier model, the whole ecosystem gets cheaper overnight.

Repository: github.com/mattpocock/skills · 135K+ stars · MIT license

Related Reading

• Matt Pocock Agent Skills (Full Inventory)
• Kaggle Agent Skills Whitepaper
• What Are Agent Skills?
• Matt Pocock AI Coding Workshop
• Headroom Token Compression
• Loop Engineering for Agents

v1.0.0 / v1.0.1 from CHANGELOG.md. Token claims from @mattpocockuk (June 2026).