skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
laurigates/claude-plugins61 installs

code-review

Code review for quality, security, performance, and architecture. Use when reviewing code, auditing OWASP, checking SOLID, or finding perf bottlenecks and test gaps.

How do I install this agent skill?

npx skills add https://github.com/laurigates/claude-plugins --skill code-review
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The skill provides a comprehensive code review workflow, utilizing a sub-agent to audit code for quality, security, and performance. It includes a re-verification step to ensure accuracy and uses standard file-system tools. No malicious activities or significant security risks were found.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

  • Runlayerpass

    1 file scanned · No issues

What does this agent skill do?

When to Use This Skill

Use this skill when...Use something else instead when...
Running an end-to-end review across quality, security, perf, and testsWalking a manual security/correctness checklist → code-review-checklist
Auditing a directory or PR delta with delegated agent analysisSpecifically scanning for code smells → code-antipatterns
Spotting missing test cases or weak assertionsAuditing test code quality on its own → code-test-quality
Producing a consolidated review reportRefactoring after the review surfaces issues → code-refactor

Context

  • Review path: $1 (defaults to current directory if not specified)

Parameters

  • $1: Path to review (defaults to current directory)

Your task

Delegate this task to the agents-plugin:review agent.

Use the Agent tool with subagent_type: agents-plugin:review to perform a comprehensive code review.

First, use the Glob tool to discover source files to review:

  • **/*.py, **/*.js, **/*.ts, **/*.go, **/*.rs for source files
  • **/*test* patterns for test files Then pass the discovered files to the agent.

The code-review agent should:

  1. Analyze code quality:

    • Naming conventions and readability
    • Code structure and maintainability
    • SOLID principles adherence
  2. Security assessment:

    • Input validation vulnerabilities
    • Authentication and authorization issues
    • Secrets and sensitive data exposure
  3. Performance evaluation:

    • Bottlenecks and inefficiencies
    • Memory usage patterns
    • Optimization opportunities
  4. Architecture review:

    • Design patterns usage
    • Component coupling
    • Dependency management
  5. Test coverage gaps:

    • Missing test cases
    • Edge cases not covered
    • Integration test needs
  6. Apply fixes where appropriate and safe

  7. Re-verify each candidate finding (false-positive gate — run BEFORE reporting): For every candidate finding from steps 1–5, re-read the cited code at the reported file:line and confirm the claim actually holds against the current source — not against a remembered or assumed shape. A finding survives only if the re-read confirms it; drop the rest. See "Re-verification Pass" below.

  8. Score every surviving finding against the anchors below:

    • Assign a severity (Critical/High/Medium/Low) using the "Severity Rubric".
    • Assign a confidence (High/Medium/Low) using the "Confidence Scale", and drop or explicitly flag findings below the reporting threshold.
  9. Generate report with:

    • Surviving findings ranked most-severe first, each carrying its severity, confidence, and verified file:line
    • Summary of issues found/fixed
    • Remaining manual interventions needed
    • Improvement recommendations

Provide the agent with:

  • The review path from context
  • Project type (language/framework)
  • Any specific focus areas requested

The agent has expertise in:

  • Multi-language code analysis (Python, TypeScript, Go, Rust)
  • LSP integration for accurate diagnostics
  • Security vulnerability patterns (OWASP)
  • Performance analysis and optimization

Severity Rubric

Score every surviving finding against these anchors. Rank the report most-severe first.

SeverityCriteria
CriticalExploitable security hole, data loss/corruption, or a crash on a common path. Ship-blocker — must fix before merge.
HighA real correctness bug that misbehaves on realistic input, a serious perf regression (N+1, unbounded growth), or an auth/validation gap without a known exploit. Fix before merge.
MediumBug on an edge case, missing error handling, a test gap over important behavior, or a maintainability problem that will bite soon. Fix or file a follow-up.
LowStyle, naming, minor readability, or a nit with no behavioral impact. Optional.

Confidence Scale

Assign each finding a confidence and let it gate what reaches the report. A finding whose defect you cannot demonstrate from the code in front of you is a guess, and guesses erode trust in the review.

ConfidenceMeaningReporting rule
HighThe defect is provable from the cited code — you can name the input and the wrong result.Report.
MediumThe defect is likely but depends on context you could not fully see.Report, labeled as needing confirmation.
LowSpeculative — a hunch not grounded in the code as read.Drop, or downgrade to a one-line "consider checking X" note; never present as a defect.

The reporting threshold is Medium: report High and Medium findings; do not present Low-confidence hunches as findings.

Re-verification Pass

Before the report step, re-check every candidate finding against the actual code. This kills false positives mechanically rather than trusting the initial read:

  1. Re-open the finding's file:line with Read and confirm the cited code still says what the finding claims (line numbers drift; assumptions decay).
  2. Confirm the failure the finding describes is reachable — name the concrete input or state that triggers it. If you cannot, it is Low confidence.
  3. Keep only findings that survive both checks. Every reported finding must carry a verified file:line, a severity, and a confidence.

Agent Teams (Optional)

For comprehensive review of large codebases, spawn specialized review teammates in parallel:

TeammateFocusValue
Security reviewerOWASP, secrets, auth flawsDeep security analysis without blocking quality review
Performance reviewerN+1 queries, algorithmic complexity, resource leaksPerformance-focused review in parallel
Correctness reviewerLogic errors, edge cases, type safetyFunctional correctness in parallel

This is optional — the skill works without agent teams for standard reviews.

Related Configure Skills

  • If security scanning not configured → /configure:security
  • If linting not set up → /configure:linting
  • If test coverage not tracked → /configure:coverage

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/laurigates/claude-plugins/code-review">View code-review on skillZs</a>