5 Claude Code Skills That Actually Work: Lessons from an AI Agent Fleet

You tell Claude "write tests first, then implement." It replies "Got it, writing tests first." You come back and find the implementation finished, with a few happy-path tests tacked on at the end. The problem isn't that Claude doesn't understand you. The problem is your workflow has no phase gate.

mattpocock/skills grew quickly after its late-April 2026 release and had about 241K GitHub stars on August 30, 2026 (MIT license). It gives agents structural workflow rules: if the Red test has not failed, Green implementation does not begin. This guide draws on our agent-fleet experience to select five skills that remain in the upstream repository and combine them into a reusable workflow.

TL;DR

• Skills aren't better prompts — they're workflow modules with phase gates
• Our 5 picks: tdd, to-spec, to-tickets, grill-me, implement
• Install: npx skills@latest add mattpocock/skills — done in 5 minutes
• Suggested chain: grill-me → to-spec → to-tickets → implement, with implement driving TDD at agreed seams
• Skills carry reusable process; checks that must never be skipped still belong in hooks or CI

Why Claude Ignores "Write Tests First" (And What Actually Fixes It)

Nearly everyone using Claude Code for development has hit this: you write "use TDD, write tests first" in your prompt. Claude acknowledges. Then it writes the implementation and backfills tests.

The root cause isn't comprehension failure — it's that prompt-level instructions are fundamentally suggestions. When processing complex tasks, Claude acts on what it calculates as the most efficient path. For a language model, writing implementation first and deriving tests afterward is the more "natural" sequence. Your prompt is a nudge, not a gate.

The TDD skill fixes this by defining a structural phase gate: the Red phase must produce a failing test, and the test must actually fail, before the Green phase (implementation) is allowed to start. This is the essential difference between a prompt nudge and structural enforcement.

Where Skills Fit: The 4-Layer Architecture

Before picking skills, understand Claude Code's 4-layer system — putting things in the wrong layer is where most people go wrong.

Layer	Mechanism	Execution Guarantee	Best For
CLAUDE.md	Loaded every session	Probabilistic	Persistent project rules, keep under 200 lines
Skills (SKILL.md)	Lazy-loaded (description always present; body only on invoke)	Probabilistic	Reusable workflow modules, playbooks
Subagents	Isolated context workers	Deterministic scope isolation	Parallel or context-isolated tasks
Hooks	Shell scripts on lifecycle events	Fully deterministic	Zero-exception enforcement: format checks, lint, tests

Key insight: once CLAUDE.md exceeds ~200 lines, Claude silently ignores rules buried in the noise. Marmelab's engineering team verified this in production, and we hit the same issue — certain rules started being silently skipped, and it took a while to trace the cause.

Skills' lazy-load design solves this. Only the description (max 1,536 chars) stays in persistent context. The full SKILL.md body loads only when you invoke /skill-name. This lets you move complex workflows out of CLAUDE.md into skills, keeping CLAUDE.md lean.

If you want to dive deeper into CLAUDE.md's three-tier priority system and .claude/rules/ path scoping, see our Claude Code Setup Guide. This article focuses on which community skills are worth installing.

Why mattpocock/skills Grew So Quickly

Matt Pocock is a well-known TypeScript educator. By August 30, 2026, mattpocock/skills had about 241K stars and an MIT license. It also arrived as developers were learning that prompt engineering alone is not enough; repeatable work needs workflow engineering.

More importantly, Skills aren't exclusive to Claude Code. Agent Skills (agentskills.io) is an open standard designed for cross-IDE compatibility: Claude Code, Cursor, Gemini CLI. The skills you install aren't IDE-locked plugins — they're cross-platform workflow protocols.

The ecosystem is growing fast:

• hesreallyhim/awesome-claude-code: The most complete community directory covering skills, hooks, orchestrators, plugins
• ComposioHQ/awesome-claude-skills: Role-based bundles (e.g., "Web Wizard" = 5-skill combo)
• alirezarezvani/claude-skills: 232+ skills spanning engineering, marketing, compliance, C-level advisory — engineers are just early adopters

This isn't one repo going viral. It's the ecosystem migrating from "everyone writes their own prompts" to "shared standardized workflows."

Our 5 Picks: The Skills Our Agent Fleet Actually Uses

From the current mattpocock/skills repository and the broader ecosystem, these five form the clearest end-to-end development flow:

Skill	Command	Core Behavior	Best For
tdd	/tdd	Phase-gated TDD: Red must fail → Green allowed → forced minimal implementation	Any feature that needs test coverage
to-spec	/to-spec	Synthesizes the existing conversation into a spec and publishes it to the configured issue tracker	Turning a clarified discussion into an executable spec
to-tickets	/to-tickets	Splits a spec into tracer-bullet tickets with dependency edges	Breaking large features into assignable tasks
grill-me	/grill-me	Exhaustive decision-tree questioning until every branch has a clear answer	Clarifying fuzzy ideas before writing code
implement	/implement	Builds from a spec or tickets, drives TDD at agreed seams, and closes with code review	Taking a spec through verified implementation

Our agent fleet follows a similar shape: strategy task → work breakdown → isolated execution → completion checks. The to-spec → to-tickets → implement chain uses the same architecture. We implement it with GitHub Issues and automation scripts; mattpocock packages the steps as invokable skills.

TDD Skill Deep Dive: What Phase Gate Actually Means

The TDD skill is the single highest-impact skill in mattpocock/skills. Its core mechanism:

1. Red Phase (write failing tests): The skill instructs Claude to write tests that must run and fail. This failure isn't a bug — it's by design. Before implementation exists, tests should fail.

