DEV Community

Hamza
Hamza

Posted on Originally published at tekmag.thsite.top

Addy Osmani's Agent Skills — Production-Grade Engineering Workflows for AI Coding Agents

#ai #github #addyosmani #promptengineering

Originally published at https://tekmag.thsite.top/addy-osmani-agent-skills-production-grade-engineering-workflows-for-ai-coding-agents/

Addy Osmani's Agent Skills is a free, MIT-licensed library of 25 production-grade engineering workflows that forces AI coding agents to do the senior-engineer work models skip by default: specs, tests, reviews, and evidence. The repo has crossed 97,000 GitHub stars, supports 70+ coding agents, and installs with one Command.

Most AI coding tools behave like a very fast junior developer. Ask for a feature and you get a feature, with no spec, no failing test written first, and no check that the change survives a review. Addy Osmani, a Google engineer on the Chrome team, spent a lot of time thinking about why that keeps happening, and the answer he published became one of the fastest-growing developer repositories of 2026.

I verified the data directly against the GitHub repository and cross-referenced it with Osmani's design notes on his blog. The numbers hold up: 97,449 stars, 10,278 forks, 25 skills in the repo, MIT license, latest release v0.6.10, and a live discussion on Hacker News with 376 points and 212 comments.

Key Takeaways

  • Agent Skills encodes six SDLC phases (spec, plan, build, test, review, ship) as 25 markdown workflows with concrete exit criteria, installed for 70+ coding agents.
  • Its most distinctive feature is the anti-rationalization table: pre-written rebuttals to the exact excuses agents use to skip specs, tests, and reviews.
  • The skills embed public Google engineering practices (Hyrum's Law, the test pyramid, ~100-line PR sizing) that frontier models have read but do not apply on their own.
  • Osmani's point: agents are capable junior engineers with no instinct for the parts of the job that don't show up in the diff, so the discipline has to be enforced rather than suggested.

What Agent Skills is and why it has 97k stars

Agent Skills is a library of markdown files, each one a workflow an AI coding agent can follow step by step. It sits between a system-prompt fragment and a runbook: a sequence of steps, checkpoints that produce evidence, and a defined exit criterion. Osmani's framing, from his own writeup, is that a 2,000-word essay on testing put into an agent's context gets read and summarized, while a workflow (write the failing test, run it, watch it fail, write the minimum code to pass) gives the model something to do and you something to verify.

The repo crossed 97,000 stars in the last week and sits in the top 150 globally on GitHub trending, per its star history. The format is portable: the same skill file works in Claude Code, Cursor, Gemini CLI, Codex, Windsurf, Cline, OpenCode, Kiro, and dozens more, which is why the project advertises 70+ agent support. That's the practical payoff of the markdown-with-frontmatter format. You write the workflow once and the runtime enforces it, instead of writing bespoke prompts per tool.

The six phases and seven slash commands

Twenty-four of the 25 skills organize around the standard software lifecycle, with a single meta-skill routing between them. A complex feature might activate eleven skills in sequence; a small bug fix might use three. The routing is the point: the workflow scales to the actual scope of the task, not to an assumed one.

Phase Command Representative skills
Define /spec spec-driven-development, interview-me, idea-refine
Plan /plan planning-and-task-breakdown
Build /build incremental-implementation, test-driven-development, doubt-driven-development
Verify /test debugging-and-error-recovery, browser-testing-with-devtools
Review /review Code-review-and-quality, security-and-hardening, performance-optimization
Ship /ship shipping-and-launch, observability-and-instrumentation

A cross-cutting /code-simplify command runs underneath all of it. This isn't new vocabulary. It's the same loop every healthy engineering organization runs, whether Google calls it design doc to review to launch checklist or Amazon calls it working-backwards memo. What's new is that most agents skip most of these phases by default, and the skills push them back in.

Anti-rationalization: the design decision doing the heavy lifting

Every skill ships with a table of common excuses paired with a written rebuttal. A few, close to the originals:

"This task is too simple to need a spec." The answer in the table: acceptance criteria still apply. Five lines is fine. Zero lines is not. "I'll write tests later." Later is the load-bearing word. There is no later. Write the failing test first. "Tests pass, ship it." Passing tests are evidence, not proof. Did you check the runtime? Did a human read the diff?

"LLMs are excellent at rationalization. Anti-rationalization tables are pre-written rebuttals to lies the agent hasn't told yet." That last line is close to verbatim from Osmani's writeup, and it's the part of the project worth stealing even if you never install a single skill. The same move works for human teams. Write down the excuses your team gives for skipping the boring steps, pair each with a rebuttal, and put the list somewhere the tired Friday-afternoon version of yourself will actually see it.

Google engineering practices, made portable

The skills are saturated with practices from Google's public engineering culture, and Osmani maps which practice lives in which skill. Hyrum's Law goes into the API design skill. The test pyramid and its ~80/15/5 ratio go into test-driven-development. PR sizing, roughly 100 lines with severity labels, goes into code review. Chesterton's Fence (don't remove a thing until you understand why it was put there) goes into code simplification. Trunk-based development, atomic commits, and shift-left CI practices fill out the rest.

None of these are new ideas. A frontier model has certainly read the phrase "Hyrum's Law" in its training data, and it does not apply Hyrum's Law when designing your API at 3am. Osmani's post on his blog makes the distinction the whole project is built on: the knowledge is in the weights, the discipline isn't. Skills are how the discipline gets enforced. If you're coming from the side of the vibe-coding debate we covered earlier, this is a concrete countermeasure: it doesn't ask the model to be careful, it removes the options that aren't careful.

