Agent Skills: Ending the AI Coding Agent Habit of Skipping Tests

Why Does Your AI Agent Always Cut Corners?

When coding with AI, you may have encountered this: the Agent rapidly generates a pile of code, casually says "I'll add tests later," and then declares the task complete. This "shortcut" behavior has become almost a universal flaw of coding Agents—they tend to deliver results via the shortest path, and the shortest path often skips testing, skips verification, and leaves only a "looks fine to me."

A video on YouTube introduced an open-source project called Agent Skills, created by Addy Osmani. The project has already garnered over 100,000 stars on GitHub, with a clear goal: use a structured workflow to force the Agent through every step from definition to deployment, eliminating cut corners.

What Is Agent Skills?

Agent Skills provides a framework of 25 skills covering the complete software development lifecycle: Define, Plan, Build, Test, Review, Ship. Each phase comes with corresponding slash commands, letting the Agent proceed according to an established workflow rather than improvising.

It uses the MIT license, meaning you can freely use, modify, and distribute it. More practically, it is compatible with several mainstream AI coding environments: Claude Code, Cursor, Codex, and Gemini CLI. Whichever tool you prefer, you can directly plug into this skill system.

Core Mechanism: Locking Down the Workflow with Slash Commands

/spec: Write the Spec First, Then the Code

Every development task should start with clear requirements. The /spec command requires the Agent to output a specification before writing any code. This step seems simple but effectively prevents the Agent from coding "by feel" and reduces later rework.

/plan: Break Large Tasks into Small Steps

The /plan command splits the overall requirement into a series of executable small tasks. The video author specifically mentions this is his favorite part—because small tasks are easier to verify one by one, and it's hard for the Agent to bluff its way through the divided steps.

Slash Command refers to shortcut commands starting with / in chat-based AI coding interfaces, such as /spec and /plan. Its purpose is to encapsulate a preset, structured prompt or workflow into a reusable command; the user enters the command name to trigger the corresponding full workflow without having to hand-write lengthy instructions each time. In tools like Cursor and Claude Code, slash commands are typically defined by configuration files or skill packs within the project and can carry parameters, constraints, and output format requirements. Agent Skills leverages this mechanism to solidify disciplines like "write the spec first, then break down tasks, then test" into one-click commands, reducing the operational cost for developers to follow standard processes and making it hard for the Agent to ignore established steps.

The Most Striking Design: Anticipating the Agent's Excuses

What truly stands out about Agent Skills is that for each skill, it lists the excuses the Agent might use to skip steps and provides rebuttals in advance. For example, the Agent might say, "I'll add tests once the code runs." The built-in reply is: "No, you won't."

This may sound like a joke, but it reflects a deep insight into AI behavior patterns. When faced with multi-step tasks, large language models tend to choose the path of least resistance, and steps like testing and verification are often seen as "extra burdens." Agent Skills puts these excuses on the table, essentially giving the Agent a preventative shot, forcing it to confront its own laziness.

The "path of least resistance" tendency of Large Language Models (LLMs) refers to the model's inclination, in multi-step tasks, to generate the least effortful response that best matches the training distribution rather than strictly following the complete workflow. This is not the model "intentionally slacking off" but a natural tension between its optimization objective (predicting the next word) and task completeness: steps like testing and verification often appear in training corpora as "to be added later," so the model learns to substitute vague promises for actual execution. Additionally, instruction decay in long contexts can cause the model to gradually forget constraints set earlier. By explicitly listing "excuse–rebuttal" pairs in each skill, Agent Skills essentially continuously reaffirms constraints at the prompt level to counter this tendency.

Closing with Evidence: No More "Looks Fine"

Every skill ends with verifiable evidence as its completion condition. Vague judgments like "looks fine" are no longer accepted; instead, it requires: passing tests, build output, real data. In other words, the Agent cannot declare victory on its own—it must produce tangible results to prove the task is complete.

This design changes the definition of "done" from a subjective judgment to an objective standard, greatly reducing the risk of AI delivering half-finished work without anyone noticing.

Verifiable Evidence in AI-assisted development refers to objective artifacts that can be independently reviewed by external tools or humans, such as test run reports (number of passed/failed cases), build logs, coverage data, diff patches, or actual runtime output. It is fundamentally different from the model's self-reported "done" or "no problem": the latter is a subjective claim that cannot be falsified, while the former can be reproduced and audited. Requiring the Agent to close with evidence essentially transfers the authority to determine "done" from the model to observable artifacts. This aligns with the "Definition of Done" practice in software engineering and is a key means of guarding against AI hallucination-style delivery.

Comparison with "Superpowers"

If you've seen the author's previous video on "Superpowers," the Agent Skills repository even has a dedicated page comparing the two. This shows the author is continuously iterating on his methodology and is willing to publicly present the pros and cons of different approaches. For developers, this also provides a reference for choosing which skill system is more suitable based on their team's workflow and toolchain.

Who Should Use Agent Skills?

If you're already asking the Agent to "plan before acting," Agent Skills can help you carry that standard through to the very last moment of delivery. It suits the following scenarios:

• Individual developers using tools like Cursor and Claude Code for AI-assisted development
• Tech leads who want to standardize the AI coding process within their team
• Engineers with high standards for AI-generated code quality who refuse to compromise on testing

The MIT License is a permissive open-source license that allows anyone to freely use, copy, modify, merge, publish, distribute, sublicense, and sell the software, provided the original copyright notice and permission notice are retained in copies. It does not require derivative works to be open-sourced as well (unlike the "copyleft" nature of GPL), making it very friendly for internal enterprise use and commercial integration. Agent Skills adopting the MIT license means teams can embed its skill definitions directly into private workflows, trim them as needed, or build upon them without worrying about license compliance burdens—one reason it has spread quickly in the developer community.

A Bit of Sober Reflection

The value of Agent Skills lies not in inventing new technology but in solidifying disciplines that already exist in software engineering—writing specs, breaking down tasks, running tests, demanding evidence—into a process the Agent must follow. With 25 skills and slash commands, it outsources "self-discipline" to the framework.

However, the effectiveness of such tools ultimately depends on whether the Agent actually executes these commands and whether developers are willing to invest time in the process. If the team itself doesn't value testing, even the best skill framework can be bypassed. But at least Agent Skills makes "skipping tests" less easy.

As the video concludes: Prune the noise, keep what works.

One-line Summary

Agent Skills uses 25 skills and slash commands to force AI Agents through the entire development workflow, eliminating cut corners.

Paragraph Summary

The article introduces Addy Osmani's open-source project Agent Skills, which addresses the common tendency of coding Agents to take shortcuts and skip testing and verification. It provides a framework of 25 skills covering six phases: Define, Plan, Build, Test, Review, Ship. Each phase comes with slash commands (such as /spec and /plan) that force the Agent to follow the workflow. Its most unique design is anticipating the excuses Agents might use to skip steps and embedding rebuttals, with each skill requiring verifiable evidence (passing tests, build output, real data) as its completion condition, rejecting vague "looks fine" delivery. The project uses the MIT license and is compatible with Cloud Code, Cursor, Codex, and Gemini CLI, suitable for individual developers, tech leads, and engineers who demand code quality. The article also notes that its effectiveness depends on whether teams actually enforce the process.