What types of feedback can I get with Agent Review?

You can receive feedback on code quality, security vulnerabilities, performance optimizations, and architectural decisions.

How do I specify which code to review?

You can pipe code directly into the command or specify a file path using the `--file` option.

Can I use different AI models for reviews?

Yes, you can choose from various models like Gemini, Codex, and Claude by using the `--model` option.

Is there a way to get feedback on specific lines of code?

Yes, you can use the `--lines` option to review specific lines within a file.

Do I need an API key to use this skill?

You need an OpenRouter API key for non-Anthropic models. Anthropic models use your local subscription.

Agent Review

Name: Agent Review
Availability: InStock
Author: civitai

Free

Get AI-driven feedback on your code and architecture.

by civitai7.2k stars on civitai/civitai

Updated Aug 10, 2026

Get this skill

Free · Opens the source repo

What Agent Review does

Agent Review is a skill designed for developers seeking external feedback on their code and architectural decisions. By leveraging AI models, it provides insights into code quality, security vulnerabilities, and performance optimizations. The skill routes requests through the Claude Agent SDK for Anthropic models or the OpenRouter API for other models, allowing users to choose the best tool for their needs. This flexibility makes it suitable for various scenarios, from code reviews to architecture validation.

The skill operates through a command-line interface, where users can pipe code directly or specify files for review. Options include selecting specific lines to analyze, providing additional context files, and customizing the AI's response style through temperature settings. This level of control enables developers to tailor the feedback they receive, whether they need a detailed security audit or a high-level architectural critique.

Agent Review is particularly beneficial for teams looking to enhance their development processes. It serves as a second opinion on critical code segments, helping to identify potential issues before they escalate. Additionally, it can assist in validating design choices, ensuring that documentation is clear, and identifying gaps in test coverage. By integrating this skill into their workflow, developers can improve code quality and make informed architectural decisions with the support of AI.

Overall, Agent Review is an invaluable tool for developers and designers who want to leverage AI to enhance their work. It simplifies the process of obtaining expert feedback, making it easier to maintain high standards in coding and design practices.

When to use it

Use this skill when you need an external review of your code or architecture, especially for security, performance, or design validation.

When not to use it

This skill may not be suitable for quick, informal reviews or for scenarios where human judgment is essential beyond AI capabilities.

What you can build with it

Code Security Review

Analyze authentication code for potential security vulnerabilities before deployment.

Architecture Validation

Get feedback on a proposed architecture design to identify potential issues.

Performance Optimization Suggestions

Request performance improvement suggestions for a specific algorithm or component.

How to install Agent Review

View source

1. Install with the skills CLI

npx skills add civitai/civitai/agent-review --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by civitai

Agent Review

Get feedback from an external AI agent. Useful for code review, architecture decisions, or getting a second opinion.

Running Commands

echo "code or prompt" | node .claude/skills/agent-review/query.mjs [options] "Your question"
# or
node .claude/skills/agent-review/query.mjs --file <path> [options] "Your question"

Options

Flag	Short	Description
`--model <model>`	`-m`	Model or alias (default: gemini)
`--file <path>`	`-f`	Read input from file instead of stdin
`--lines <start-end>`	`-l`	Extract specific lines from file (e.g., 50-100)
`--context <path>`	`-c`	Additional context file (can repeat)
`--system <prompt>`	`-s`	Custom system prompt
`--temperature <n>`	`-t`	Temperature 0-1 (default: 0.7)
`--quiet`	`-q`	Suppress status messages and usage stats
`--list`		List available models
`--json`		Output raw JSON response

Available Models

Model ID	Aliases	Provider	Notes
`google/gemini-3-pro-preview`	`gemini`, `g3`	OpenRouter	Default - good for external perspective
`openai/gpt-5.1-codex`	`gpt`, `codex`, `gpt5`	OpenRouter	Strong at code analysis
`anthropic/claude-opus-4.5`	`opus`, `claude-opus`	Agent SDK	Uses local subscription
`anthropic/claude-sonnet-4.5`	`sonnet`, `claude`	Agent SDK	Uses local subscription

