Top 10 Agent Skills Every Developer Should Install

Skills are arguably the simplest solution for AI agents with profound impact. Skills are modular, reusable capabilities that define what an agent can do and how it should do it.

A skill typically bundles together a set of best practices, step-by-step procedures, tool usage patterns, and domain-specific knowledge for a particular type of task. For example, a "create a PowerPoint" skill would include instructions on how to structure slides, use a specific library, apply formatting, and produce a polished output.

This article covers the top 10 skills you need to build AI agents. Let’s get started!

How to install Agent Skills (quick start)

Most Agent Skills are folders that include a required SKILL.md.

Install (Claude Code)

SKILLS_DIR=".claude/skills"
mkdir -p "$SKILLS_DIR"
# Example: install Browser Testing skill
rm -rf "$SKILLS_DIR/browser-testing"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
cp -R /tmp/agent-skills/skills/browser-testing-with-devtools "$SKILLS_DIR/browser-testing"

Install (Codex)

SKILLS_DIR=".agents/skills"
mkdir -p "$SKILLS_DIR"
# Example: install Browser Testing skill
rm -rf "$SKILLS_DIR/browser-testing"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
cp -R /tmp/agent-skills/skills/browser-testing-with-devtools "$SKILLS_DIR/browser-testing"

Short answer: If you install only three skills, start with browser testing, test-driven development, and debugging. Together, they make an agent prove that its changes work, protect the behavior with tests, and investigate failures systematically.

The best Agent Skills at a glance

How I selected these skills

I prioritized skills that:

1. Address a frequent failure mode in coding-agent workflows.

2. Define a repeatable process rather than a collection of generic tips.

3. Require evidence before the agent declares a task complete.

4. Apply across languages, frameworks, and agent clients.

5. Have a clear trigger, scope, and expected output.

6. Can be inspected and adapted by the team installing them.

The ranking favors broad usefulness over novelty. A specialized framework skill can be valuable, but testing, debugging, review, and security improve almost every software project.

Before publishing, we recommend running each skill against the same benchmark tasks in at least two agent clients. Record completion rate, number of corrective prompts, regressions introduced, and time to a verified result. Add those results to this article to make the ranking independently reproducible.

1. Browser Testing

Best for: Web applications, dashboards, forms, and frontend changes

Recommended implementation: Browser Testing with DevTools

Install first if: Your agent writes or modifies user interfaces

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/browser-testing"
cp -R /tmp/agent-skills/skills/browser-testing-with-devtools "$SKILLS_DIR/browser-testing"

Coding agents are good at producing code that looks plausible. They are less reliable at recognizing that a button does nothing, a form fails after submission, a mobile layout overflows, or the browser console contains an exception.

A browser-testing skill teaches the agent to open the application, interact with it like a user, and collect evidence from the live runtime. That can include DOM inspection, console logs, network requests, screenshots, responsive checks, and performance traces.

Why browser testing is necessary

Compilation proves that code can be transformed into an executable artifact. Unit tests prove selected functions behave as expected. Neither proves that a user can complete the intended workflow.

For example, after adding a signup form, a browser-testing skill should instruct the agent to:

1. Start the application.

2. Open the signup page.

3. Submit an empty form and verify validation.

4. Submit malformed data and inspect the error state.

5. Complete the flow with valid data.

6. Confirm the success state or navigation.

7. Check the console and failed network requests.

8. Repeat the critical path at a mobile viewport.

That process catches integration problems that isolated code review misses.

What to look for in a browser-testing skill

• Explicit user journeys rather than random clicking

• Console and network inspection

• Responsive and keyboard-navigation checks

• Screenshots or other evidence of the final state

• Clear reporting of what was and was not tested

• A rule that prevents the agent from claiming success without running the application

Limitation

Browser testing does not replace unit, integration, accessibility, or security testing. It is the final behavioral layer that confirms those pieces work together.

Verdict: The most broadly useful skill for developers building web products. It changes the agent's completion criterion from "the code looks right" to "the workflow was exercised and verified."

2. Test-Driven Development

Best for: New behavior, bug fixes, and regression prevention

