# addyosmani/agent-skills for Claude Code: install and use

> addyosmani/agent-skills is a Claude Code plugin indexing 36 components: 24 skills, 8 commands and 4 agents that carry a software change from spec to ship. Use it when you want a spec, a plan, incremental builds, tests, a code review and a shipping checklist enforced at each stage rather than left to habit.

Canonical: https://www.flowy.sh/plugins/addy-sdlc-flow/guide
Published: 2026-10-29
Updated: 2026-10-29
Author: Flowy

## When does addyosmani/agent-skills pay off?

You are about to change something other people depend on: a payments path, an
auth flow, a public API. The easy move is to open the editor and start
typing. This plugin gets in the way of that on purpose. A spec has to exist
before code does. A plan has to exist before the spec turns into files. A
review has to happen before anything merges, and a checklist has to run
before anything ships.

That is the whole shape of addyosmani/agent-skills: 36 components, 24
skills, 8 commands and 4 agents, that turn one software change into a
sequence of gates instead of a single freehand session.

## What does addyosmani/agent-skills include?

The 8 commands are the entry points you type. Six of them line up with a
single pipeline, one command per stage: `spec` writes down what to build
before any code exists, `plan` breaks that spec into small ordered tasks,
`build` implements one slice at a time, `test` treats a passing test as
proof rather than a description, `review` runs a pass before merge, and
`ship` is the last gate before production.

The other 24 are skills: structured workflows with their own steps and
verification requirements, several of which the plugin's own author says
activate automatically once you are doing the kind of work they cover,
because Claude Code can match a skill's description to what you are asking
for. The 4 remaining components are agent personas, standing reviewers you
call in for a specific angle rather than a pipeline stage.

## Which two commands sit outside the spec-to-ship line?

`code-simplify` reduces complexity in code that already works, without
changing its behavior. `webperf` audits page performance and is the command
that drives the `web-performance-auditor` agent described below. Neither
sits in the spec-to-ship sequence; you reach for them when the code already
exists and either needs to get simpler or needs its performance checked.

## What do the four agent personas in addyosmani/agent-skills do?

Where the commands are pipeline stages, the agents are reviewers you bring
in for one angle at a time:

- `code-reviewer` reads as a senior staff engineer running a five-axis
  review.
- `test-engineer` reads as a QA specialist: test strategy and coverage
  gaps, asking a change to prove itself.
- `security-auditor` reads as a security engineer running vulnerability
  detection and an OWASP-style pass.
- `web-performance-auditor` reads as a web performance engineer, and is the
  persona behind the `webperf` command.

## Which of the 24 skills would you reach for directly?

Most of the skills back one of the six commands rather than standing alone,
but a few are worth knowing by name. `using-agent-skills` is the
meta-skill: it maps whatever you are doing to the right workflow, which
matters once you are choosing among two dozen of them. `interview-me` and
`idea-refine` turn a vague ask into something concrete before
`spec-driven-development` writes it down as a PRD.

On the build side, `test-driven-development`, `source-driven-development`
and `frontend-ui-engineering` cover red-green-refactor discipline,
grounding decisions in official documentation, and accessible interface
work. On the review side, `security-and-hardening` and
`performance-optimization` are measure-first passes rather than opinions
about the code. And on the ship side, `documentation-and-adrs` and
`shipping-and-launch` cover the parts that are easy to skip under deadline
pressure: writing down why a decision was made, and having a rollback plan
before you need one.

## When should you skip addyosmani/agent-skills?

If you want one skill, say `test-driven-development` on its own,
installing all 36 components to get it is more surface than you need. The
[the install card on the listing page](https://www.flowy.sh/listings/addy-sdlc-flow#install) shows what is available and
how much of it you would be pulling in.

And if your team already runs its own spec, review and release process,
the value here is narrower. This plugin is a written, repeatable version of
a discipline some teams already practice by habit. It is not a replacement
for a process that already works, and it will not tell you that your
existing one is wrong.

Sources: [addyosmani/agent-skills on GitHub](https://github.com/addyosmani/agent-skills), [addyosmani/agent-skills README](https://github.com/addyosmani/agent-skills#readme)

## Common questions

### What is addyosmani/agent-skills for in Claude Code?

It is a Claude Code plugin that indexes 36 components, 24 skills, 8 commands and 4 agents, built around a single software development lifecycle: writing a spec, planning the work, building it incrementally, testing it, reviewing it and shipping it. Reach for it when you want that sequence enforced rather than left to whichever step gets skipped under deadline pressure.

### What is the difference between the spec, plan and build commands?

`spec` writes down what you are building and why, before any code exists. `plan` takes that spec and breaks it into small, ordered, verifiable tasks. `build` then implements those tasks one slice at a time, with tests included in each slice rather than saved for the end.

### Does the code-simplify command change what the code does?

No. `code-simplify` is scoped to reducing complexity in code that already works correctly, so the behavior has to stay exactly the same before and after. It is a cleanup pass, not a rewrite, and it sits outside the six-stage spec-to-ship pipeline.

### What do the four agent personas add beyond the skills?

The skills are workflows tied to a stage of development. The four agents, `code-reviewer`, `test-engineer`, `security-auditor` and `web-performance-auditor`, are standing personas you call in for one specific angle, such as a security pass or a performance audit, independent of which stage of the pipeline you are actually in.

### How do I install addyosmani/agent-skills through Flowy?

Flowy indexes the plugin's real components so you can see what is inside before you install anything; it does not host or bundle the code itself. Use the install command on the listing's install card (flowy.sh/listings/addy-sdlc-flow#install), since that command is generated from the plugin's own current manifest rather than typed by hand here.

## Related

- [The listing page](https://www.flowy.sh/listings/addy-sdlc-flow): Install command, components and repository
- [Alternatives to this plugin](https://www.flowy.sh/alternatives/addy-sdlc-flow): Peers in its category, ranked by stars
- [The Claude Code plugin marketplace](https://www.flowy.sh/marketplace/plugins): How plugins install, and every plugin in the index
- [superpowers for Claude Code: what it does and how to install it](https://www.flowy.sh/plugins/superpowers-flow/guide): another plugin guide
- [mattpocock/skills for Claude Code: install and use](https://www.flowy.sh/plugins/matt-pocock-flow/guide): another plugin guide