You give an intern a task: "implement this feature." They can write code, but they don't know: write a spec first, break implementation into small slices, test each slice, run a thorough review before merging, check performance before shipping. These aren't "coding ability" — they're "engineering process." The difference between a senior engineer and an intern often lies not in intelligence, but in workflow.
AI coding agents today are like a smart intern: they can write code, but not "engineering-grade" code. They'll write an entire feature in one go, skip tests, skip review, and push straight to main.
addyosmani/agent-skills, which hit GitHub trending this week, does exactly this: encoding senior engineers' workflows into skills that AI agents can follow.
8 slash commands covering the full development lifecycle
The core of agent-skills is 8 slash commands, each mapping to a stage of the software development lifecycle:
| Command | Stage | Core principle |
|---------|-------|----------------|
| /spec | Define | Spec before code |
| /plan | Plan | Small, atomic tasks |
| /build | Implement | One slice at a time |
| /test | Verify | Tests are proof |
| /review | Review | Improve code health |
| /webperf | Performance | Measure before you optimize |
| /code-simplify | Simplify | Clarity over cleverness |
| /ship | Ship | Faster is safer |
Behind these 8 commands are 24 skills, each a Markdown file describing what to do at a given stage, what not to do, and how to judge whether it was done well.
Key design: automatic skill activation
agent-skills doesn't require users to manually invoke 24 skills. The design: you type a slash command, and the system automatically activates the relevant skills.
For example, typing /build automatically activates:
- test-driven-development
- code-review-and-quality
- api-and-interface-design (if API code is detected)
- frontend-ui-engineering (if UI code is detected)
- Skip the spec and start coding
- Write the entire feature in one go, no slicing
- Skip tests
- Skip review
- Push directly
- obra/superpowers: Shell scripts, an "agentic skills framework & software development methodology" — more methodology-oriented
- addyosmani/agent-skills: JavaScript/Markdown, "production-grade engineering skills" — more practical, with explicit slash-command mapping
- cloudflare/computer: gives agents a computer (state layer)
- huangruiteng/loopx: gives agents a scheduling hub (control layer)
- addyosmani/agent-skills: gives agents an operations manual (skills layer)
This differs from obra/superpowers. superpowers is a "framework + methodology" — heavier, requiring wholesale adoption. agent-skills is a set of "slash commands + skill files" — lighter, adoptable one by one. You don't need to buy into the whole methodology; just pick the stage you're missing.
/build auto: automatic planning + implementation
The most interesting feature is /build auto. Give it a spec, and it:
1. Automatically generates an implementation plan (splitting the spec into small, atomic tasks)
2. Implements each task one by one
3. Tests each task with TDD
4. Commits each task separately
5. Pauses on failures or risky steps
The key design: **it removes human intervention *between* tasks, not verification. The problem with traditional agent workflows: humans must confirm after every task, so once they step away, the agent stops. /build auto lets you approve a plan once, then the agent runs autonomously — but every task is still verified by tests, and it still pauses on failure.
This is the same direction as the ACE RPI workflow we covered earlier: upgrading humans from "step-by-step confirmation" to "one-time approval + automatic verification". The granularity moves from "each task" to "the entire plan."
Why this matters
The core insight of agent-skills: the problem with AI agents isn't "not smart enough" — it's "no process."
A GPT-4-class model told to "implement this feature" directly will:
Not because it can't write tests or do review, but because nobody told it "this is the step to do now." That's exactly what agent-skills does: encoding "what to do now" into executable instructions**.
This mirrors how human engineers grow. An intern isn't lacking IQ — nobody told them "write a spec before code." Once given a process checklist, an intern's output quality jumps a tier. The same goes for agents.
Addy Osmani's background
The author is Addy Osmani, an engineering leader on Google's Chrome team, author of books like *Image Optimization* and *Learning Web Performance*, and a well-known expert in web performance optimization.
This background matters. The /webperf command ("Measure before you optimize") is the crystallization of decades of engineering experience — not "teaching agents how to measure performance," but "teaching agents to measure before optimizing." The principle applies to human engineers too, but agents especially need it, because LLMs naturally tend to "give answers directly" rather than "measure first."
vs. obra/superpowers
Yesterday we covered obra/superpowers; today it's addyosmani/agent-skills. The two projects overlap conceptually — both "give AI agents engineering skills" — but take different angles:
Both reflect the same trend: agent engineering is shifting from "making agents smarter" to "giving agents better processes". This trend is independent of model-layer progress — whether GPT-5 or Claude 4, processes are still needed.
The bigger picture
Connecting recent trending projects:
Addy Osmani wrote on his blog: "Skills encode the workflows, quality gates, and best practices that senior engineers use when building software."
That may be the most accurate definition of agent engineering yet — not making agents replace engineers, but encoding engineers' experience into processes agents can follow.
---
*Project: addyosmani/agent-skills · JavaScript · 203 stars today · Author: Addy Osmani (Google Chrome team)*