Installing it: one command, or read it as a spec

For most agents, installation is a single command that pulls all 25 skills at once:

npx skills add addyosmani/agent-skills

You can also install a single skill, which is the path to try if the full set feels like too much:

npx skills add addyosmani/agent-skills --skill code-review-and-quality

Claude Code users have a marketplace path instead:

/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills

Osmani recommends a third mode that costs nothing: read the skills as documentation and steal the parts you need, even without installing anything. The "start with one workflow, prove it, then scale" rule is the same advice we gave when we wrote about OfficeCLI: wire one command into your loop before you automate the whole document pipeline. His suggested starting point here is the meta-skill, which carries five non-negotiables he would put in any team's agent rules tomorrow:

  • Surface assumptions before building. A wrong assumption held silently is the most common failure mode.
  • Stop and ask when requirements conflict. Don't guess.
  • Push back when warranted. The agent is not a yes-machine.
  • Prefer the boring, obvious solution. Cleverness is expensive.
  • Touch only what you're asked to touch.

If you use Claude Code or similar, start with the single-skill install and see which workflow you actually wanted; if you want to wire the full lifecycle into a new project, compare it against the patterns in our guide to using GitHub Copilot in 2026 and treat the five non-negotiables as the baseline your AGENTS.md should already have.

What the community is arguing about

The Hacker News thread thread that put the project in front of a large audience is skeptical in interesting ways. The top comment calls it snake oil: a stochastic model can drop any hard requirement you write in your rules, and the only reliable answer is human review, possibly two in a row. The strongest reply in the thread points out that "snake oil" never works at all, while a probabilistic harness works a meaningful percentage of the time, and that the value shows up when you already have a mental model of the code and the agent just executes it faster.

Both sides of that thread converge on the same conclusion: oversight stays with a human, and the tooling changes how much of the boring work the human has to do. The repo's 10,000+ forks and its position in GitHub's top 150 say a lot of people found the answer worth building on.

Conclusion

"Agent Skills is a blueprint for treating an LLM like a junior engineer: give it the workflow, the exit criteria, and the written rebuttals, and stop expecting it to improvise the discipline." The parts of the repo that will outlive any single tool are the anti-rationalization tables and the five non-negotiables. Both work for human teams, and both can be dropped into an AGENTS.md or an engineering wiki in an afternoon. The next 90 days will show which agent harnesses ship enforcement built in rather than as an add-on, and which keep treating skills as optional flavor text. Watch for teams publishing their own skill libraries the way they now publish style guides.

What are your thoughts? Share your opinion in the comments, and if the anti-rationalization table caught your attention, copy it into your team's docs and report back whether the excuses show up less.

{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "How do you install Addy Osmani's Agent Skills?",
"acceptedAnswer": {
"@type": "Answer",
"text": "For most coding agents, run npx skills add addyosmani/agent-skills to install all 25 skills, or add the --skill flag for a single one. Claude Code users can use the plugin marketplace instead: /plugin marketplace add addyosmani/agent-skills, then /plugin install agent-skills@addy-agent-skills."
}
},
{
"@type": "Question",
"name": "Is Agent Skills free?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Yes. The repository is MIT licensed, so you can install it, fork it, and adapt it for any use. You still pay for the underlying model calls your agent makes; the skills themselves add no cost."
}
},
{
"@type": "Question",
"name": "What makes Agent Skills different from a generic AI rules repo?",
"acceptedAnswer": {
"@type": "Answer",
"text": "The skills are workflows with checkpoints and exit criteria, not reference essays. The most distinctive piece is the anti-rationalization table in each skill, which pre-writes the rebuttal to the excuses an agent will try to use to skip the step. Essay-style rules get read and summarized by the model; workflow-style skills give it something to do and something to verify."
}
},
{
"@type": "Question",
"name": "Do the skills only work in Claude Code?",
"acceptedAnswer": {
"@type": "Answer",
"text": "No. The markdown-with-frontmatter format is portable, and the project lists support for 70+ agents, including Cursor, Gemini CLI, Codex, Windsurf, Cline, OpenCode, and Kiro. You can also read the skills as plain documentation and apply them without installing anything."
}
}
]
}

Frequently asked questions

How do you install Addy Osmani's Agent Skills?

For most coding agents, run npx skills add addyosmani/agent-skills to install all 25 skills, or add the --skill flag for a single one. Claude Code users can use the plugin marketplace instead: /plugin marketplace add addyosmani/agent-skills, then /plugin install agent-skills@addy-agent-skills.

Is Agent Skills free?

Yes. The repository is MIT licensed, so you can install it, fork it, and adapt it for any use. You still pay for the underlying model calls your agent makes; the skills themselves add no cost.

What makes Agent Skills different from a generic AI rules repo?

The skills are workflows with checkpoints and exit criteria, not reference essays. The most distinctive piece is the anti-rationalization table in each skill, which pre-writes the rebuttal to the excuses an agent will try to use to skip the step. Essay-style rules get read and summarized by the model; workflow-style skills give it something to do and something to verify.

Do the skills only work in Claude Code?

No. The markdown-with-frontmatter format is portable, and the project lists support for 70+ agents, including Cursor, Gemini CLI, Codex, Windsurf, Cline, OpenCode, and Kiro. You can also read the skills as plain documentation and apply them without installing anything.


References

Top comments (0)