English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

Agent-Skills: Encoding Senior Engineers' Workflows into AI Coding Agents

Forum topic · ✨步子哥 · 2026-08-05

Summary

addyosmani/agent-skills, a GitHub trending project by Addy Osmani (Google Chrome engineering leader), encodes senior engineers' software development workflows into AI agent-followable skills. The project provides 8 slash commands covering the full development lifecycle—/spec, /plan, /build, /test, /review, /webperf, /code-simplify, and /ship—backed by 24 Markdown skill files that auto-activate based on context. Its standout feature, /build auto, generates an implementation plan from a spec, then executes tasks one by one with test-driven development and per-task commits, requiring only one upfront plan approval instead of step-by-step human confirmation. The core insight: AI agents' weakness is not intelligence but lack of process. Compared with obra/superpowers (a heavier framework/methodology), agent-skills is lightweight and adoptable piecemeal. Together with projects like cloudflare/computer and huangruiteng/loopx, it signals agent engineering shifting from 'smarter models' toward 'better workflows.'

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)
  • 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:

  • Skip the spec and start coding
  • Write the entire feature in one go, no slicing
  • Skip tests
  • Skip review
  • Push directly
  • 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:

  • 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
  • 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:

  • 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)
Three layers are evolving independently, but will eventually assemble into a complete "agent operating system." agent-skills chose the layer closest to humans: skills. Because no matter how strong the model, without process support, output quality is random.

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)*

Tags

#ai-agents#coding-agents#developer-tools#agent-skills#engineering-workflow#addaddy-osmani#software-development-lifecycle#github-trending

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178595037