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
| # | Skill | Stage | Best for | Last updated |
|---|---|---|---|---|
| 1 | To Spec | Plan | Capturing a design discussion as a spec | Aug 2026 |
| 2 | Domain Modeling | Plan | A shared vocabulary and decision records | Sep 2026 |
| 3 | TDD | Build | Test-first features and fixes | Oct 2026 |
| 4 | Improve Codebase Architecture | Review | Finding structural improvements | Oct 2026 |
| 5 | Code Review | Review | Checking standards and spec | Oct 2026 |
| 6 | Debugging and Error Recovery | Debug | A repeatable bug routine | Oct 2026 |
| 7 | Verification Before Completion | Verify | Stopping false "done" claims | Jul 2026 |
| 8 | API Design Reviewer | Review | REST API changes | Oct 2026 |
| 9 | Git Advanced Workflows | Ship | Clean history and recovery | Oct 2026 |
| 10 | Writing for Agents | Setup | AGENTS.md and skill writing | Aug 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.
- Spec: run To Spec after a design discussion.
- Language: use Domain Modeling when names are inconsistent.
- Build: write the tests first with TDD.
- Review: run Code Review on the branch.
- Verify: require Verification Before Completion before anyone calls it done.
- 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.
| Job | Options | Our advice |
|---|---|---|
| Test-first development | TDD or Test Driven Development | Pick one |
| Debugging | Debugging and Error Recovery, Systematic Debugging or Diagnosing Bugs | Pick one |
| Reviewing work | Code Review or Requesting Code Review | They 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.
Related guides
- 10 Claude workflows you can set up today: Ready-to-copy workflows for coding, research, documents and marketing.
- Claude Code subagents vs skills vs hooks vs plugins: What each extension point does and when to use it.
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.