home / skills / basedhardware / omi / agent-review

agent-review skill

safe

/.cursor/skills/agent-review

This skill helps you review agent-generated code and local changes to catch bugs before merging.

npx playbooks add skill basedhardware/omi --skill agent-review

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

1.6 KB

---
name: agent-review
description: "Agent Review workflows and best practices for catching bugs before merging. Use for reviewing agent-generated code and local changes."
---

# Agent Review Skill

Workflows and best practices for using Agent Review to catch bugs before merging.

## When to Use

Use this skill when:
- Agent has generated code changes
- You have local changes to review
- Before creating a PR
- After significant refactoring
- When you want a second opinion on code

## Capabilities

### Review Agent-Generated Code

- Click "Review" in agent diff
- Click "Find Issues" to analyze edits
- Review flagged issues
- Address critical issues
- Accept changes when satisfied

### Review All Local Changes

- Open Source Control tab
- Run Agent Review on all changes
- Review issues across all files
- Fix issues before committing

## What Agent Review Catches

- Logic bugs and edge cases
- Security vulnerabilities
- Architecture violations
- Missing error handling
- Test coverage gaps
- Performance issues

## Best Practices

### Before Review

1. Complete your changes
2. Run tests
3. Format code
4. Quick manual review

### During Review

1. Address critical issues first
2. Review suggestions carefully
3. Test fixes
4. Use selective acceptance

### After Review

1. Re-run tests
2. Re-review if needed
3. Create PR

## Integration

**Workflow:**
1. Use Agent Review locally
2. Create PR
3. Bugbot reviews PR automatically
4. Address any additional issues

## Related Resources

- Rule: `.cursor/rules/agent-review.mdc`
- Command: `/review-changes`
- `.cursor/BUGBOT.md` - Bugbot review rules

Overview

This skill helps you run Agent Review workflows and apply best practices to catch bugs before merging. It focuses on reviewing agent-generated code and local changes, surfacing logic, security, and performance issues so you can fix them early. Use it to streamline pre-PR checks and improve code quality in mobile and wearable apps.

How this skill works

Agent Review inspects diffs and full local changes to flag problems like logic errors, missing error handling, security vulnerabilities, and architecture violations. Run reviews from your source-control view or an agent diff, examine flagged issues, test suggested fixes, and accept or reject changes selectively. It integrates into a local workflow that feeds into your PR process for automated follow-up reviews.

When to use it

After an agent generates code changes
Before opening a pull request
When you have local edits to validate
After major refactors or feature merges
When you want a second opinion on tricky logic

Best practices

Finish your coding and run the test suite before review
Format and lint code to reduce noise in findings
Manually scan critical paths before running automated review
Prioritize and fix critical/severe issues first
Re-run tests and re-review after applying fixes

Example use cases

Reviewing agent-generated Dart changes in a Flutter wearable app before committing
Running a full local-change review to catch security and performance regressions
Using selective acceptance to merge safe suggestions and reject risky edits
Triggering a follow-up automated PR review after local fixes are pushed
Validating error handling and edge cases added during refactoring

FAQ

What types of issues will this review catch?

It finds logic bugs, missing error handling, security vulnerabilities, architecture violations, test coverage gaps, and performance concerns.

How does this fit into a PR workflow?

Run Agent Review locally, fix issues, create the PR, then let automated reviewers perform an additional pass and address any remaining findings.