Recommended implementation: Test-Driven Development

Install first if: Your agent regularly changes business logic

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/test-driven-development"
cp -R /tmp/agent-skills/skills/test-driven-development "$SKILLS_DIR/test-driven-development"

A test-driven development skill requires the agent to express expected behavior as a failing test before implementing the change. The workflow is commonly described as red, green, refactor:

1. Write a test that fails for the correct reason.

2. Implement the smallest change that makes it pass.

3. Refactor while keeping the suite green.

This is particularly valuable for bug fixes. Without a regression test, an agent can patch the visible symptom while leaving the underlying problem reproducible elsewhere.

Why it is necessary

Agents can move quickly enough to create large amounts of unverified code. A TDD skill slows the agent down at the point where precision matters and speeds up later iteration by creating an executable safety net.

A strong TDD skill should also distinguish between:

• Unit tests for isolated logic

• Integration tests for boundaries such as databases and APIs

• End-to-end tests for critical user journeys

• Regression tests that reproduce a reported defect

Example

If a discount calculation incorrectly accepts an expired coupon, the agent should first add a test demonstrating that expired coupons are rejected. Only then should it change the implementation. The test proves the bug existed, validates the fix, and prevents the same behavior from returning.

Limitation

Poorly chosen tests can lock in implementation details or produce false confidence. The skill should focus on observable behavior and avoid mocking every dependency by default.

Verdict: Essential for teams that want agent-generated changes to remain stable after the first successful run.

3. Debugging and Error Recovery

Best for: Test failures, build errors, production defects, and flaky behavior

Recommended implementation: Debugging and Error Recovery

Install first if: Your agent tends to make several speculative fixes before identifying the cause

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/debugging"
cp -R /tmp/agent-skills/skills/debugging-and-error-recovery "$SKILLS_DIR/debugging"

When an agent sees an error, its first instinct is often to edit the nearest relevant-looking code. That can work, but it can also create a chain of unrelated changes that hides the original defect.

A debugging skill imposes a disciplined sequence:

1. Reproduce the failure.

2. Collect the exact error and relevant state.

3. Localize the failing layer.

4. Reduce the problem to the smallest reproducible case.

5. Form and test a hypothesis.

6. Implement the narrowest correct fix.

7. Add a regression guard.

8. Re-run the affected and surrounding tests.

Why it is necessary

The value of an agent is not that it can generate many possible fixes. It is that it can investigate the system faster while preserving a traceable explanation of what failed and why.

A debugging skill is especially useful when failures cross boundaries: frontend to API, API to database, application to third-party service, or build tooling to runtime configuration.

Limitation

The skill needs access to useful evidence. Missing logs, nondeterministic environments, and unavailable credentials can still block diagnosis. A good skill reports those constraints instead of inventing certainty.

Verdict: One of the highest-leverage skills for reducing noisy edits and shortening the path from symptom to verified root cause.

4. Code Review and Quality

Best for: Reviewing pull requests and agent-generated diffs

Recommended implementation: Code Review and Quality

Install first if: Agents are allowed to implement multi-file changes independently

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/code-review"
cp -R /tmp/agent-skills/skills/code-review-and-quality "$SKILLS_DIR/code-review"

Generating code and reviewing code require different mental modes. An implementation agent is optimizing for task completion. A review skill asks whether the resulting change is correct, appropriately scoped, maintainable, tested, and compatible with the surrounding system.

The skill should review the actual diff and prioritize findings by impact. Useful categories include:

• Correctness and edge cases

• Behavioral regressions

• Missing or weak tests

• Security and privacy risks

• API compatibility

• Error handling

• Unnecessary complexity

• Scope creep

Why it is necessary

Agents often produce locally reasonable code that conflicts with repository conventions or changes behavior outside the requested scope. A structured review catches those issues before they become part of the codebase.

The most useful review output is not a long summary. It is a short list of actionable findings with file and line references, severity, and a concrete explanation of the failure mode.

Limitation

Review quality depends on context. The skill should inspect tests, call sites, interfaces, and relevant documentation rather than reviewing a diff in isolation.

Verdict: A practical quality gate for any team allowing agents to create pull requests or complete tickets.

