Skip to main content
command CX Codex

full-review · ormus-solutions — Claude Code command: what it does, how to install

full-review runs a phased multi-agent code audit in Claude Code. Inspects architecture, OWASP vulnerabilities, runtime bottlenecks, and test suites.

MIT ★ 126 updated 2026-10-04

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code
/plugin install comprehensive-review@libreuiux
Open on GitHub

What full-review does

The workflow conducts code inspections across four staged phases via the Task tool. First, code quality and architecture agents run side by side to surface coupling issues, code smells, and SOLID violations. The next phase consumes those structural findings to audit OWASP vulnerabilities, exposed secrets, and database query bottlenecks.

Later phases evaluate test coverage metrics alongside documentation like OpenAPI specifications. The final step verifies idioms and standards for the target language or framework.

This command relies on dedicated subagent profiles such as code-reviewer and security-auditor. Missing subagent definitions will cause the Task calls to fail. Passing --strict-mode halts the review as soon as any critical vulnerability appears.

What it helps with

  • Audit pull requests for OWASP Top 10 vulnerabilities and leaked credentials
  • Pinpoint CPU hotspots, memory leaks, and inefficient database queries
  • Measure test suite quality and verify TDD compliance
  • Detect architectural drift, circular dependencies, and tight coupling

Example prompts for the agent

  • /full-review src/api/ --security-focus
  • /full-review PR-142 --performance-critical --strict-mode
  • /full-review ./services/auth --tdd-review --framework Django

How to install full-review

1Plugin marketplace

/plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code
/plugin install comprehensive-review@libreuiux

2Manually: put the files in place

.claude/commands/full-review.md

Call it with /full-review. For all projects use ~/.claude/commands/

Questions about full-review

How to install full-review in Claude Code?

Run /plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code in Claude Code, then execute /plugin install comprehensive-review@libreuiux.

What does full-review do?

It orchestrates specialized subagents through sequential review phases for a given path or pull request. The command evaluates code quality, security risks, scalability, and documentation.

Which review flags can be passed to full-review?

The command accepts --security-focus, --performance-critical, --tdd-review, --ai-assisted, --strict-mode, --metrics-report, and --framework [name].

Source text

full-review.md · MIT
---
description: "Run a multi-agent code review across quality, security, performance, and architecture"
argument-hint: "[path or PR] [--security-focus] [--performance-critical]"
---

Orchestrate comprehensive multi-dimensional code review using specialized review agents

[Extended thinking: This workflow performs an exhaustive code review by orchestrating multiple specialized agents in sequential phases. Each phase builds upon previous findings to create a comprehensive review that covers code quality, security, performance, testing, documentation, and best practices. The workflow integrates modern AI-assisted review tools, static analysis, security scanning, and automated quality metrics. Results are consolidated into actionable feedback with clear prioritization and remediation guidance. The phased approach ensures thorough coverage while maintaining efficiency through parallel agent execution where appropriate.]

## Review Configuration Options

- **--security-focus**: Prioritize security vulnerabilities and OWASP compliance
- **--performance-critical**: Emphasize performance bottlenecks and scalability issues
- **--tdd-review**: Include TDD compliance and test-first verification
- **--ai-assisted**: Enable AI-powered review tools (Copilot, Codium, Bito)
- **--strict-mode**: Fail review on any critical issues found
- **--metrics-report**: Generate detailed quality metrics dashboard
- **--framework [name]**: Apply framework-specific best practices (React, Spring, Django, etc.)

## Phase 1: Code Quality & Architecture Review

Use Task tool to orchestrate quality and architecture agents in parallel:

### 1A. Code Quality Analysis
- Use Task tool with subagent_type="code-reviewer"
- Prompt: "Perform comprehensive code quality review for: $ARGUMENTS. Analyze code complexity, maintainability index, technical debt, code duplication, naming conventions, and adherence to Clean Code principles. Integrate with SonarQube, CodeQL, and Semgrep for static analysis. Check for code smells, anti-patterns, and violations of SOLID principles. Generate cyclomatic complexity metrics and identify refactoring opportunities."
- Expected output: Quality metrics, code smell inventory, refactoring recommendations
- Context: Initial codebase analysis, no dependencies on other phases

### 1B. Architecture & Design Review
- Use Task tool with subagent_type="architect-review"
- Prompt: "Review architectural design patterns and structural integrity in: $ARGUMENTS. Evaluate microservices boundaries, API design, database schema, dependency management, and adherence to Domain-Driven Design principles. Check for circular dependencies, inappropriate coupling, missing abstractions, and architectural drift. Verify compliance with enterprise architecture standards and cloud-native patterns."
- Expected output: Architecture assessment, design pattern analysis, structural recommendations
- Context: Runs parallel with code quality analysis

