Skip to content
Skills Library
Programming · Review & audit

code-review

/code-review

Use to review code changes with a two-stage process - first checking spec/requirements compliance, then code quality. Works on staged changes, branches, or PRs.

Licence
Apache-2.0
Last repository change
27.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

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

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use to review code changes with a two-stage process - first checking spec/requirements compliance, then code quality. Works on staged changes, branches, or PRs.

Arguments

/code-review [branch name, PR number, or file paths]
Original author description

Use to review code changes with a two-stage process - first checking spec/requirements compliance, then code quality. Works on staged changes, branches, or PRs.

How it works

  1. When to Use
  2. Usage
  3. Stage 1: Spec Compliance Review
  4. Stage 2: Code Quality Review
  5. Reviewing GitHub PRs
Original SKILL.md headings · 155 lines, 831 words
SKILL.md preview
---
name: code-review
description: Use to review code changes with a two-stage process - first checking spec/requirements compliance, then code quality. Works on staged changes, branches, or PRs.
user-invocable: true
argument-hint: "[branch name, PR number, or file paths]"
---

# Code Review for OpenMetadata

Two-stage review process: requirements compliance first, then code quality.

**The bar is `REVIEW.md` at the repository root.** Read it first. Its "How to review" order, its
finding format (trigger → result → fix), its test and flaky-test shapes and its "Do not report" list
override the generic checklist below wherever they differ.

## When to Use

- Before creating a PR
- Reviewing someone else's PR
- Self-checking your own changes before requesting review

## Usage

```
/code-review                    # Review uncommitted changes
/code-review feature-branch     # Review branch diff against main
/code-review #1234              # Review GitHub PR
/code-review path/to/file.java  # Review specific files
```

## Stage 1: Spec Compliance Review

Verify the changes do what they're supposed to do — no more, no less.

### Steps

1. **Understand the goal.** Read the PR description, issue, or ask the user what the change is supposed to accomplish.
2. **Read all changed files.** Use `git diff` to see the full scope:
   ```bash
   git diff main...HEAD          # Branch diff
   git diff --staged             # Staged changes
   gh pr diff <number>           # PR diff
   ```
3. **Check completeness against requirements:**
   - Does every stated requirement have a corresponding code change?
   - Are there missing pieces? (e.g., backend change without migration, API change without UI update)
4. **Check for scope creep:**
   - Are there changes unrelated to the stated goal?
   - Was code "improved" that didn't need to change?
5. **Check the cross-layer contract:**
   - Schema change (`openmetadata-spec/`) + model regeneration (`make generate`)
   - Backend API change + frontend API client update
   - New entity field + database migration (`bootstrap/sql/`)
   - New connection config + `yarn parse-schema` for UI forms

### Report Format (Stage 1)

```
## Spec Compliance: [PASS / FAIL / PARTIAL]

### Requirements Met
- [x] Requirement A — implemented in file.java:42
- [ ] Requirement B — MISSING: no migration for new field

### Scope Issues
- file.java:100-120 — unrelated refactor, consider separate PR

### Cross-Layer Gaps
- Schema updated but `make generate` not run (models out of sync)
```

**If Stage 1 fails, stop here.** Fix compliance issues before reviewing quality.

## Stage 2: Code Quality Review

Now review the implementation quality.

### Checklist

**Architecture:**
- [ ] Follows existing patterns in the module (check similar implementations)
- [ ] No new dependencies that duplicate existing functionality
- [ ] Connector-specific logic stays in connector-specific files (not in shared `builders.py`)

**Java:**
- [ ] No wildcard imports (`import java.util.*`)
- [ ] No unnecessary comments on obvious code
- [ ] `mvn spotless:apply` has been run
- [ ] Integration tests for new API endpoints (in `openmetadata-integration-tests/`)
- [ ] Proper error handling with meaningful messages

**Python:**
- [ ] pytest style (plain `assert`, no `unittest.TestCase`)
- [ ] Type hints on public functions
- [ ] `make py_format && make py_format_check` passes
- [ ] Pydantic 2.x patterns (not v1 compatibility layer)

**TypeScript/React:**
- [ ] No `any` types — use proper types or `unknown` with type guards
- [ ] Tailwind classes use `tw:` prefix
- [ ] Strings use i18n (`t('label.xxx')`) not string literals
- [ ] CSS custom properties for colors/spacing, no hardcoded values
- [ ] Loading states and error handling with `showErrorToast`/`showSuccessToast`

**Testing (use `/test-enforcement` for full analysis; `REVIEW.md` § Tests lists the shapes reviewers reject):**
- [ ] 90% line coverage on changed Java classes
- [ ] Integration tests for new/changed API endpoints
- [ ] Jest tests for new/changed React components
- [ ] Playwright E2E tests for new user-facing features
- [ ] Tests verify behavior, not implementation

**Security:**
- [ ] No hardcoded secrets or credentials
- [ ] User input validated at system boundaries
- [ ] No SQL injection vectors (parameterized queries)
- [ ] No XSS vectors in frontend (proper escaping)

**Decisions (`docs/decisions/`, rules in its `README.md`):**
- [ ] No change undoes an Accepted record without adding the record that supersedes it
- [ ] A durable decision — a contract another component or repo must agree with, a new default or limit, an ordering that must hold, a rule stated only in the PR description — ships its record in this PR

### Report Format (Stage 2)

```
## Code Quality: [GOOD / NEEDS WORK / SIGNIFICANT ISSUES]

### Issues (must fix)
- file.java:42 — wildcard import, use specific imports
- Component.tsx:15 — `any` type, use `EntityReference` from generated types

### Suggestions (nice to have)
- connector.py:80 — could use `yield from` instead of loop

### Positive Notes
- Good test coverage for the new endpoint
- Follows existing pagination pattern correctly
```

## Reviewing GitHub PRs

When reviewing a GitHub PR by number:

```bash
# Get PR details
gh pr view <number>

# Get the diff
gh pr diff <number>

# Get review comments
gh api repos/{owner}/{repo}/pulls/<number>/comments

# Check CI status
gh pr checks <number>
```

After review, optionally post findings:
```bash
gh pr review <number> --comment --body "Review findings..."
```

Versions

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

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 57e9ac31879d (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

  • 100review
    Two-stage code review: spec compliance first, then code quality. Auto-triggered after implementation. Also available as /review.
  • 100ql-review
    Part of the quantum-loop autonomous development pipeline (brainstorm \u2192 spec \u2192 plan \u2192 execute \u2192 review \u2192 verify). Two-stage code review. Spec compliance first, then code quality. Use after implementation or before merge. Triggers on: review code, code…
  • 96skill-staged-review
    Use when a PR or feature needs both specification and code-quality review
  • 100pr-review
    Comprehensive, project-agnostic pull request review workflow. Use when reviewing PRs, checking code quality, validating implementations against specs, or deciding whether to approve, request changes, or ask for discussion.
  • 100review-code
    Perform a senior-engineer code review when the user asks to review code, review a PR, review changes, or check code quality
  • 100review-plan
    Use when a Plan is complete and ready for review. Two-stage review -- spec contract compliance first, code quality second. Block on contract failure before reviewing code.

Feedback and reports

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