home / skills / yellinzero / aico / code-review

code-review skill

safe

This skill performs structured code reviews to catch correctness, security, and readability issues early, guiding improvements before merging.

This is most likely a fork of the aico-code-review skill from yellinzero

npx playbooks add skill yellinzero/aico --skill code-review

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

Files (1)

SKILL.md

2.4 KB

---
name: aico-code-review
description: |
  Request structured code review to catch correctness, security, performance, and readability issues. Reviews should happen early and often.

  Use this skill when:
  - Completing a task and need quality check
  - After major feature implementation
  - Before merging to main branch
  - When stuck and need fresh perspective on code
  - User asks for "code review", "review my code", "check my code"
  - Subagent-driven workflow needs spec compliance or quality review

  Review categories: Correctness, Tests, Security, Performance, Readability, Error Handling
  Severity levels: Critical (fix now), Important (fix before proceeding), Minor (note for later)
---

# Code Review

## When to Request Review

**Mandatory:**

- After completing each task
- After implementing major feature
- Before merge to main

**Optional:**

- When stuck (fresh perspective)
- Before refactoring
- After fixing complex bug

## Review Checklist

| Category       | Check                           |
| -------------- | ------------------------------- |
| Correctness    | Does it do what it should?      |
| Tests          | Are there tests? Do they pass?  |
| Security       | Any vulnerabilities?            |
| Performance    | Any obvious bottlenecks?        |
| Readability    | Is code clear and maintainable? |
| Error Handling | Are errors handled properly?    |

## Issue Severity

| Severity      | Action                           |
| ------------- | -------------------------------- |
| **Critical**  | Fix immediately, blocks progress |
| **Important** | Fix before proceeding            |
| **Minor**     | Note for later, can proceed      |

## Review Output Template

```markdown
## Code Review: [Feature/Task Name]

### Files Modified

- `path/to/file.ts` - [what changed]

### Issues

**Critical:**

- [ ] [Issue description]

**Important:**

- [ ] [Issue description]

**Minor:**

- [ ] [Issue description]

### Assessment

- [ ] Ready to proceed
- [ ] Needs fixes (see issues above)
```

## Key Rules

- ALWAYS review after each task completion
- MUST fix Critical issues immediately
- MUST fix Important issues before proceeding
- Minor issues can be noted for later
- If reviewer is wrong, push back with technical reasoning

## Common Mistakes

- ❌ Skip review because "it's simple" → ✅ Review everything
- ❌ Ignore Critical issues → ✅ Fix immediately
- ❌ Proceed with Important issues → ✅ Fix first

Overview

This skill provides a structured, checklist-driven code review for TypeScript projects to catch correctness, security, performance, tests, readability, and error-handling issues. Reviews are concise, prioritized by severity (Critical, Important, Minor), and designed to be run early and often. The output highlights files changed, actionable issues, and a clear assessment to guide next steps.

How this skill works

Submit the feature or task context and the diff or files to inspect. The skill evaluates code against the review checklist: Correctness, Tests, Security, Performance, Readability, and Error Handling, and assigns severities to findings. It returns a compact review report with categorized issues, remediation suggestions, and a final readiness assessment. Use the report to decide whether to fix items immediately or proceed.

When to use it

After completing a task to get a quality check before moving on
After implementing a major feature and before merging to main
Before creating a pull request or merging into the main branch
When you’re stuck and need a fresh perspective on tricky code
When a subagent workflow needs spec compliance or quality validation

Best practices

Request reviews frequently—after each task or major change
Address Critical issues immediately; fix Important issues before proceeding
Include diffs and a short description of intended behavior to speed review
Provide failing tests or reproduction steps for correctness and security findings
Treat Minor items as backlog notes but triage them periodically

Example use cases

Validate a new authentication flow for security and error handling
Check a performance-sensitive TypeScript module for bottlenecks
Verify tests exist and pass after adding a feature
Review refactored code to ensure readability and unchanged behavior
Get a quick pre-merge check to avoid introducing Critical regressions

FAQ

What defines a Critical versus Important issue?

Critical issues are blockers that must be fixed immediately (security vulnerabilities, data loss risks, failing core logic). Important issues should be fixed before proceeding but are not immediate blockers (incorrect edge-case handling, missing tests).

How should I submit code for review?

Provide the diff or modified files, a brief summary of expected behavior, and any relevant tests or reproduction steps. That context lets the review focus on correctness and spec compliance.