## Phase 2: Security & Performance Review

Use Task tool with security and performance agents, incorporating Phase 1 findings:

### 2A. Security Vulnerability Assessment
- Use Task tool with subagent_type="security-auditor"
- Prompt: "Execute comprehensive security audit on: $ARGUMENTS. Perform OWASP Top 10 analysis, dependency vulnerability scanning with Snyk/Trivy, secrets detection with GitLeaks, input validation review, authentication/authorization assessment, and cryptographic implementation review. Include findings from Phase 1 architecture review: {phase1_architecture_context}. Check for SQL injection, XSS, CSRF, insecure deserialization, and configuration security issues."
- Expected output: Vulnerability report, CVE list, security risk matrix, remediation steps
- Context: Incorporates architectural vulnerabilities identified in Phase 1B

### 2B. Performance & Scalability Analysis
- Use Task tool with subagent_type="application-performance::performance-engineer"
- Prompt: "Conduct performance analysis and scalability assessment for: $ARGUMENTS. Profile code for CPU/memory hotspots, analyze database query performance, review caching strategies, identify N+1 problems, assess connection pooling, and evaluate asynchronous processing patterns. Consider architectural findings from Phase 1: {phase1_architecture_context}. Check for memory leaks, resource contention, and bottlenecks under load."
- Expected output: Performance metrics, bottleneck analysis, optimization recommendations
- Context: Uses architecture insights to identify systemic performance issues

## Phase 3: Testing & Documentation Review

Use Task tool for test and documentation quality assessment:

### 3A. Test Coverage & Quality Analysis
- Use Task tool with subagent_type="unit-testing::test-automator"
- Prompt: "Evaluate testing strategy and implementation for: $ARGUMENTS. Analyze unit test coverage, integration test completeness, end-to-end test scenarios, test pyramid adherence, and test maintainability. Review test quality metrics including assertion density, test isolation, mock usage, and flakiness. Consider security and performance test requirements from Phase 2: {phase2_security_context}, {phase2_performance_context}. Verify TDD practices if --tdd-review flag is set."
- Expected output: Coverage report, test quality metrics, testing gap analysis
- Context: Incorporates security and performance testing requirements from Phase 2

### 3B. Documentation & API Specification Review
- Use Task tool with subagent_type="code-documentation::docs-architect"
- Prompt: "Review documentation completeness and quality for: $ARGUMENTS. Assess inline code documentation, API documentation (OpenAPI/Swagger), architecture decision records (ADRs), README completeness, deployment guides, and runbooks. Verify documentation reflects actual implementation based on all previous phase findings: {phase1_context}, {phase2_context}. Check for outdated documentation, missing examples, and unclear explanations."
- Expected output: Documentation coverage report, inconsistency list, improvement recommendations
- Context: Cross-references all previous findings to ensure documentation accuracy

## Phase 4: Best Practices & Standards Compliance

Use Task tool to verify framework-specific and industry best practices:

### 4A. Framework & Language Best Practices
- Use Task tool with subagent_type="framework-migration::legacy-modernizer"
- Prompt: "Verify adherence to framework and language best practices for: $ARGUMENTS. Check modern JavaScript/TypeScript patterns, React hooks best practices, Python PEP compliance, Java enterprise patterns, Go idiomatic code, or framework-specific conventions (based on --framework flag). Review package management, build configuration, environment handling, and deployment practices. Include all quality issues from previous phases: {all_previous_contexts}."
- Expected output: Best practices compliance report, modernization recommendations
- Context: Synthesizes all previous findings for framework-specific guidance

### 4B. CI/CD & DevOps Practices Review
- Use Task tool with subagent_type="cicd-automation::deployment-engineer"
- Prompt: "Review CI/CD pipeline and DevOps practices for: $ARGUMENTS. Evaluate build automation, test automation integration, deployment strategies (blue-green, canary), infrastructure as code, monitoring/observability setup, and incident response procedures. Assess pipeline security, artifact management, and rollback capabilities. Consider all issues identified in previous phases that impact deployment: {all_critical_issues}."
- Expected output: Pipeline assessment, DevOps maturity evaluation, automation recommendations
- Context: Focuses on operationalizing fixes for all identified issues

## Consolidated Report Generation

Compile all phase outputs into comprehensive review report:

