mattpocock/skills: A complete AI Coding workflow, end-to-end

Overview

This video is a tutorial-style walkthrough of the “main AI coding workflow” for mattpocock/skills—an end-to-end skills framework/repo. The speaker focuses on getting set up and then using the core skills in the right sequence, explicitly avoiding advanced/experimental features.

Purpose + repo positioning

• The speaker says they’ve never published a proper tutorial for the skills repo despite its popularity (around 162k stars and 7.5M downloads).
• Common user questions addressed:
  • Recommended sequence of skills
  • How to install them
  • How to set them up for different agents/harnesses

Installation / setup (getting started)

The demonstration uses a work repo called AI Hero CLI (used in the speaker’s courses).

Installation command

Run:

npx skills@latest add mattpocock/skills

• Assumes Node.js is installed.
• npx runs the Vercel skills installer (skills.sh).

What the installer outputs

• It outputs a large list of skills (example shows 38 official/public-facing skills).
• Skills are grouped:
  • “Blessed” skills: recommended, public-facing
  • Other skills: experimental and may be removed later

Selection UI note

• There’s mention of an annoying/broken selection experience in the installer, but it can still select all official skills.

Agent compatibility

• Skills can be configured to work with multiple agent types (supports “universal” agent categories like Cursor/Codex/Claude, etc.).
• For agents that depend on skills explicitly (e.g., Claude Code), those agents require explicit setup.

Installation scope + linking

• Where skills are installed:
  • Project scope (recommended for teams for consistent shared skill sets)
  • Global scope (fine for solo dev)
• Recommends symlinking rather than copying into agent folders to make setup easier.

After install (example: Claude Code)

• Within Claude Code (specifically), skills appear as commands (e.g., “grill me”, “way finder”, “grill with docs”, etc.).
• Key design/feature point: skills are mostly user-invoked, so the speaker keeps context/token load low (example claims skills only occupy ~660 tokens in context).

Core workflow: “main flow” sequence

The speaker argues there’s a stable loop used for most work.

1) Run “set up Matt Pocock skills”

Inside the repo, run the setup skill.

What it does:

• Writes required repo configuration files (adds links in claw.md)
• Ensures an issue tracker mechanism exists for saving:
  • specs
  • tickets
• Supports integration choices like GitHub, local Markdown, or Jira/Linear/etc.
  • The speaker emphasizes that Jira/Linear can be enabled by telling the agent: “set it up with Jira/Linear” (and that it already supports them)
• Configures triage labels (defaults acceptable)
• Chooses documentation layout:
  • Single context (recommended for most repos)
  • Multi-context (for large monorepos with bounded contexts)

2) Use the “ask Matt” skill to learn the flow

• “Ask Matt” is described as the speaker-as-a-skill that explains how to proceed first.

3) Default idea-to-ship loop

3a) grill with docs

• An interview-style session to sharpen requirements and create shared understanding.
• Emphasis on managing LLM context length (“unbroken context window”).
• For repo-based tasks it’s stateful:
  • records learnings into context.md and ADRs
• Produces a crisp plan, even when started with a vague idea.

3b) Branch point (based on task size / context constraints)

• If it fits: go to implement directly.
• If it needs multiple sessions: go to to spec then to tickets.

4) Multi-session planning + execution

4a) to spec

• Compresses prior discussion into a reusable spec document.
• The spec becomes the “destination” for a multi-ticket sprint.
• Stores spec content into the issue tracker (example uses local markdown).
• Spec includes items like:
  • problem statement
  • solution approach
  • user stories
  • implementation decisions
  • testing decisions

4b) to tickets

• Converts the spec into tickets sized to fit within a single context window (“single smart zone”).
• Tickets become manageable sub-sessions.

Implementation strategy

• Implement tickets one by one, with context cleared between tickets (manual guidance).

5) implement + built-in code review and verification

• The implement skill runs verification steps and then a code review skill.
• Review includes checks such as:
  • Type checking
  • Build
  • Additional internal verification (e.g., “AI Hero internal help”, “shows only edit commits”)
  • Code review

How review is performed (two axes)

1. Compare the implementation against the original spec
   • Ensures acceptance criteria are satisfied and nothing was dropped.
2. Check against standards documentation
   • If none exist, it falls back to “classic” standards (mentions Martin Fowler)
   • Includes detecting code smells.

Key emphasis: context window management

• The workflow supports splitting work when the model would exceed a “smart zone” threshold.
• The speaker claims degradation/“halucination risk” rises above about ~140k tokens.
• Tickets are designed to match single context window execution units.

Evaluation of their approach (implicit review/comparison)

• The speaker states that doing review in sub-agents is important:
  • Main agents may “stop improving” because they already wrote the code.
  • Sub-agents have fresh context windows and can better critique edits/code quality.
• The example ends with:
  • Acceptance criteria matched spec
  • No issues found on standards/code smells
  • Changes committed to the current branch

“Cool extra” tip

• Pause and use one skill immediately: ask Matt
  • It can act like an interactive tutorial for first steps.

Main speakers / sources

• Matt Pocock (speaker and author of mattpocock/skills; referenced skills like “ask Matt”, “grill with docs”, etc.)
• Vercel skills installer (invoked via npx skills.sh)