Skills are reusable capability packs. Installed ones load automatically when a matching task comes up; recommended ones can be added with npx skills add. Each entry explains what the skill does and when to reach for it.
Download this guidebook as PDF ↓
Then vs Now
From ad-hoc prompts to reusable skillsThen
- Virtually no reusable agent skills.
- Every task started from a blank prompt.
- Tooling knowledge lived in scattered notes and memory.
- Even the REPI Tools Guide book had to be built by hand each time.
Now
- Matt Pocock’s engineering skills are installed and ready.
- Each skill carries a trigger, a workflow, and a stop condition.
- Work starts with the right skill instead of a blank prompt.
- The guidebook itself is kept in sync by the same skills.
Skills
Then virtually none, now many skillsSkills then, virtually none — now many skills
The environment now ships with a library of skills for planning, building, reviewing, teaching, and grilling designs. Reach for them by name or by intent.
Matt Pocock’s Skills
Main engineering skills installed in this environmentsetup-matt-pocock-skillsCore
Scaffolds the repo conventions the other engineering skills expect: issue tracker, triage label vocabulary, and domain-doc layout. Run once per repo.
planCore
Writes an implementation plan as a markdown file under .hermes/plans/. No execution — just a clear map before work starts.
wayfinderCore
Plans work too large for one agent session. Creates a shared map of decision tickets on the issue tracker and resolves them one at a time until the path is clear.
prototypeCore
Builds a throwaway prototype to answer a design question or explore what a UI should look like before committing to real code.
tddCore
Enforces red-green-refactor: tests before code. Use for features or bug fixes where test-first discipline matters.
code-reviewCore
Reviews changes since a commit or branch against repo standards and the originating spec, running both reviews in parallel.
implementCore
Implements a spec or set of tickets end-to-end. The workhorse skill for turning a plan into working code.
diagnosing-bugsCore
Structured diagnosis loop for hard bugs and performance regressions. Use when the cause is not obvious.
qaCore
Interactive QA session: report bugs conversationally and the agent explores the codebase, then files well-formed issues.
researchCore
Investigates a question against high-trust primary sources and captures the findings as a Markdown file in the repo.
grilling / grill-meCore
Relentlessly interviews you to stress-test a plan, decision, or design before you build on it.
teachCore
Teaches a new skill or concept within this workspace, with examples tied to your actual code.
handoffCore
Compacts the current conversation into a handoff document another agent can pick up and continue.
to-spec, to-tickets, to-questionnaireCore
Turn conversation into a spec, a set of tracer-bullet tickets, or a questionnaire for someone else to fill in.
domain-modeling & ubiquitous-languageCore
Builds a domain model and canonical glossary, flagging ambiguities and proposing terms the whole team can use.
codebase-design & design-an-interfaceCore
Shared vocabulary for deep modules and parallel exploration of interface shapes before choosing one.
request-refactor-planCore
Creates a detailed, tiny-commit refactor plan via interview, then files it as an issue. Use before large restructuring.
/teach-me
How to implement and use a skill- Load it. Say the skill name in chat, e.g.
/teach TDD, or callskill_view(name='tdd')to read its full instructions. - Match the trigger.Each skill opens with “Use when...” — wait for that situation, then invoke the skill by name.
- Follow the workflow. Skills are deterministic recipes. Let the skill ask its setup questions, confirm choices, then execute.
- Save learnings. If a skill taught you a stable workflow, ask the agent to save it as a new skill or patch the existing one.
Start small: pick one skill per week, use it for real work, and add the next only when the first feels automatic.