### Critical Issues (P0 - Must Fix Immediately)
- Security vulnerabilities with CVSS > 7.0
- Data loss or corruption risks
- Authentication/authorization bypasses
- Production stability threats
- Compliance violations (GDPR, PCI DSS, SOC2)

### High Priority (P1 - Fix Before Next Release)
- Performance bottlenecks impacting user experience
- Missing critical test coverage
- Architectural anti-patterns causing technical debt
- Outdated dependencies with known vulnerabilities
- Code quality issues affecting maintainability

### Medium Priority (P2 - Plan for Next Sprint)
- Non-critical performance optimizations
- Documentation gaps and inconsistencies
- Code refactoring opportunities
- Test quality improvements
- DevOps automation enhancements

### Low Priority (P3 - Track in Backlog)
- Style guide violations
- Minor code smell issues
- Nice-to-have documentation updates
- Cosmetic improvements

## Success Criteria

Review is considered successful when:
- All critical security vulnerabilities are identified and documented
- Performance bottlenecks are profiled with remediation paths
- Test coverage gaps are mapped with priority recommendations
- Architecture risks are assessed with mitigation strategies
- Documentation reflects actual implementation state
- Framework best practices compliance is verified
- CI/CD pipeline supports safe deployment of reviewed code
- Clear, actionable feedback is provided for all findings
- Metrics dashboard shows improvement trends
- Team has clear prioritized action plan for remediation

Target: $ARGUMENTS

© Seth Hobson · MIT · Ormus-Solutions/LibreUIUX-Claude-Code

Similar slash commands

All slash commands for Code review and refactoring →

full-review by other authors comes first.

full-review Seth Hobson full-review — a command for Claude Code, Codex and Cursor orchestrates a five-phase code review using specialized sub-agents: quality, architecture, security, performance, testing. CX Codex +1 ★ 42,780repo stars full-audit undeadlist full-audit runs 11 audit agents in parallel across your repository and consolidates issues into a prioritized action plan. Designed for pre-release inspections or routine weekly health checks. CX Codex +1 ★ 149repo stars code-review-pro OneWave-AI code-review-pro reviews files, a module, a diff or a branch and returns severity-ranked findings: vulnerabilities, correctness bugs, performance and maintainability issues, each with evidence and a fix. CX Codex +1 2,600installs suede-code JasonColapietro suede-code is a skill that reviews PRs, diffs, branches, or commit ranges with evidence-backed findings and a ship grade. It runs only when you ask for a review. CX Codex +1 ★ 121repo stars code-reviewer https://github.com/Jeffallan code-reviewer analyzes code diffs and files to spot bugs, security vulnerabilities (SQL injection, XSS), code smells, N+1 queries, and returns a prioritized review report. Use for pull request reviews and code audits. CX Codex +1 7,100installs api-security-review OWASP The api-security-review skill runs an API through the OWASP API Security Top 10 (2023), covering auth, BOLA, SSRF and gateway config. Useful before a release or when auditing someone else's service. CX Codex +1 684installs code-review-security OWASP code-review-security — a skill that reviews code for vulnerabilities against OWASP Top 10 and ASVS, then reports findings with attack scenarios and fixed snippets. CX Codex +1 516installs

From the same set42

The whole set →
dependency-management dependency-management audits dependencies across eight ecosystems for CVEs and license issues, plus guides legacy code migration. Useful for security checks and framework upgrades. ★ 126repo stars debugging-toolkit debugging-toolkit adds the /smart-debug command and two subagents to Claude Code for root cause analysis and workspace tuning. Useful when investigating test failures or production errors. ★ 126repo stars full-stack-feature full-stack-feature runs feature work through four phases — schema design, API contracts, parallel implementation, testing — by delegating each step to a specialized subagent. Takes a feature description as its argument. CX Codex +1 ★ 126repo stars security-hardening The security-hardening command hardens an application through coordinated security agents. Use it to assess vulnerabilities, fix high-risk issues, and add layered controls. CX Codex +1 ★ 126repo stars performance-optimization performance-optimization coordinates end-to-end performance audits, database optimizations, frontend tuning, and load testing. CX Codex +1 ★ 126repo stars incident-response The incident-response command coordinates incident triage, investigation, mitigation, and recovery. Give it an incident description to start a staged response. CX Codex +1 ★ 126repo stars ui-responsive The ui-responsive command analyzes a component or page at five breakpoints and gives specific fixes for mobile, tablet and desktop layouts. CX Codex +1 ★ 126repo stars jungian-archetypes jungian-archetypes maps twelve brand archetypes to UI layout, typography, animations, and Tailwind styling. CX Codex +1 ★ 126repo stars

Project sponsors

Companies that keep this analytics open