Anthropic models route through Claude Agent SDK (uses your Claude subscription). Other models route through OpenRouter API (requires OPENROUTER_API_KEY).

Environment Variables

Variable	Required	Description
`OPENROUTER_API_KEY`	For non-Anthropic models	OpenRouter API key
`AGENT_REVIEW_DEFAULT_MODEL`	No	Override default model

Examples

Code Review

# Review a file for security issues
cat src/server/auth.ts | node .claude/skills/agent-review/query.mjs \
  "Review this authentication code for security vulnerabilities"

# Review with a specific model (using alias)
node .claude/skills/agent-review/query.mjs -m gpt -f src/utils/parser.ts \
  "Review this parser for edge cases and error handling"

Reviewing Specific Lines

# Review a specific function (lines 50-100)
node .claude/skills/agent-review/query.mjs \
  -f src/server/auth.ts -l 50-100 \
  "Review this authentication function for security issues"

# Review a single line
node .claude/skills/agent-review/query.mjs \
  -f src/utils/parser.ts -l 42 \
  "Is this regex safe from ReDoS attacks?"

With Context Files

# Review code with type definitions as context
node .claude/skills/agent-review/query.mjs \
  -f src/api/routes.ts \
  -c src/types/api.ts \
  -c src/types/models.ts \
  "Review this API implementation"

# Review component with its hooks as context
node .claude/skills/agent-review/query.mjs \
  -f src/components/UserProfile.tsx \
  -c src/hooks/useUser.ts \
  "Review this React component for performance issues"

Architecture Feedback

# Get feedback on a proposed design
cat docs/design-proposal.md | node .claude/skills/agent-review/query.mjs \
  "What are the potential issues with this architecture?"

Custom System Prompt

node .claude/skills/agent-review/query.mjs \
  -f src/api/routes.ts \
  -s "You are a security expert specializing in API design" \
  "Audit this API for OWASP top 10 vulnerabilities"

Temperature Control

# Lower temperature for more deterministic analysis
node .claude/skills/agent-review/query.mjs -t 0.2 -f src/algo.ts \
  "Analyze the time complexity"

# Higher temperature for creative suggestions
node .claude/skills/agent-review/query.mjs -t 0.9 -f src/ui.tsx \
  "Suggest ways to improve the user experience"

Using Anthropic Models (Local Subscription)

# Uses Claude Agent SDK - no API credits consumed
node .claude/skills/agent-review/query.mjs -m opus -f complex-algorithm.ts \
  "Analyze the time complexity and suggest optimizations"

Quiet Mode (for scripting)

# Suppress all status messages, only output the response
REVIEW=$(node .claude/skills/agent-review/query.mjs -q -f src/auth.ts \
  "List security issues as JSON array")
echo "$REVIEW" | jq .

Output

The response text is written to stdout. After the response, usage stats are shown on stderr:

Tokens: 189 in / 871 out (1060 total)
Cost: $0.0108

This helps track token consumption and costs for OpenRouter requests. Use --quiet to suppress.

When to Use

Code Review: Get a second opinion on code quality, security, or performance
Architecture Decisions: Validate design choices with another perspective
Bug Analysis: Share error context and get debugging suggestions
Documentation Review: Check if docs are clear and complete
Test Coverage: Identify missing test cases

Tips

Default model (Gemini 3 Pro) is recommended for most external reviews
Use Anthropic models when you want consistency with Claude's style
Use -l to review specific functions without sending the entire file (saves tokens)
Use -c to include type definitions or related files for better context
Use -t 0.2 for more focused/deterministic responses, -t 0.8 for creative suggestions
Pipe code directly for quick reviews: cat file.ts | node ... "review this"

Frequently asked questions about Agent Review

Similar skills

Quality Playbook Generator

Run comprehensive quality audits on any codebase.

PR Draft Summary

Automate PR summary generation for openai-agents-python.

Final Release Review

Streamline your release candidate audits with ease.

Unit Test Vue Pinia

Efficiently write and review unit tests for Vue 3 applications.

Slang Shader Expert

Optimize and integrate Slang shaders with ease.

Telemetry Standards

Ensure consistent event tracking in Supabase Studio.