Skip to content
Skills Library
Programming · Review & audit

code-review

/code-review

Structured code review protocol for inspecting code quality against the full rule set. Use when auditing code written by yourself or another agent, during the /audit skill, or when the user asks for a code review.

Repository
awesome-agv ↗
Licence
MIT
Last repository change
15.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
13
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 15.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Structured code review protocol for inspecting code quality against the full rule set. Use when auditing code written by yourself or another agent, during the /audit skill, or when the user asks for a code review.

Original author description

Structured code review protocol for inspecting code quality against the full rule set. Use when auditing code written by yourself or another agent, during the /audit skill, or when the user asks for a code review.

How it works

  1. Purpose
  2. When to Invoke
  3. Review Process
  4. Rule Compliance
  5. Quick Reference Audit Checklist
Original SKILL.md headings · 174 lines, 955 words
SKILL.md preview
---
name: code-review
description: Structured code review protocol for inspecting code quality against the full rule set. Use when auditing code written by yourself or another agent, during the /audit skill, or when the user asks for a code review.
---

# Code Review Skill

## Purpose
Systematically review code against the full antigravity rule set. Catches issues that linters miss: architectural violations, missing observability, business logic errors, pattern inconsistencies.

## When to Invoke
- During the `/audit` skill (as part of parallel subagent dispatch)
- When user asks for a code review outside any workflow
- **Best practice:** Invoke in a fresh conversation (not the same one that authored the code) to avoid confirmation bias

## Review Process

### 1. Scope the Review
Identify the files/features to review. Determine the review scope:
- **Feature review** — all files in a feature directory
- **PR review** — only changed files
- **Full codebase audit** — all features

### 2. Load the Rule Set
Read all applicable rules from `.agents/rules/`. Use `rule-priority.md` for severity classification.

### 3. Review Categories (Priority Order)

Review each file/feature against these categories, in order from `rule-priority.md`:

#### Critical (Must Fix)
- **Security** — injection, hardcoded secrets, broken auth
- **Data loss** — missing error handling on writes, no transaction boundaries
- **Resource leaks** — unclosed connections, missing cleanup

#### Major (Should Fix)
- **Testability** — I/O not behind interfaces, untested error paths
- **Observability** — missing logging on operations, no correlation IDs
- **Error handling** — empty catch blocks, swallowed errors
- **Architecture** — circular dependencies, wrong layer access

#### Minor (Nice to Fix)
- **Pattern consistency** — deviation from established codebase patterns
- **Naming** — unclear variable/function names
- **Code organization** — functions too long, mixed responsibilities

#### Enhancement (Backlog)
- **Style** — formatting issues or non-critical refactorings
- **Documentation** — missing comments on complex logic

### 4. Produce Findings

Output a structured findings document:

```markdown
# Code Review: {Feature/Module Name}
Date: {date}
Reviewer: AI Agent (fresh context)

## Summary
- **Files reviewed:** N
- **Issues found:** N (X critical, Y major, Z minor, W enhancement)

## Critical Issues
- [ ] **[SEC]** {description} — [{file}:{line}](file:///path)
- [ ] **[DATA]** {description} — [{file}:{line}](file:///path)

## Major Issues
- [ ] **[TEST]** {description} — [{file}:{line}](file:///path)
- [ ] **[OBS]** {description} — [{file}:{line}](file:///path)

## Minor Issues
- [ ] **[PAT]** {description} — [{file}:{line}](file:///path)

## Enhancement Issues
- [ ] {description} — [{file}:{line}](file:///path)

## Rules Applied
List of rules referenced during this review.
```

### 5. Save the Report

When invoked via the `/audit` skill, you **MUST** persist the findings to the repo:

**Path:** `docs/audits/review-findings-{feature}-{YYYY-MM-DD}-{HHmm}.md`

1. Create `docs/audits/` if it doesn't exist
2. Write the findings document to that path
3. This makes the report accessible from other conversations and agents

When invoked as a standalone review (not via `/audit`), saving to `docs/audits/` is recommended but optional.

### 6. Severity Tags

| Tag      | Category             | Rule Source                                        |
| -------- | -------------------- | -------------------------------------------------- |
| `[SEC]`  | Security             | `security-principles.md`                           |
| `[DATA]` | Data integrity       | `error-handling-principles.md`                     |
| `[RES]`  | Resource leak        | `resources-and-memory-management-principles.md`    |
| `[TEST]` | Testability          | `architectural-pattern.md`, `testing-strategy.md`  |
| `[OBS]`  | Observability        | `logging-and-observability-mandate.md`             |
| `[ERR]`  | Error handling       | `error-handling-principles.md`                     |
| `[ARCH]` | Architecture         | `architectural-pattern.md`, `project-structure.md` |
| `[PAT]`  | Pattern consistency  | `code-organization-principles.md`                  |
| `[INT]`  | Integration contract | `api-design-principles.md`                         |
| `[DB]`   | Database design      | `database-design-principles.md`                    |
| `[CFG]`  | Configuration        | `configuration-management-principles.md`           |
| `[SPEC]` | Spec compliance      | `structured-spec` profiles                         |

