The problem with AI coding agents is that they're too helpful. They'll write code, run tests, refactor modules, and push changes — but they do it the way a junior engineer would: fast, incomplete, and full of invisible shortcuts that won't surface until the PR is merged and something breaks in production.

Addy Osmani — the developer productivity lead at Google Chrome — just published "Agent Skills," an open-source framework (26K GitHub stars) that encodes senior engineer discipline as executable agent workflows. Instead of asking agents to "be more careful," it gives them an actual process to follow.

This is the most practical framework I've seen for making AI coding agents actually reliable.

The Core Problem: Agents Default to Shortcuts

When you give an AI agent a coding task, it optimizes for completion. The model wants to produce a working solution as quickly as possible. This is exactly what you'd ask a contractor to do if you said "build me a deck" without specifying materials, permits, load requirements, or inspection schedules.

The shortcuts AI agents take are predictable:

  • Skipping the spec phase and jumping to code
  • Writing minimal or no tests ("I'll add tests later")
  • Not checking scope — adding features that weren't requested
  • Skipping review because "the task is simple"
  • Pushing code without verifying it compiles or passes linting

None of these shortcuts make the agent malicious. They're the natural output of a model that was trained to complete tasks, not to maintain quality standards over time.

How Agent Skills Works

Agent Skills is deceptively simple: it's a collection of markdown files with YAML frontmatter that get injected into an AI agent's context at the right moments in the workflow.

Each skill is a workflow with steps and exit criteria — not reference documentation. When an agent is in the "Build" phase, it gets the build skill. When it's in the "Verify" phase, it gets the test skill. This is "progressive disclosure" — don't load all 20 skills at once, activate the ones relevant to the current phase.

The five load-bearing principles:

Process over prose: Skills are workflows, not essays. A "write tests" essay might explain testing philosophy. A "write tests" workflow has steps: "identify edge cases," "write failing test," "verify test fails," "implement fix," "verify test passes." The agent can execute this.

Anti-rationalization tables: Pre-written rebuttals to the excuses agents (and humans) use to skip work. "This task is too simple for a spec." Pre-written response: "Simplicity is not a spec exemption. Write the spec anyway." "I'll write tests later." Pre-written response: "Later means never in a CI context. Write tests now or the workflow doesn't complete."

Verification is non-negotiable: Every skill terminates in concrete evidence. Not "seems right" or "tested manually." A passing CI run, a lint check, a coverage threshold met. The workflow doesn't end until there's a verifiable artifact.

Progressive disclosure: Loading all 20 skills at once creates context noise. Skills activate based on the agent's current phase. A spec phase gets different skills than a review phase.

Scope discipline: "Touch only what you're asked to touch." This is the hardest skill to enforce — agents (like junior engineers) love expanding scope when they're on a roll. The scope discipline skill makes agents stop and ask "is this in scope?" before adding features.

The SDLC Encoded

The full software development lifecycle is encoded:

/spec (Define) → /plan (Plan) → /build (Build) → /test (Verify) → /review (Review) → /ship (Ship)

Each phase has its own skill set. The agent can't skip from /build to /ship without going through the intervening phases. More importantly, each phase has exit criteria — the /build phase doesn't complete until there are tests. The /ship phase doesn't complete until there's a code review.

This is the senior engineer's mental model of software development: every phase has a purpose, shortcuts accumulate as technical debt, and quality is maintained by process discipline rather than hoping the code "just works."

Why Google DNA Matters

The framework carries Google's engineering culture DNA in specific ways:

Hyrum's Law: "With a sufficient number of users of an API, all observable behaviors of your system will be depended on by somebody." Skills encode this by requiring agents to think about backward compatibility and API contracts before shipping.

~100 line PR sizing: Large PRs are hard to review. Skills encourage small, focused changes that are easier to reason about and safer to merge.

DAMP over DRY in tests: "Don't Abstract Message Patterns" — tests should be readable and self-documenting. Skills push agents to write tests that explain themselves rather than tests that minimize code duplication at the expense of clarity.

Chesterton's Fence: "Don't remove a fence until you understand why it was put there." Skills teach agents to question changes that remove existing abstractions without understanding their purpose.

Code as liability: Every line of code is a liability. Skills push agents to ask "do we need this?" before adding code, not after.

Three Adoption Modes

The framework is tool-agnostic by design:

Claude Code marketplace: Install skills through Claude Code's built-in marketplace — the smoothest adoption path if you're already using Claude Code.

Drop markdown into any tool: The skills are just markdown files. Drop them into your Cursor rules, your Gemini CLI configuration, or any AI coding tool that supports custom instructions.

Read and steal the patterns: You don't need to use the full framework. Read the skills and implement the patterns in your own workflow. The anti-rationalization tables alone are worth reading.

The Honest Assessment

Agent Skills is the most mature approach to AI agent reliability I've seen. It doesn't pretend that model capability is the bottleneck — it acknowledges that process discipline is what makes engineering teams reliable, and that discipline has to be explicitly encoded for agents.

The limitations: this is a framework for coding agents. The skills are specifically about software development workflows. And the framework requires you to actually install it and configure your agent — it's not a setting you flip.

But the core insight is valuable beyond coding agents: AI systems that take on consequential tasks need process discipline. That discipline doesn't emerge from better models alone. It has to be engineered in.

The senior-engineer parts of the job are no longer optional, even when the engineer is a model.

Related posts: Advanced Tool Use Patterns for AI Agents — the technical patterns that make AI agents reliable. AI Agents in Production — the engineering practices for deploying agents at scale. AI Agent Threat Models — security considerations for AI coding agents. CopilotKit AG-UI Protocol — the emerging protocol standards for agent-UI integration.