code-review
by alinaqicode-review is a mandatory review workflow for code changes before commits and deploys. It helps teams run a structured /code-review step, choose an engine, and get actionable feedback instead of a generic pass. Ideal for pre-merge checks, release candidates, and high-stakes refactors.
This skill scores 68/100, which means it is list-worthy but best framed as a practical, somewhat opinionated code-review workflow rather than a fully polished turnkey package. Directory users get enough evidence to understand when it triggers and what it does, but should expect to rely on the skill body for operational details rather than external helpers or scripts.
- Clear triggerability: frontmatter says it is user-invocable and intended for use when the user asks to review code, before commits, or when /code-review is invoked.
- Substantial workflow content: the SKILL.md body is large, with many headings plus scope, workflow, constraints, and practical signals, indicating real procedural guidance rather than a stub.
- Low placeholder risk: no placeholder markers or experimental/test-only signals were detected, so the listing appears to describe an actual usable workflow.
- No install command or support files are provided, so adoption depends entirely on reading and following the markdown skill itself.
- The skill appears opinionated and tool-choice driven, but the evidence does not show external automation or reusable scripts, which may limit consistency across environments.
Overview of code-review skill
The code-review skill is a mandatory review workflow for code changes before commits and deploys. It is most useful for developers and teams who want a repeatable /code-review step that turns a rough change set into a structured review pass, rather than relying on a generic “looks fine” prompt.
What makes the code-review skill useful is its engine-selection approach: it lets you route reviews through Claude, OpenAI Codex, Google Gemini, or a multi-engine workflow depending on the size, risk, and complexity of the change. That makes it a better fit when review quality matters more than speed, especially for pre-merge checks, release candidates, and high-stakes refactors.
It is not just a checklist. The code-review skill is designed to be invoked at the point where you already have changed files, diffs, or a clear review target, so it can produce feedback that is actionable enough to block or approve a change.
Who should install code-review
Install the code-review skill if you want a consistent review gate for an AI-assisted or tool-assisted development workflow. It is especially relevant for solo developers, small teams, and agents that need a predictable review step before shipping code.
If your process already requires code review but the execution is ad hoc, this skill gives you a clearer operating pattern. If you only want occasional style feedback on snippets, a normal prompt is usually enough.
What problem it solves
The main job-to-be-done is reducing review ambiguity. Instead of asking “can you review this code?” and getting a vague pass, the code-review skill helps you define engine choice, scope, and expected rigor so the review is more likely to catch real issues.
That matters when you need:
- a pre-commit review gate
- a deployment safety check
- a second-pass review after a large change
- a broader pass across correctness, maintainability, and risk
Why it stands out
The code-review skill is decision-oriented. Its most practical differentiator is the ability to choose the review engine rather than locking you into one model or one style of analysis.
That gives you a useful tradeoff:
- Claude for local context and convenience
- Codex for code-focused review workflows
- Gemini for larger context windows
- multiple engines when you want cross-checking
How to Use code-review skill
Install and trigger the skill
Use the repository’s skill installation flow for your environment, then invoke /code-review when you have code to inspect. The skill is user-invocable, so it is meant to be called directly as part of your workflow rather than hidden inside a broader assistant prompt.
The repository excerpt points to allowed-tools: [Read, Glob, Grep, Bash], which signals that the skill is intended to inspect files and surrounding context, not just read a pasted snippet.
Give the skill review-ready input
The code-review skill works best when you provide the exact review target and the reason for review. Strong input usually includes:
- the branch, PR, or commit range
- the files changed
- the type of change: bug fix, refactor, feature, dependency update
- the risk level: low, medium, high
- the review focus: correctness, security, tests, API behavior, performance
A weak prompt is: “Review my code.”
A stronger prompt is: “Run /code-review on the auth refactor in src/login.ts and src/session.ts. Focus on regressions, edge cases, and test gaps before I merge to main.”
Read the right files first
Start with SKILL.md, because it defines the workflow and engine choice. Then inspect any repository instructions that shape how the skill should behave in your environment, including README.md, AGENTS.md, metadata.json, and any supporting folders if they exist.
In this repository, the core guidance appears to live in SKILL.md, so the practical install decision is straightforward: if you want the review workflow, that file is the main source of truth.
Use the engine choice intentionally
The code-review skill is strongest when you choose the review engine based on the change, not habit. For example:
- use the default engine when you want a fast, integrated review
- use Codex when you want code-specialized analysis
- use Gemini when long context is the bottleneck
- use multiple engines when you need higher confidence on risky changes
If you do not specify why an engine is being used, the review can become generic. Tell the skill whether you care most about depth, breadth, or context size.
code-review skill FAQ
Is code-review better than a normal prompt?
Yes, when you need a repeatable review workflow. A normal prompt can review code, but the code-review skill gives you a structured entry point, engine selection, and a clearer pre-commit or pre-deploy use case.
Is the code-review skill beginner-friendly?
Mostly yes, if you can identify the files or change set being reviewed. The skill is easier to use when you already know what changed and what you want checked. It is less helpful if you have no diff, no context, and no specific question.
When should I not use code-review?
Do not use it if you only need a quick explanation of a small snippet or if you are still exploring an idea and do not want a formal review pass. It is also not the best fit for non-code content, because its value comes from inspecting actual code changes.
Does code-review fit agentic workflows?
Yes. The code-review skill is a good fit for agent workflows because it can be called as a guardrail before commits and deploys. That makes it useful when the assistant is expected to produce and then validate code in the same session.
How to Improve code-review skill
Give the review a narrower target
The biggest quality gain comes from reducing ambiguity. Instead of asking for a whole-repo review, scope the task to a commit, diff, folder, or feature boundary. The code-review skill works better when it knows what changed and what “good” means for that change.
State the risk you care about
The best code-review outputs come from explicit priorities. Say whether you want the skill to look for logic bugs, regressions, security issues, test coverage gaps, API breakage, or maintainability problems. If you do not say, the review may spread attention too thin.
Ask for a decision, not just comments
If your goal is a deploy gate, ask the code-review skill to classify findings by severity and to say whether the change is safe to merge. That produces more useful output than a loose list of observations.
Iterate after the first pass
If the first review finds issues, feed the follow-up with the fixes and ask for a second /code-review pass on the updated diff. The skill is most valuable as a loop: review, patch, re-review. That is how you turn code-review from a one-off prompt into a reliable release habit.