### 7. Language-Specific Anti-Patterns

Load the anti-pattern checklist for the language(s) under review:

| Language | Anti-Patterns |
|---|---|
| **Go** | `languages/go.md` |
| **TypeScript** | `languages/typescript.md` |
| **Python** | `languages/python.md` |
| **Rust** | `languages/rust.md` |
| **Java** | `languages/java.md` |
| **C#** | `languages/csharp.md` |
| **Swift** | `languages/swift.md` |
| **Flutter/Dart** | `languages/flutter.md` |
| **C++** | `languages/cpp.md` |
| **Kotlin** | `languages/kotlin.md` |
| **PHP** | `languages/php.md` |
| **Ruby** | `languages/ruby.md` |

> Anti-patterns listed in language files are **auto-fail** — they require no judgment call. If the pattern exists in the code, it is a finding.

### 8. Cross-Boundary Checks

For full audits, cross-boundary concerns (integration contracts, database schema, configuration hygiene, dependency health, test coverage gaps) are checked via the dedicated MECE dimension scope cards in the `/audit` skill (Dimension F & G) — defined in `.agents/skills/audit/references/audit-dimensions.md`.

When invoking this skill standalone (outside `/audit`), apply the applicable dimensions from that checklist manually and tag findings with `[INT]`, `[DB]`, or `[CFG]` as appropriate.

When structured specs exist in the repository (files with structured-spec YAML frontmatter), verify that:
- Contracts declared in specs (`CT-*`) are implemented in code
- Tests declared in specs (`TC-*`) exist and pass
- No requirement (`REQ-*`) is unimplemented without documented rationale
Tag findings with `[SPEC]`.

**Zero-Findings Guard:** If this review produces fewer than 3 findings, you MUST produce a "Dimensions Covered" attestation section in the findings document, listing each cross-boundary dimension and the specific files or queries you examined. Only then may you declare a clean result.

---

## Rule Compliance
This skill enforces all rules in `.agents/rules/`. Key references:
- Rule Priority @rule-priority.md (severity classification)
- Security Principles @security-principles.md
- Architectural Patterns @architectural-pattern.md
- Testing Strategy @testing-strategy.md
- Logging and Observability Mandate @logging-and-observability-mandate.md
- Error Handling Principles @error-handling-principles.md

## Quick Reference Audit Checklist

Consolidated from rule-based checklists. Use as a rapid scan after detailed review.

### Architecture *(from architectural-pattern.md)*
- [ ] I/O behind interfaces; pure business logic; dependencies point inward

### Database *(from database-design-principles.md)*
- [ ] Parameterized queries; migrations reversible; indexes documented

### Dependencies *(from dependency-management-principles.md)*
- [ ] Versions pinned; lock file committed; unused deps removed

### Git *(from git-workflow-principles.md)*
- [ ] Conventional commits; no large binaries; .gitignore complete

### Monitoring *(from monitoring-and-alerting-principles.md)*
- [ ] Health endpoint; key metrics instrumented; alerting rules defined

### Performance *(from performance-optimization-principles.md)*
- [ ] No premature optimization; profiling before tuning; budgets defined
Files in this package (13)
  • SKILL.md 8 KB
  • languages/cpp.md 4 KB
  • languages/csharp.md 4 KB
  • languages/flutter.md 5 KB
  • languages/go.md 3 KB
  • languages/java.md 4 KB
  • languages/kotlin.md 4 KB
  • languages/php.md 4 KB
  • languages/python.md 5 KB
  • languages/ruby.md 4 KB
  • languages/rust.md 5 KB
  • languages/swift.md 4 KB
  • languages/typescript.md 6 KB

Versions

RepositoryScoreLicence
This page · irahardianto/awesome-agv100MIT
microsoft/aspire100MIT
kdlbs/kandev100AGPL-3.0
dotnet/runtime100MIT
drosam/agents100MIT
ggml-org/llama.cpp100MIT
ShamelesAbyss/Nyx100Apache-2.0
dzhng/jevgrep100MIT
iuliandita/skills100MIT

Database snapshot: 13.11.2026 · package version 01b3f1cfb82c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100code-review-and-quality
    Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.
  • 100code-review-and-quality
    Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.
  • 90code-review-and-quality
    Conducts multi-axis code review across correctness, readability, architecture, security, and performance. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Triggers on "review my PR", "review this diff", "code review", "review…
  • 100code-review-and-quality
    Use when reviewing code before it merges, whether written by an agent or a human.
  • 100review-code
    Perform a senior-engineer code review when the user asks to review code, review a PR, review changes, or check code quality
  • 100code-scorecard
    Use when asked for a codebase scorecard, quality audit, 9-dimension assessment, post-merge/refactor/release health review, or due-diligence review.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.