A fork of mattpocock/skills by Matt Pocock. I try my best to keep this repo in sync with Matt's upstream, so that every one of his skills is included here — most byte-for-byte identical, with a handful carrying my own edits (some functional, some only repo-wide Prettier formatting). This fork extends Matt's skills with:
- Framework scaffolding — React, Vue, and Angular component creation with a consistent two-phase scaffold + TDD loop
- Git & PR lifecycle — WIP commits, PR creation, PR review, and morning review-debt sweeps
- LittleBranches org — component scaffolding, quality-gate enforcement, and PR review workflows for the OSS Quality Standards
- Daily workflow — session wrapping, Asana sync, and standup orchestration
- Apprentice mentoring — issue auditing, learner-history tracking, and next-issue sequencing for a student or apprentice contributor
Before you install: I maintain this fork solo, use it daily, and write it with AI assistance. It is not a polished product — and some skills ship with shell scripts in an area where my own experience is limited. Please read Quality, Maintenance and Risk before relying on it.
npx skills@latest add AlexRebula/skillsThen run /setup-matt-pocock-skills once per repo to configure the issue tracker, domain docs, and triage labels.
Prefer a plug-and-play install you don't maintain by hand? These skills also ship as a native Claude Code plugin. Instead of copying editable files into your repo, the plugin installs the whole skill set as a managed bundle that updates when I ship a new version — you subscribe rather than fork.
Inside Claude Code:
/plugin marketplace add AlexRebula/skills
/plugin install alexrebula-skills@AlexRebula
Or from your shell:
claude plugin marketplace add AlexRebula/skills
claude plugin install alexrebula-skills@AlexRebulaThen run /setup-matt-pocock-skills once per repo, exactly as in the quickstart above.
Two ways to install, two philosophies:
- skills.sh copies the skills into your project so you can hack on them and make them your own.
- The plugin keeps them as a read-only, always-current bundle you don't edit — best when you just want my set to work and follow along as it evolves.
Using Codex or another agent? The skills.sh installer already installs these skills into Codex and other Agent-Skills-standard harnesses today. A native Codex plugin is on the roadmap — see
.agents/adr/0002-ship-as-a-claude-code-plugin.md.
I built these skills as a way to fix common failure modes I see with Claude Code, Codex, and other coding agents.
"No-one knows exactly what they want"
David Thomas & Andrew Hunt, The Pragmatic Programmer
The Problem. The most common failure mode in software development is misalignment. You think the dev knows what you want. Then you see what they've built - and you realize it didn't understand you at all.
This is just the same in the AI age. There is a communication gap between you and the agent. The fix for this is a grilling session - getting the agent to ask you detailed questions about what you're building.
The Fix is to use:
/grill-me- for non-code uses/grill-with-docs- same as/grill-me, but adds more goodies (see below)
These are my most popular skills. They help you align with the agent before you get started, and think deeply about the change you're making. Use them every time you want to make a change.
With a ubiquitous language, conversations among developers and expressions of the code are all derived from the same domain model.
Eric Evans, Domain-Driven-Design
The Problem: At the start of a project, devs and the people they're building the software for (the domain experts) are usually speaking different languages.
I felt the same tension with my agents. Agents are usually dropped into a project and asked to figure out the jargon as they go. So they use 20 words where 1 will do.
The Fix for this is a shared language. It's a document that helps agents decode the jargon used in the project.
Example
Here's an example CONTEXT.md, from my course-video-manager repo. Which one is easier to read?
- BEFORE: "There's a problem when a lesson inside a section of a course is made 'real' (i.e. given a spot in the file system)"
- AFTER: "There's a problem with the materialization cascade"
This concision pays off session after session.
This is built into /grill-with-docs. It's a grilling session, but that helps you build a shared language with the AI, and document hard-to-explain decisions in ADR's.
It's hard to explain how powerful this is. It might be the single coolest technique in this repo. Try it, and see.
Tip
A shared language has many other benefits than reducing verbosity:
- Variables, functions and files are named consistently, using the shared language
- As a result, the codebase is easier to navigate for the agent
- The agent also spends fewer tokens on thinking, because it has access to a more concise language
"Always take small, deliberate steps. The rate of feedback is your speed limit. Never take on a task that’s too big."
David Thomas & Andrew Hunt, The Pragmatic Programmer
The Problem: Let's say that you and the agent are aligned on what to build. What happens when the agent still produces crap?
It's time to look at your feedback loops. Without feedback on how the code it produces actually runs, the agent will be flying blind.
The Fix: You need the usual tranche of feedback loops: static types, browser access, and automated tests.
For automated tests, a red-green-refactor loop is critical. This is where the agent writes a failing test first, then fixes the test. This helps give the agent a consistent level of feedback that results in far better code.
I've built a /tdd skill you can slot into any project. It encourages red-green-refactor and gives the agent plenty of guidance on what makes good and bad tests.
For debugging, I've also built a /diagnosing-bugs skill that wraps best debugging practices into a simple loop.
"Invest in the design of the system every day."
Kent Beck, Extreme Programming Explained
"The best modules are deep. They allow a lot of functionality to be accessed through a simple interface."
John Ousterhout, A Philosophy Of Software Design
The Problem: Most apps built with agents are complex and hard to change. Because agents can radically speed up coding, they also accelerate software entropy. Codebases get more complex at an unprecedented rate.
The Fix for this is a radical new approach to AI-powered development: caring about the design of the code.
This is built in to every layer of these skills:
/to-specquizzes you about which modules you're touching before creating a spec
And crucially, /improve-codebase-architecture helps you rescue a codebase that has become a ball of mud. I recommend running it on your codebase once every few days.
Software engineering fundamentals matter more than ever. These skills are my best effort at condensing these fundamentals into repeatable practices, to help you ship the best apps of your career. Enjoy.
These split on one axis — who can invoke them. User-invoked skills are reachable only when you type them (e.g. /grill-me); their job is to orchestrate. Model-invoked skills can be invoked by you or reached for automatically by the agent when the task fits; they hold the reusable discipline. A user-invoked skill may invoke model-invoked skills, but never another user-invoked one.
Skills I use daily for code work.
User-invoked
- ask-matt — Ask which skill or flow fits your situation. A router over the whole skill set in this repo.
- grill-with-docs — Grilling session that also builds your project's domain model, sharpening terminology and updating
CONTEXT.mdand ADRs inline. - triage — Move issues — and, where configured, external PRs — through a state machine of triage roles: categorise, verify, grill if needed, write agent-ready briefs.
- improve-codebase-architecture — Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.
- setup-matt-pocock-skills — Configure this repo for the engineering skills (issue tracker, triage labels, domain doc layout). Run once per repo before using the other engineering skills.
- start-issue — Bootstrap a session from a GitHub issue number: reads the issue, checks blockers, loads codebase context, and routes to
/tddor/grill-mebased on the triage label. - sync — Bidirectional sync between configured Asana projects and their local markdown files. Pulls new/updated tasks, pushes local changes, resolves conflicts (local wins).
- to-spec — Turn the current conversation into a spec and publish it to the issue tracker. No interview — just synthesizes what you've already discussed.
- to-tickets — Break any plan, spec, or conversation into a set of tracer-bullet tickets, each declaring its blocking edges — written as text in a local file, or as native blocking links on a real tracker.
- implement — Build the work described by a spec or set of tickets, driving
/tddat pre-agreed seams and closing out with/code-reviewbefore committing. - wayfinder — Plan a huge chunk of work, more than one agent session can hold, as a shared map of investigation tickets on the issue tracker — resolve them one at a time until the way to the destination is clear.
Model-invoked
- prototype — Build a throwaway prototype to answer a design question — a runnable terminal app for state/logic questions, or several radically different UI variations toggleable from one route.
- diagnosing-bugs — Disciplined diagnosis loop for hard bugs and performance regressions: reproduce → minimise → hypothesise → instrument → fix → regression-test.
- research — Investigate a question against high-trust primary sources and capture the findings as a cited Markdown file in the repo, run as a background agent.
- tdd — Test-driven development with a red-green-refactor loop. Builds features or fixes bugs one vertical slice at a time.
- domain-modeling — Actively build and sharpen a project's domain model — challenge terms against the glossary, stress-test with edge-case scenarios, and update
CONTEXT.mdand ADRs inline. - codebase-design — Shared discipline and vocabulary for designing deep modules: a lot of behaviour behind a small interface, placed at a clean seam, testable through that interface.
- code-review — Two-axis review of the diff since a fixed point: Standards (does it follow the repo's coding standards, plus a Fowler smell baseline?) and Spec (does it faithfully implement the originating issue/PRD?), run as parallel sub-agents so neither pollutes the other.
- resolving-merge-conflicts — Work through an in-progress git merge or rebase conflict hunk by hunk, resolving by intent traced to each side's primary source, then finish the operation — never
--abort.
Framework-specific scaffolding. Each skill follows a consistent two-phase workflow: scaffold first (types, test stubs, README), then implement (TDD vertical slices).
- create-angular-component — Scaffold and TDD a new Angular 17+ standalone component. Uses signal-based inputs/outputs and Angular Testing Library.
- create-react-component — Scaffold and TDD a new React component from scratch. Framework-agnostic — no MUI dependency.
- create-vue-component — Scaffold and TDD a new Vue 3 single-file component. Uses Composition API with
<script setup>,definePropsgenerics, and@testing-library/vue.
Skills for the full git and PR lifecycle — from discovering what needs committing to sweeping review debt across all repos.
- commit-wip — Scan all workspace repos for uncommitted changes, group files by topic, match each group to an existing remote branch (or create a categorised new one), and commit there.
- create-pr — Verify branch hygiene, run the quality gate, and open a PR with a complete description via
gh pr create. Optionally triggers a review bot. - morning-pr-sweep — Clear all open PR review debt across your repos in one session. Triages all threads before touching any code, batches fixes into one commit per PR, and reports which PRs are merge-ready.
- open-pr-sweep — Discover all non-draft open PRs across one or more GitHub orgs or users. Pure discovery — no writes.
- query-issues — Query GitHub issues for a repo filtered by one or more labels (AND logic) and print a formatted list in chat. Pure discovery — no writes. Run at session start to find pending cross-repo work.
- repo-status — Discover all workspace repos dynamically and produce a dirty-state table (repo, branch, dirty file count, clean/uncommitted status).
- respond-pr-review — Respond to an existing Copilot PR review in any repo: gather every thread, reply inline before fixing, batch valid fixes into one commit, and post SHA follow-ups.
- review-pr — Review an open GitHub PR on two axes — Standards (does the code follow the repo's own conventions?) and Spec (does it match the originating issue/PRD?). Posts findings via the GitHub PR Reviews API with inline line comments.
- sync-branches — Resolve each repo's default branch (main, master, or other), fetch latest, flag already-merged branches, pull each stale branch from origin, then merge the default branch into every active branch. Works on one repo or many.
- wip-sweep — Scope selection + tiered WIP commit/push/PR model (T1 scope → T2 local commit → T3 push → T4 draft PRs) with confirmation gates at each tier.
Skills specific to the LittleBranches organisation and its OSS Quality Standards. These skills require access to the LittleBranches AGENTS.md barrels.
- audit-giselle-tests — Audit existing AI-generated tests in
giselle-muifor quality problems: placeholder stubs, MUI-mock anti-patterns, and missing required test cases. - create-giselle-component — Scaffold and TDD a new
giselle-muicomponent following OSS Quality Standards rules — two-phase: scaffold (types, test stubs, README), then implement (TDD vertical slices with real ThemeProvider). - load-dependency-chain — Read the
dependency-chain.mdfile and extract the hard deadline, critical path, and phase status for each active repo. - load-oss-standards — Verify access to the public and private LittleBranches AGENTS.md barrels and print a session health-check table.
- respond-giselle-pr-review — Respond to an existing Copilot PR review in a LittleBranches repo: pre-load AGENTS.md + workflow rules, triage every thread, reply inline before fixing, batch valid fixes, and post SHA follow-ups.
- sync-roadmap — Pull current task statuses from Asana and write them back into each repo's
docs/roadmap.mdanddata.tsxdoneflags. Asana is the master; this skill flows changes downstream.
General workflow tools, not code-specific.
User-invoked
- grill-me — Get relentlessly interviewed about a plan or design until every branch of the decision tree is resolved.
- handoff — Compact the current conversation into a handoff document so another agent can continue the work.
- teach — Teach the user a new skill or concept over multiple sessions, using the current directory as a stateful teaching workspace.
- writing-great-skills — Reference for writing and editing skills well: the vocabulary and principles that make a skill predictable.
Model-invoked
- grilling — Interview the user relentlessly about a plan, decision, or idea until every branch of the decision tree is resolved. The reusable loop behind
grill-meandgrill-with-docs.
AlexRebula extensions (not in upstream)
- capture — Capture a freeform thought, task, or note mid-session — routes it to the correct content project, creates a real Asana task, writes a local markdown file, and commits it.
- sync — Bidirectional Asana ↔ local markdown sync: pulls new/updated tasks from Asana, pushes local changes, resolves conflicts (local wins), and commits.
- asana-sync — Opt-in Asana sync for morning briefs: locate or bootstrap
.asana-config.json, create the Morning Briefs section if missing, seed tasks with full metadata, post a Status Update, and log results back to the brief file. - check-prior-work — Scans context for a
<conversation-summary>block and extracts earlier session work for continuity. - ingest — Ingest a raw source file into the personal wiki — reads the source, extracts metadata, writes a wiki/sources/ synthesis page, updates related wiki pages, and updates wiki/index.md and wiki/log.md. Add --deep to also write a long-form deep dive at wiki/deep/-deep.md.
- extract-vocabulary — Companion to
/ingest: pull jargon out of an already-ingested source and file each term into its own vocabulary file under the owning concept's folder (ELI5/junior-dev level), cross-linked from the concept page, a flat A–Z barrel index, and the source page. Opt-in — run manually on jargon-heavy sources, not every ingest. - load-session-context — Load the session index and latest wrap file; check for an existing morning brief for today.
- collapse-session-folder — Collapse all same-day session wrap folders into one combined folder. Repairs → Next footer links and updates sessions-index.md. Called automatically by /session-wrap.
- resolve-ai-paths — Resolve
SESSIONS_ROOT,PROMPTS_ROOT,MORNING_BRIEFS_ROOT, andSKILLS_ROOTfor AI workflow skills. Call this at the start of any skill that reads/writes the sessions, morning-briefs, prompts, or skills-repo folders. - query — Answer a question using the personal wiki — reads the index, drills into relevant pages, synthesises an answer with citations, and optionally files the answer as a new wiki page.
- session-wrap — Write a session wrap doc, update the session index, and hand off to
/wip-sweep. More powerful sibling of/handoff. Use at context >55% or after completing major work. - standup-prep — Daily session startup coordinator. Runs preflight → session context → repo status + WIP sweep → open PR sweep → morning brief → file write → Asana sync.
- standup-prep-preflight — Composite pre-flight: runs
/check-prior-work,/load-oss-standards, and/load-dependency-chainin sequence. - wiki-lint — Health-check the personal wiki — scans for contradictions, orphan pages, stale claims, missing cross-references, and data gaps. Produces a prioritised finding list and suggests next ingests.
- learner-history — Build a factual, source-verified history of a learner's GitHub issue work across an org. Call this before
/audit-issueor/next-issueto establish what concepts the learner has already encountered and at what quality. - audit-issue — Audit a GitHub issue body against a principles index and draft fixes for approval before touching GitHub. Paste the issue body and your principles directly in chat — no
ghCLI or file paths required. The lower-level primitive that/next-issuewraps with automatic issue fetching. - log-incident — Log an AI behavioural incident or workflow violation to the wiki's incidents hub. Drafts the structured record from the current conversation, gets approval, then writes the file, updates the index, and opens a PR. No Asana involved.
- next-issue — Identify, audit, and prepare the next GitHub issue for a student or apprentice. GitHub-integrated wrapper around
/audit-issuethat adds automatic issue fetching, principles file discovery, and learner progression checks via/learner-history. - rebuild-root-index — Rescan every git repo under
$AR_ROOTand refresh the master barrel index. Diffs against a content-hash manifest so only new/changed/deleted files are re-summarized. Chained from/ingestor run standalone. - load-session-guidelines — Load all session guidelines in one go: Karpathy coding rules, OSS quality standards, and PR/branch conventions. Run at the start of every session before any user task.
- extract-session-worktree — Split one session's uncommitted changes out of a working directory shared by multiple concurrent sessions, into its own isolated git worktree and branch, without touching any other session's pending work.
Tools kept around but rarely used.
- git-guardrails-claude-code — Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, etc.) before they execute.
- karpathy-guidelines — Behavioral guardrails for LLM coding: think before coding, keep changes surgical, and drive work by verifiable success criteria.
- migrate-to-shoehorn — Migrate test files from
astype assertions to @total-typescript/shoehorn. - scaffold-exercises — Create exercise directory structures with sections, problems, solutions, and explainers.
- setup-pre-commit — Set up Husky pre-commit hooks with lint-staged, Prettier, type checking, and tests.
Skills tied to my own setup — not promoted in the plugin, since they assume my own tools and data layout.
- anonimise — Anonymise sensitive personal data in wiki files using
{{SCREAMING_SNAKE_CASE}}placeholders, with real values stored locally in a gitignored vault file. Also resolves placeholders back for local-context work. - caveman — Ultra-compressed communication mode. Cuts token usage ~75% by dropping filler while keeping full technical accuracy.
- edit-article — Edit and improve articles by restructuring sections, improving clarity, and tightening prose.
- obsidian-vault — Search, create, and manage notes in an Obsidian vault with wikilinks and index notes.
Read this before you rely on this repo.
I maintain this fork myself, daily, alongside my own work — it is not a polished product with a dedicated QA process. I use these skills every day on real projects, which is the main quality signal I can offer: if something were badly broken, I'd have hit it myself by now. I want to be upfront about the gaps rather than let you find them the hard way.
Some skills ship with accompanying shell scripts. Shell is not my strongest area — I have far less experience writing and reviewing it than the TypeScript/React work I do daily. That means some scripts here are probably not written the way an experienced shell engineer would write them. I review everything I merge, including with AI-assisted testing and static analysis, but I can't personally vouch for shell the way I can for code in a language I know deeply.
I use AI to write and audit these skills. I review every change to the best of my ability and available time, but mistakes or AI-generated "slop" can still creep in. Use this repo at your own risk. What I can tell you honestly is that I run these skills myself, every day — I can't promise perfection.
Why this fork exists in the first place: I wanted to keep building on Matt Pocock's original skills without being blocked on whether or when upstream adds something I need. This repo is where every skill I actually use daily lives, and it doubles as a place for me to try different LLMs and learn more about how agentic coding tools work. Because of that, skills and scripts here are expected to keep evolving — this is a living workspace I use, not a finished library.
I try to track upstream, syncing from mattpocock/skills regularly and keeping the original skills unchanged where I can. As this fork diverges further, staying in sync gets harder, and I'd rather say that plainly than let it go unstated.
When I hit something outside my experience — like a shell script that needs more scrutiny than I can personally give it — I try to flag it honestly rather than quietly ship it, in line with the OSS Quality Standards I hold myself to elsewhere.
If I've missed something, please open an issue — I'd rather know.
The original mattpocock/skills covers the core engineering philosophy: grilling sessions to align with the agent before writing a line of code, TDD loops for consistent feedback, architecture reviews to prevent entropy. For the full motivation and background, see mattpocock/skills.