$ skilldirectory
— zsh — registry.skilldirectory.dev
skill libraryblogguidesabout

home / blog / coding

10 Developer Agent Skills That Can Improve Your Coding Workflow (2026)

Quick answer: The developer skills gaining the most traction cover the loop of spec, test, review and verify.

Our ten are To Spec, Domain Modeling, TDD, Improve Codebase Architecture, Code Review, Debugging and Error Recovery, Verification Before Completion, API Design Reviewer, Git Advanced Workflows and Writing for Agents.

Reusable skills for test-driven development, architecture reviews, code quality and engineering workflows are spreading fast. They give an AI coding agent the same habits a careful engineer follows, so you stop re-explaining them in every session.

This list picks ten that cover the whole development loop, all free and MIT-licensed. Each one works as a SKILL.md folder, so you can use it in Claude Code, Codex or Cursor.

Why these skills are gaining traction

Two repositories dominate developer skills. Matt Pocock's skills collection was created on February 3, 2026 and has about 319,000 GitHub stars. Obra's Superpowers, created in October 2025, has about 315,000.

The install counts tell a similar story. On November 6, 2026, 13 of the 30 most-installed skills on the skills.sh leaderboard came from Matt Pocock's repository.

  • TDD: about 1.2 million installs.
  • Improve Codebase Architecture: about 1.2 million.
  • Domain Modeling: about 940,000.
  • Code Review: about 855,000.
  • To Spec: about 772,000.
  • Writing for Agents: about 523,000.

Treat these as directional. Install counts are anonymous telemetry, and the leaderboard also contains copycat entries, so popularity is not proof of quality.

The 10 developer agent skills at a glance

#SkillStageBest forLast updated
1To SpecPlanCapturing a design discussion as a specAug 2026
2Domain ModelingPlanA shared vocabulary and decision recordsSep 2026
3TDDBuildTest-first features and fixesOct 2026
4Improve Codebase ArchitectureReviewFinding structural improvementsOct 2026
5Code ReviewReviewChecking standards and specOct 2026
6Debugging and Error RecoveryDebugA repeatable bug routineOct 2026
7Verification Before CompletionVerifyStopping false "done" claimsJul 2026
8API Design ReviewerReviewREST API changesOct 2026
9Git Advanced WorkflowsShipClean history and recoveryOct 2026
10Writing for AgentsSetupAGENTS.md and skill writingAug 2026

How we picked these skills

We started from the coding, testing and project-management skills in the SkillDirectory catalog and chose one for each stage of the loop. We left out the skills in our best Claude Code skills list, so the two articles do not overlap.

  • Workflow fit: it covers a real stage of day-to-day development.
  • Licence: MIT, so you can reuse it with attribution.
  • Upkeep: updated in 2026, and not abandoned.
  • Clear method: it says what to do, not just what to value.

We have not run every skill. The ranking reflects each skill's published description, licence and upkeep, not a benchmark.

The 10 developer agent skills

1. To Spec

Best for: turning a design conversation into a written spec.

It turns the current conversation into a spec and publishes it to your project's issue tracker. The spec covers the problem, the solution, user stories, implementation decisions and testing decisions, and it synthesises what you discussed instead of interviewing you.

Why it made the list: a written spec gives an agent a clear definition of done before it writes code.

Heads-up: gaps in the conversation become gaps in the spec, and it publishes to your tracker, so confirm the target first.

Details: MIT license · 9 commits in the last six months · skill page · source repository

2. Domain Modeling

Best for: projects where names drift between the code, the docs and conversations.

It helps you build a domain model by challenging your terms against a glossary, sharpening fuzzy language, testing ideas against concrete scenarios and cross-referencing the code. It also records decisions as architecture decision records.

Why it made the list: a shared vocabulary cuts the misunderstandings that lead agents to build the wrong thing.

Heads-up: it writes files such as a glossary into your repo, and the result reflects your answers.

Details: MIT license · 8 commits in the last six months · skill page · source repository

3. TDD

Best for: building features or fixing bugs test-first.

It explains what a good test looks like, where tests belong (which it calls seams), common anti-patterns and the rules of the red-green-refactor loop. It also suits integration tests.

Why it made the list: it is one of the most-installed developer skills, and it is actively maintained, with 13 commits in six months.

Heads-up: it overlaps with the Test Driven Development skill from Superpowers, so choose one as your default.

Details: MIT license · 13 commits in the last six months · skill page · source repository

4. Improve Codebase Architecture

Best for: architecture reviews that you would otherwise never schedule.

It scans a codebase for places where modules could be deeper, presents the candidates in a visual HTML report, then walks you through whichever one you choose in a questioning loop.

Why it made the list: it turns an architecture review into a routine you can repeat, and it keeps you in the decision.

Heads-up: it proposes and discusses changes instead of rewriting code, and it needs a codebase with real structure to analyse.

Details: MIT license · 12 commits in the last six months · skill page · source repository

5. Code Review

Best for: reviewing a branch against your standards and the original request.

It reviews everything since a fixed point, such as a commit, branch, tag or merge-base, along two axes. One asks whether the code follows your documented coding standards, and the other asks whether it matches the issue or spec it came from.

Why it made the list: most reviews check only one of those two questions.

Heads-up: it needs documented standards and a spec to compare against, and it uses sub-agents, so your agent must support them.

Details: MIT license · 13 commits in the last six months · skill page · source repository

6. Debugging and Error Recovery

