How to use the Error Handling Reviewer agent skill

What is an agent skill and what does this one make the agent do?

An agent skill is a folder containing instructions that an AI agent can load when a task matches the skill's description. This skill is a set of written guidelines and checklists for error handling, not a program that runs on your machine.

Once installed, the agent reviews JavaScript code, components, and browser behaviour for error handling gaps. Typical findings include async calls without try-catch, errors swallowed silently, and missing React Error Boundaries. It also suggests fixes that add proper handling and logging, and explains best practices such as try-catch, Promise rejection, and error boundaries.

• Flags async operations that lack try-catch blocks
• Flags errors that are silently swallowed
• Flags React components that lack Error Boundaries
• Suggests fixes that add handling and logging with context
• Explains the reasoning behind the recommended patterns

How do you install the Error Handling skill?

Download the ZIP for the skill from the Front-End Checklist page. Then use one of the two methods below.

For Claude Code, unzip the download into ~/.claude/skills/ to make it available in all your projects, or into a project's .claude/skills/ folder to limit it to that project. The skill folder should contain SKILL.md and references/rule.md.

In the Claude apps, you can upload the ZIP instead under Settings → Capabilities → Skills.

• Personal install: ~/.claude/skills/
• Project install: .claude/skills/ inside your project
• Claude apps: Settings → Capabilities → Skills, then upload the ZIP

How do you trigger the skill with a natural request?

You do not need a special command. The skill's description says it applies when reviewing scripts, client components, bundles, or runtime behaviour related to error handling, so ask for that work in plain language and name the file or component you want checked.

Good requests say what you want reviewed and why. Mention the scope, such as one component or one data-fetching module, so the agent does not review the whole project.

• Review the error handling in src/api/users.js, especially the async calls
• Check whether our React checkout components need Error Boundaries
• Look for errors that are swallowed silently in this file and suggest fixes with logging

What does a typical review look like?

The skill's guidance shows a before-and-after pattern. In the unsafe version, an async fetch returns the parsed JSON without checking the response or catching failures. In the improved version, the code checks response.ok, throws a descriptive error when the request fails, logs the error with context, and re-throws it so the caller can handle it.

The guidance also covers a version with error recovery, where a fallback value is returned instead of re-throwing. Ask the agent which approach fits your code, since the right choice depends on what the caller expects.

• Expect the agent to point to the exact function and the missing check
• Expect a suggested replacement with try-catch, a status check, and logging
• Ask why a fix is needed if the reasoning is not clear

What does the skill need, and what are the safety notes?

The skill lists no requirements. It does not run scripts and does not use the network. The files provided contain no executable scripts, so installing it does not add code that runs on your machine.

Because it only provides guidance, the agent reviews by reading code and reasoning about it. It does not run your tests or open a browser to confirm behaviour. Any fix it suggests should be verified by your own tests and by checking the browser yourself.

• No listed requirements
• Runs scripts: no
• Uses network: no
• Scope: JavaScript and React guidance only

What tips help you get better reviews?

Point the agent at real code rather than general questions. The skill works best on specific async functions and components, where it can check for try-catch, Promise rejection handling, and Error Boundaries.

Treat the output as a review checklist. Confirm each finding against the code, and keep the re-throw or handle rule in mind: errors should be re-thrown or handled, never silently swallowed.

• Name one file or component per request
• Ask for both the finding and the suggested fix
• Verify changes with your own tests and a browser check