5. Security and Hardening

Best for: Authentication, authorization, APIs, file handling, payments, and sensitive data

Recommended implementation: Security and Hardening

Install first if: The application accepts untrusted input or performs privileged actions

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/security-hardening"
cp -R /tmp/agent-skills/skills/security-and-hardening "$SKILLS_DIR/security-hardening"

Security defects are rarely obvious from a happy-path demo. A feature can work perfectly while exposing another user's data, accepting an unsafe redirect, leaking a secret, or trusting client-controlled fields.

A security skill gives the agent a repeatable review process that includes:

• Identifying assets and trust boundaries

• Mapping untrusted inputs

• Checking authentication and authorization separately

• Validating data at system boundaries

• Reviewing secret and credential handling

• Looking for injection, traversal, SSRF, and unsafe deserialization

• Checking dependency and configuration risks

• Verifying logging does not expose sensitive data

Why it is necessary

General coding prompts optimize for functionality. Security requires adversarial thinking: how could this behavior be abused, bypassed, replayed, or combined with another weakness?

The skill is most effective when activated during design and again before merge. Finding an unsafe trust boundary before implementation is cheaper than patching it after release.

Limitation

An agent skill is not a substitute for professional penetration testing, dependency scanning, or a formal security review of high-risk systems.

Verdict: Mandatory for production applications that handle accounts, money, private data, or external input.

6. Composio App Integration

Best for: Connecting agents to external applications and APIs

Recommended implementation: Composio Agent Skill

Install first if: Your agent needs to work with Gmail, Slack, GitHub, Notion, Salesforce, or other external services

Install

This item refers to Composio’s integration tooling rather than a single Agent Skills repo folder, so there isn’t a “copy this directory” install snippet like the others. Treat it as an integration layer you enable and configure (accounts, auth, scopes).

Most useful agents eventually need to act outside the local codebase. They may need to create a GitHub issue, search Slack, update a CRM, send an email, add a calendar event, or read data from a workspace tool.

Those integrations create three recurring problems:

1. Discovering the correct tool and input schema

2. Authenticating users securely

3. Handling provider-specific errors and account state

The Composio skill teaches an agent how to discover and use app tools through Composio's integration layer rather than building every OAuth flow and API wrapper from scratch.

Why it is necessary

A raw API description is not enough for reliable tool use. The agent must know which operation matches the task, what fields are required, whether an account is connected, and what to do when authentication is missing.

For example, an agent asked to "email the latest report to the finance team" may need to:

1. Find the report in cloud storage.

2. Identify the correct email tool.

3. Verify that the intended email account is connected.

4. Resolve recipients.

5. Attach or link the correct file.

6. Request confirmation before the external side effect.

7. Send the message and return evidence of completion.

A well-designed integration skill turns that into a repeatable workflow.

Limitation

External actions have real consequences. The agent still needs appropriate permissions, user confirmation for consequential actions, and careful handling of sensitive information.

Verdict: The strongest choice when the goal is to move from a coding assistant to an agent that can complete workflows across real applications.

7. Incremental Implementation

Best for: Multi-file features, refactors, and uncertain changes

Recommended implementation: Incremental Implementation

Install first if: Your agent tends to generate large changes before running tests

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/incremental-implementation"
cp -R /tmp/agent-skills/skills/incremental-implementation "$SKILLS_DIR/incremental-implementation"

An incremental implementation skill breaks work into thin, complete slices. Each slice is implemented, tested, and verified before the next one begins.

For a task-management feature, the slices might be:

1. Create a task through the database, API, and basic UI.

2. List tasks end to end.

3. Edit an existing task.

4. Delete a task with confirmation.

Each stage leaves the system in a working state.

Why it is necessary

Large agent-generated diffs are difficult to review and expensive to unwind. When ten files change before the first test runs, the source of a failure becomes harder to identify.

Incremental work also exposes architectural problems earlier. If the riskiest integration cannot be made to work, the team discovers that before investing in the surrounding feature.

Limitation

Not every task needs a formal slicing process. A single, obvious function change may be clearer without additional ceremony.