Best for: a team-wide routine for failing tests and broken builds.

It starts with a stop-the-line rule and a triage checklist, then works through four steps: reproduce the problem, localise it, reduce it and fix the root cause.

Why it made the list: it gives an agent a fixed order of work, so it reproduces a bug before it patches anything.

Heads-up: it slows the first minutes on purpose, and it overlaps with Systematic Debugging, so pick one routine.

Details: MIT license · 3 commits in the last six months · skill page · source repository

7. Verification Before Completion

Best for: stopping an agent from saying "done" without proof.

It requires the agent to run verification commands and confirm their output before it claims work is complete, fixed or passing. It includes a gate function, a list of common failures and rationalisations to watch for.

Why it made the list: false success reports are one of the most costly agent habits, and this fixes them cheaply.

Heads-up: it only works if checks exist, so you need tests or commands to run, and it was last updated in July 2026.

Details: MIT license · 1 commit in the last six months · skill page · source repository

8. API Design Reviewer

Best for: pull requests that add or change REST endpoints.

It lints API conventions, detects breaking changes and scores the design, using bundled scripts for each job. That gives reviews a consistent scorecard instead of a matter of taste.

Why it made the list: breaking API changes are easy to miss in a normal review.

Heads-up: the scores are heuristics tuned to its own conventions, and the scripts need Python.

Details: MIT license · 6 commits in the last six months · skill page · source repository

9. Git Advanced Workflows

Best for: cleaning up a branch or recovering from a mistake.

It is a reference for interactive rebase, cherry-picking, bisect, worktrees and reflog, the techniques that rescue messy histories.

Why it made the list: these are the commands people forget, and an agent can run them carefully with a guide.

Heads-up: rebase and reset rewrite history, so use them only on branches you have not shared, and make a backup branch first.

Details: MIT license · 2 commits in the last six months · skill page · source repository

10. Writing for Agents

Best for: writing the instructions every other skill depends on.

It gives guidance on the documents agents read: skills, AGENTS.md and CLAUDE.md. It covers context pointers, information hierarchy, completion criteria, when to split a file and leading words.

Why it made the list: a skill is only as good as its instructions, and this improves yours.

Heads-up: the style is opinionated, so adapt it to your team and test after you rewrite a long instruction file.

Details: MIT license · 4 commits in the last six months · skill page · source repository

How the skills fit together

These skills work best when they follow the order of the work. This sequence is our suggestion, not part of any one skill.

  1. Spec: run To Spec after a design discussion.
  2. Language: use Domain Modeling when names are inconsistent.
  3. Build: write the tests first with TDD.
  4. Review: run Code Review on the branch.
  5. Verify: require Verification Before Completion before anyone calls it done.
  6. Ship: use Git Advanced Workflows to keep history clean.

Run Improve Codebase Architecture every few weeks, and use Writing for Agents whenever your instructions get long.

Where these skills overlap

Several skills solve the same problem, and installing two of them can give your agent conflicting advice.

JobOptionsOur advice
Test-first developmentTDD or Test Driven DevelopmentPick one
DebuggingDebugging and Error Recovery, Systematic Debugging or Diagnosing BugsPick one
Reviewing workCode Review or Requesting Code ReviewThey differ: one reviews, one asks for a review

Honorable mentions

These skills just missed the list.

  • Triage: moves issues and outside pull requests through triage roles.
  • Retro: runs a retrospective on a coding session.
  • Writing Plans: turns a spec into a plan before any code is touched.

For the Superpowers set, see our best Claude Code skills.

Do not install all ten

Each installed skill adds a small amount of text for your agent to read, and overlapping skills can compete. Start with three that fix a problem you actually have.

  • Tests are weak: TDD and Verification Before Completion.
  • Reviews are shallow: Code Review and API Design Reviewer.
  • Requirements are vague: To Spec and Domain Modeling.

Add the others one at a time. For setup steps, see how to install an agent skill and how to use Claude skills.

Use them in other agents

Every skill here is a standard SKILL.md folder. Codex and Cursor read the same format, so the same skills can work across tools.

Read our guides to Codex skills and Cursor skills, and test each skill in the tool you use. Browse more in the Coding category and the Testing & QA category.

Review skills before you install them

A skill is instructions, and sometimes code. Read it first, check the licence and try it on a throwaway project.

Our safety checklist lists what to look for. For security-focused work, see how to use AI agent skills for automated security audits.

Frequently asked questions

What are developer agent skills?

They are reusable instruction folders that teach a coding agent a repeatable engineering habit. Examples include writing tests first, reviewing a branch against a spec and verifying work before claiming it is done.

Which skill should I start with for TDD?

Start with TDD or Test Driven Development, but not both. Both teach red-green-refactor, so pick the one whose style you prefer.

Do these skills work in Codex and Cursor?

They use the standard SKILL.md format that Codex and Cursor read. Test each skill in your own tool, because supported scripts and settings can differ.

Are these skills free?

Yes. All ten are MIT-licensed, so you can reuse them with attribution. You still pay for the model usage they consume.

How many skills should I install?

Start with three, and add more one at a time. Too many overlapping skills can confuse an agent and use extra context.

Methodology and disclosure

Skill details come from the SkillDirectory catalog and each skill's published description. Repository stars come from the GitHub API on November 9, 2026, and install counts from the skills.sh leaderboard on November 6, 2026.

Install counts are telemetry and can be inflated. We have not run every skill, we have no affiliation with the projects, and this article contains no affiliate links.