Skip to content
Nerdy beta

Engineering Skills

Add to Space
 AI Engineering

A typical prompt evaporates when your conversation ends. A skill is a practice your agent picks up whenever the situation calls for it, without being asked.

Overview

A skill is a markdown file with a name, a description of when to use it, and a body of instructions. The description is the trigger. The body is the procedure. The agent scans the descriptions, loads only what the current task needs, and leaves the rest on disk. That last property is the whole trick: you can ship a hundred pages of hard-won engineering discipline without spending a hundred pages of context on every request.

Which makes a skill library a golden path for a coding agent. The paved road for “how we test,” “how we review,” “how we ship” is available, easier than improvising, and still optional when the situation is genuinely different.

Read the four libraries below as reference, not as a shopping list. Each one is somebody’s working agent directory made public, which is the most useful thing about them and also the limit of what they can do for you. Use them to see the format, to steal the failure modes they name, and to calibrate what “good” looks like. Then write the skills your own team needs. The catalog is the least valuable part of any of them.

All four use the same file shape. Each makes a different bet about where the discipline needs to live.

Superpowers

Jesse Vincent’s Superpowers bills itself as “a complete software development methodology for your coding agents.” Seventeen skills across testing, debugging, collaboration, and meta. Four stated principles: test-driven development, systematic over ad-hoc, complexity reduction, evidence over claims.

Superpowers is narrow on scope and deep on autonomy. The agent brainstorms before it writes anything, produces a written plan, then executes through subagents in isolated git worktrees with review cycles between phases. The bet is that a long autonomous run needs structure more than it needs breadth. Install it from the official marketplace:

/plugin install superpowers@claude-plugins-official

Matt Pocock’s skills

Matt Pocock’s collection is his personal agent directory, published: “My agent skills that I use every day to do real engineering - not vibe coding.” Twenty-four skills, split into engineering and productivity.

The signature primitive is grilling. grill-me and grill-with-docs interrogate your thinking before a line of code exists, and only then does to-spec turn the conversation into a spec, to-tickets cut it into tracer bullets, and implement drive TDD at seams you agreed on in advance. Pocock names the four failure modes he is targeting: misalignment between you and the agent, excessive verbosity, broken code, architectural decay. This is the strongest of the four at requirements, and it reads like a daily loop rather than a methodology.

claude plugins install mattpocock-skills

agent-skills

Addy Osmani’s agent-skills promises “production-grade skills for AI coding agents” and covers the widest surface: 24 skills mapped to lifecycle phases from Define through Ship. It is the only one of the four with real weight past the merge. security-and-hardening, performance-optimization, observability-and-instrumentation, deprecation-and-migration, documentation-and-adrs.

Two mechanisms stand out. Anti-rationalization tables name the excuses an agent reaches for when it wants to skip a step, so the dodge is written down before the agent tries it. And the repo ships its own eval harness, which means the skills are falsifiable rather than merely confident.

npx skills add addyosmani/agent-skills

pstack

pstack ships inside Cursor’s own plugin repository, which makes it the only first-party entry here. lauren, who works on Cursor and the React Compiler core team, calls it “the same skills i use everyday to ship high quality code at Cursor.” The operating principle: if you want to go fast, go deep first.

The architecture is the outlier. /poteto-mode is a sticky router. You turn it on when the task starts and it picks one of 22 playbooks for you, then dispatches to whatever else it needs. Underneath sit 44 skill directories, and 21 of them are principles rather than procedures: principle-fix-root-causes, principle-guard-the-context-window, principle-subtract-before-you-add, principle-never-block-on-the-human. The other three libraries bury their principles inside skill bodies. pstack makes each one a file the agent can load and cite, which is the difference between a value you claim and a value you can point at.

Two skills reach past the library. create-verification-skill and maintain-verification-skill author and update the skills that check the work, so the agent extends its own guardrails. That is the loop this whole page is arguing for, shipped as a skill. /unslop, /no-comments, and /interrogate are the tell that lauren has read a lot of generated code and did not enjoy it.

/add-plugin pstack

Read the comparison with one eye on the scoreboard

The most detailed head-to-head lives on Osmani’s own site, which is worth knowing before you treat it as neutral. It covers the first three and leaves pstack out, so read it as a snapshot rather than a survey. It is still the best map available, and it is honest about the axes that matter: core idea, organizing principle, catalog size, lifecycle coverage, distinctive mechanisms, quality measurement.

It also quietly demonstrates that catalog size is a garbage metric. The compare page counts Superpowers at roughly 14 skills and Pocock at roughly 30; those repositories say 17 and 24. pstack is worse: its README says 24 while its skills/ directory holds 44. Nobody is lying. Skills nest, some are model-invoked and some user-invoked, and the boundary between “one skill” and “three” is an authoring decision. Judge a library by whether it names the failure mode you actually have.

Then write your own

Here is what all four libraries really give you: proof that your team’s practices fit in a markdown file, and a format worth copying. What they cannot give you is the content. The deployment step that breaks when someone skips it. The test suite that flakes for a known reason. The review standard three senior engineers enforce and nobody wrote down. Every one of those is a skill nobody else can author for you, and every one of them is currently being rediscovered from scratch by whoever is on call.

Install one of them, work with it for a week, and pay attention to where it gets your codebase wrong. Those corrections are your first skill. That is compounding engineering with a file format: the tacit knowledge that used to leave with the person now stays in the repo, loads on demand, and gets sharper every time it is wrong.

A skill library you adopted without reading is just a mandate you didn’t agree to.

Resources