2. Green Phase (minimal implementation): Only after Red tests confirm failure does the implementation phase begin. The skill enforces "write only the minimal code to make tests pass" — nothing more.

3. Subagent isolation: The TDD skill uses context: fork, running the test-writing agent and implementation agent in separate contexts. This prevents a common problem: when the same context knows both "what tests expect" and "how to implement," Claude tends to skip Red and write passing code directly.

The difference from "just tell Claude to write tests first": a prompt is a suggestion (Claude can choose to ignore it); a phase gate is structure (Green cannot start without passing Red).

Skills and hooks solve different problems. A skill gives the model a reusable method; a hook runs a script at a fixed lifecycle event. If a check cannot be skipped, such as blocking dangerous Git operations or running lint after writes, do not depend on the model choosing to invoke a skill.

The Workflow Chain (Manual Sequence): grill-me → to-spec → to-tickets → implement

A single skill has value, but several can form a complete development pipeline. These skills do not auto-chain, so trigger each step deliberately:

Step 1: /grill-me (clarify requirements) Input: A vague idea ("I want to build a dashboard") Output: Decision-tree exhausted, every branch has a clear answer

Step 2: /to-spec (structured spec) Input: The grill-me conversation output Output: A structured spec published to the configured issue tracker

Step 3: /to-tickets (vertical slices) Input: The published spec Output: Tracer-bullet tickets with explicit dependency edges

Step 4: /implement (execute each ticket) Input: A spec or ticket set Output: Code that matches the spec and passes TDD at agreed seams plus code review

This chain's logic mirrors our fleet's daily operations: strategy issue → task breakdown → isolated execution → auto-complete. The difference is mattpocock packages each node as a standardized skill anyone can npx install and use immediately.

After first install, run /setup-matt-pocock-skills to configure per-repo settings (issue tracker location, triage labels, docs path).

Skills + Hooks: From Probabilistic to Deterministic Execution

This is the most counterintuitive part: Skills are probabilistic.

No matter how complete your SKILL.md is, Claude can still skip skill instructions when focused on complex tasks. This isn't a bug — it's the nature of language models. They trade off between multiple objectives, and sometimes "complete the task" outweighs "follow the process."

Hooks are fully deterministic. They're shell scripts bound to Claude Code lifecycle events (like PreToolUse, PostToolUse) that execute unconditionally every time they trigger.

The combination strategy:

• Skills define "what to do": TDD's Red/Green phase gate, PRD's output structure
• Hooks ensure "it will be done": Check TDD phase before each prompt, run lint after each code write

mattpocock/skills' git-guardrails-claude-code is a great example — it uses hooks to intercept dangerous git operations (force push, reset --hard). Not "suggesting" Claude shouldn't do it, but blocking at the shell level. The setup-pre-commit skill configures Husky hooks, making linting and tests mandatory before every commit.

Installation & Quick Start

# Launch the installer, then choose skills and target agents
npx skills@latest add mattpocock/skills

The installer asks you to choose the target agent and installation scope, so the destination depends on those choices. For a project-scoped Claude Code install, .claude/skills/ is a common location. In your session:

1. Verify installation: Type / in Claude Code and confirm the skill list shows /tdd, /grill-me, etc. If they don't appear, check that .claude/skills/ contains the corresponding SKILL.md files
2. Run /setup-matt-pocock-skills: Configure issue tracker, triage labels, docs path
3. Start with /grill-me: No code required, pure conversation — immediately feel the difference from a regular prompt
4. Global vs project scope: Place in ~/.claude/skills/ for global (all projects) or .claude/skills/ for project-level (commit to repo, share with team)
5. What context: fork means: Setting this in SKILL.md frontmatter makes the skill execute in an isolated subagent, fully separated from the main session context

Community resources: if mattpocock/skills isn't enough, hesreallyhim/awesome-claude-code is the most complete directory, ComposioHQ/awesome-claude-skills has role-based bundles, and alirezarezvani/claude-skills catalogues 232+ skills.

Risk Disclosure: Honest Limitations

From our agent fleet experience, here's what you should know before installing:

Skills are still probabilistic. Installation does not equal guaranteed execution. During complex tasks, Claude may skip skill instructions. Don't expect "install and forget" — reliable execution requires the skills + hooks dual layer.

Upstream names change. Earlier versions used to-prd, to-issues, and caveman; those are no longer part of the current main flow. Check the repository README before installing. This article reflects to-spec, to-tickets, and implement as of August 30, 2026.

/grill-with-docs time cost. The full interview flow takes 15-20 minutes. For small features or hotfixes, just start coding — running the full decision-tree is overkill.

forrestchang/andrej-karpathy-skills complements mattpocock/skills. karpathy-skills defines "what not to do" guardrails (defense); mattpocock/skills defines "how to do things structurally" workflows (offense). They don't conflict — stack them.

Do not treat a skill as enforcement. Automatic invocation depends on its description, task context, and the host tool. Put mandatory rules in hooks, tests, or CI.

Conclusion: From "Smart but Chaotic" to "Engineering Discipline"

Skills don't solve Claude's capability problem — they solve its behavioral discipline problem. An AI that can do anything, without phase gates or structured processes, is like a brilliant engineer who never runs tests — fast output, unpredictable quality.

Start with npx skills@latest add mattpocock/skills and use /grill-me to learn the interaction. Then try grill-me → to-spec → to-tickets → implement. If you manage several AI agents at once, the herdr terminal multiplexer guide shows how to monitor their state in one window.