If you've ever handed an autonomous AI agent more than a toy function—say, a real chunk of business logic for a live project—you probably remember that brief rush of euphoria. For the first five minutes, it feels like magic: the model zips across files, scaffolds components, wires up routes, and proudly reports, "All done, boss!" Then you open git diff, and your stomach drops. Beneath the surface sits a pile of duct-tape workarounds, ignored edge cases, and tests that are either missing altogether or quietly commented out so the build stays green.
The industry has a fitting name for this: vibe coding—shipping code on pure momentum and optimism, only to watch it crumble on first contact with production. The problem with large language models isn't syntax; they know syntax inside out. The problem is a lack of engineering discipline. By nature, an LLM takes the path of least resistance, optimizing its output for the immediate context window rather than long-term maintainability.
To tame that chaos, Addy Osmani—Staff Engineer at Google Chrome and author of foundational JavaScript architecture guides—published an open-source system of engineering skills called addyosmani/agent-skills. It isn't another autocomplete plugin. It's a full framework of 25 standardized modules that nudges over 70 IDEs and coding agents (including Claude Code, Cursor, Windsurf, Cline, and Copilot Workspace) into working by senior-engineer rules.
From Chaotic Prompts to a Six-Phase Lifecycle
Let's be honest: trying to enforce discipline through a massive system prompt is a dead end. Feed an agent a thirty-page instruction manual and it quickly loses focus, skipping critical constraints buried in the middle—while burning through your context window budget.
Osmani approached the problem like a systems architect. He broke the entire software development lifecycle (SDLC) into six sequential phases controlled by nine short slash commands. Instead of cramming every rule into memory at once, the model loads specialized instructions via Progressive Disclosure—only when it enters the relevant step.
- DEFINE Phase (Locking Down Requirements): Before the agent touches production code,
/specactivates thespec-driven-developmentmodule. The agent drafts a Product Requirements Document (PRD) covering user flows, data contracts, and explicit system boundaries. If the prompt is vague, theinterview-meskill asks clarifying questions one at a time until the scope is crystal clear. Meanwhile,constraint-driven-development(/constraints) writes quality gates intoCONSTRAINTS.md(for example, banning new external dependencies without explicit approval). - PLAN Phase (Task Decomposition): Running
/plantriggersplanning-and-task-breakdown, splitting the spec into manageable, atomic steps with clear acceptance criteria. No blind 500-line leaps—each item is verifiable on its own. - BUILD Phase (Incremental Implementation): The
incremental-implementationandtest-driven-developmentskills enforce a strict TDD loop: write a failing test first, implement the minimal code to pass it, and make an atomic commit. At critical forks,doubt-driven-developmentforces the model to challenge its own assumptions using theCLAIM -> EXTRACT -> DOUBT -> RECONCILE -> STOPprotocol. - VERIFY Phase (Automated Checks): The
/testcommand runs the test pyramid (80% unit, 15% integration, 5% end-to-end). When needed, the agent spins up a browser via Chrome DevTools MCP (browser-testing-with-devtools) to visually verify UI rendering. - REVIEW Phase (Quality Gates): The
code-review-and-qualitymodule (/agent-skills:reviewin Claude Code) audits the diff impartially. Patches over 100 lines are sent back to be split,/code-simplifytrims over-engineering, and/webperfmeasures the impact on Core Web Vitals. - SHIP Phase (Safe Release): The
/shipcommand validates database migrations and guards public interfaces against regressions under Hyrum's Law: if a system has an observable behavior, someone will eventually depend on it.
We previously looked at how the Agent Skills standard expands coding agents with modular capabilities, creating a shared language across editors—and Osmani's release is where that idea gets a complete, battle-ready workflow.
Anti-Rationalization Tables: Teaching the Model Not to Cheat
The cleverest piece of engineering in the whole repository is what Osmani calls Anti-Rationalization Tables.
I've watched models invent remarkably smooth excuses for cutting corners. An agent will write: "This module is trivial, so I skipped writing tests—the logic is self-evident." Or: "The linter flagged line 42, so I added an eslint-disable comment temporarily to keep things moving." That's pure laziness rationalization, absorbed straight from millions of sloppy public GitHub repos.
Osmani baked tables directly into the skill manifests, pairing each common LLM excuse with a hard counter-rule:
- Excuse: "The code is trivial; tests can be added later." Hard rule: "Tests written after the fact suffer from confirmation bias. Write the test first."
- Excuse: "The full test suite takes too long; let's skip running it." Agent directive: "Run only the isolated test file using targeted test-runner flags."
- Complaint: "It's hard to mock the network call to an external API." Architectural directive: "If a dependency can't be isolated in a test, extract the business logic into pure functions."
Once those counter-arguments sit right inside the execution context, the model loses its wiggle room and has to play by the rules.
Inside a Skill Manifest: Looking Under the Hood of SKILL.md
Let's peek inside a skill manifest to see how it's wired up. Each skill lives in its own directory with a SKILL.md file. The header uses standard YAML frontmatter for metadata and invocation triggers, while the body spells out operating rules, anti-rationalization tables, and verification gates:
---
name: test-driven-development
description: Enforce Red-Green-Refactor, test pyramid (80/15/5), and boundary verification.
triggers:
- "implement feature"
- "fix bug"
- "refactor"
---
# Test-Driven Development (TDD) Skill
## Operating Rules
1. Write the test BEFORE writing any production code.
2. Run the test suite and verify that the test FAILS for the expected reason (Red).
3. Write the minimal amount of code to make the test pass (Green).
4. Refactor the code for clarity and maintainability without altering behavior.
## Verification Gate
- Run `npm test -- --watch=false`
- Capture stdout and stderr into execution log.
- Confirm zero failing assertions and test coverage threshold >= 85%.
The agent parses this file, knows the exact boundaries of its job, and gets to work. If the verification gate fails—say, a test breaks or coverage drops below 85%—moving on to the next task is blocked at the protocol level.
Deploying the Skills in One Minute
You don't need to copy dozens of files by hand or wrestle with custom configs to try this out. Everything installs through the cross-platform skills CLI via npx:
# Install the full skill suite into the current project
npx skills add addyosmani/agent-skills
# Install only the TDD and code-review skills selectively
npx skills add addyosmani/agent-skills --skill test-driven-development
npx skills add addyosmani/agent-skills --skill code-review-and-quality
One heads-up if you install selectively: in the current version of the CLI, the --skill flag only copies that specific skill's directory and skips the shared references/ folder (a known snag currently being tracked in issue #361). For serious projects, I'd recommend installing the full suite or cloning the repository directly.
Packaging engineering experience into structured skills makes one thing clear: the future of autonomous development doesn't hinge on blindly scaling model parameters—it depends on the rigor and cleanliness of the processes we put around them.