Verdict: The best skill for controlling blast radius and keeping autonomous implementation understandable.

8. API and Interface Design

Best for: REST APIs, SDKs, internal modules, events, and shared interfaces

Recommended implementation: API and Interface Design

Install first if: Other code or customers will depend on the interface being created

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/api-interface-design"
cp -R /tmp/agent-skills/skills/api-and-interface-design "$SKILLS_DIR/api-interface-design"

Interfaces outlive implementations. A poorly named field, ambiguous error response, or accidental breaking change can spread across clients and become difficult to reverse.

An API-design skill should require the agent to define the contract before implementation and examine:

• Inputs, outputs, and invariants

• Error semantics

• Validation boundaries

• Idempotency

• Pagination and rate limits

• Backward compatibility

• Versioning

• Naming consistency

• Authentication and authorization expectations

Why it is necessary

Coding agents naturally optimize the implementation they can see. API design requires considering code that does not exist yet: future clients, alternative callers, retries, partial failures, and migration paths.

A contract-first workflow makes those assumptions explicit before they become production dependencies.

Limitation

The skill cannot resolve product ambiguity on its own. Teams still need to decide what behavior they want to support and what compatibility guarantees they are willing to maintain.

Verdict: Necessary whenever an agent creates a boundary that other developers or systems will consume.

9. Performance Optimization

Best for: Slow pages, expensive queries, high resource usage, and regressions

Recommended implementation: Performance Optimization

Install first if: Performance work is being proposed without a profile or baseline

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/performance-optimization"
cp -R /tmp/agent-skills/skills/performance-optimization "$SKILLS_DIR/performance-optimization"

Performance optimization is an area where plausible advice is often wrong. An agent can refactor code, add caching, or introduce concurrency without improving the actual bottleneck.

A performance skill should enforce a measurement loop:

1. Define the affected user experience or system objective.

2. Record a baseline.

3. Profile the real workload.

4. Identify the dominant bottleneck.

5. Make one targeted change.

6. Measure again under comparable conditions.

7. Check correctness and resource tradeoffs.

Why it is necessary

Without measurement, optimization becomes aesthetic refactoring. The skill keeps the agent focused on observable outcomes such as latency, throughput, memory, bundle size, or Core Web Vitals.

Limitatio

Benchmarks can mislead when test data, hardware, network conditions, or caches differ. The skill should document the environment and avoid presenting synthetic improvements as production guarantees.

Verdict: Valuable because it teaches the agent that faster-looking code is not evidence of a faster system.

10. Documentation and Architecture Decision Records

Best for: Long-lived codebases, migrations, and cross-team decisions

Recommended implementation: Documentation and ADRs

Install first if: Important technical decisions currently live only in chat or pull-request comments

Install (example: Claude Code)

SKILLS_DIR=".claude/skills" # or: .agents/skills | .cursor/skills | .gemini/skills
mkdir -p "$SKILLS_DIR"
git clone --depth 1 <https://github.com/addyosmani/agent-skills.git> /tmp/agent-skills
rm -rf "$SKILLS_DIR/documentation-adrs"
cp -R /tmp/agent-skills/skills/documentation-and-adrs "$SKILLS_DIR/documentation-adrs"

Code explains what the system does. It rarely captures why one approach was chosen over another, what alternatives were rejected, or which constraints shaped the decision.

A documentation and ADR skill helps the agent produce:

• Setup and operational instructions

• API and component documentation

• Migration notes

• Troubleshooting guides

• Architecture decision records

• Explicit tradeoffs and consequences

Why is it necessary

Agents can make changes faster than teams can absorb them. Without durable documentation, each new session must rediscover the same context from code, commit history, and conversations.

A useful ADR should be short and specific: the context, the decision, the alternatives considered, and the consequences. It should not become a transcript of the implementation process.

Limitation

Generated documentation becomes harmful when it is not maintained. The skill should update documentation alongside behaviour and avoid creating pages that merely repeat the code.

Verdict: The skill that preserves the engineering context after the agent session ends.

End Note

Install the skills you only need. Verify and vet each skill, even if it is from official sources. And use Composio to securely connect coding agents to the real world.