home / skills / davila7 / claude-code-templates / code-reviewer

code-reviewer skill

safe

/cli-tool/components/skills/development/code-reviewer

This skill automates code reviews across languages, generating checklists, enforcing best practices, and producing actionable feedback for PRs.

This is most likely a fork of the code-reviewer skill from eyh0602

npx playbooks add skill davila7/claude-code-templates --skill code-reviewer

Review the files below or copy the command above to add this skill to your agents.

Files (7)

SKILL.md

4.3 KB

---
name: code-reviewer
description: Comprehensive code review skill for TypeScript, JavaScript, Python, Swift, Kotlin, Go. Includes automated code analysis, best practice checking, security scanning, and review checklist generation. Use when reviewing pull requests, providing code feedback, identifying issues, or ensuring code quality standards.
---

# Code Reviewer

Complete toolkit for code reviewer with modern tools and best practices.

## Quick Start

### Main Capabilities

This skill provides three core capabilities through automated scripts:

```bash
# Script 1: Pr Analyzer
python scripts/pr_analyzer.py [options]

# Script 2: Code Quality Checker
python scripts/code_quality_checker.py [options]

# Script 3: Review Report Generator
python scripts/review_report_generator.py [options]
```

## Core Capabilities

### 1. Pr Analyzer

Automated tool for pr analyzer tasks.

**Features:**
- Automated scaffolding
- Best practices built-in
- Configurable templates
- Quality checks

**Usage:**
```bash
python scripts/pr_analyzer.py <project-path> [options]
```

### 2. Code Quality Checker

Comprehensive analysis and optimization tool.

**Features:**
- Deep analysis
- Performance metrics
- Recommendations
- Automated fixes

**Usage:**
```bash
python scripts/code_quality_checker.py <target-path> [--verbose]
```

### 3. Review Report Generator

Advanced tooling for specialized tasks.

**Features:**
- Expert-level automation
- Custom configurations
- Integration ready
- Production-grade output

**Usage:**
```bash
python scripts/review_report_generator.py [arguments] [options]
```

## Reference Documentation

### Code Review Checklist

Comprehensive guide available in `references/code_review_checklist.md`:

- Detailed patterns and practices
- Code examples
- Best practices
- Anti-patterns to avoid
- Real-world scenarios

### Coding Standards

Complete workflow documentation in `references/coding_standards.md`:

- Step-by-step processes
- Optimization strategies
- Tool integrations
- Performance tuning
- Troubleshooting guide

### Common Antipatterns

Technical reference guide in `references/common_antipatterns.md`:

- Technology stack details
- Configuration examples
- Integration patterns
- Security considerations
- Scalability guidelines

## Tech Stack

**Languages:** TypeScript, JavaScript, Python, Go, Swift, Kotlin
**Frontend:** React, Next.js, React Native, Flutter
**Backend:** Node.js, Express, GraphQL, REST APIs
**Database:** PostgreSQL, Prisma, NeonDB, Supabase
**DevOps:** Docker, Kubernetes, Terraform, GitHub Actions, CircleCI
**Cloud:** AWS, GCP, Azure

## Development Workflow

### 1. Setup and Configuration

```bash
# Install dependencies
npm install
# or
pip install -r requirements.txt

# Configure environment
cp .env.example .env
```

### 2. Run Quality Checks

```bash
# Use the analyzer script
python scripts/code_quality_checker.py .

# Review recommendations
# Apply fixes
```

### 3. Implement Best Practices

Follow the patterns and practices documented in:
- `references/code_review_checklist.md`
- `references/coding_standards.md`
- `references/common_antipatterns.md`

## Best Practices Summary

### Code Quality
- Follow established patterns
- Write comprehensive tests
- Document decisions
- Review regularly

### Performance
- Measure before optimizing
- Use appropriate caching
- Optimize critical paths
- Monitor in production

### Security
- Validate all inputs
- Use parameterized queries
- Implement proper authentication
- Keep dependencies updated

### Maintainability
- Write clear code
- Use consistent naming
- Add helpful comments
- Keep it simple

## Common Commands

```bash
# Development
npm run dev
npm run build
npm run test
npm run lint

# Analysis
python scripts/code_quality_checker.py .
python scripts/review_report_generator.py --analyze

# Deployment
docker build -t app:latest .
docker-compose up -d
kubectl apply -f k8s/
```

## Troubleshooting

### Common Issues

Check the comprehensive troubleshooting section in `references/common_antipatterns.md`.

### Getting Help

- Review reference documentation
- Check script output messages
- Consult tech stack documentation
- Review error logs

## Resources

- Pattern Reference: `references/code_review_checklist.md`
- Workflow Guide: `references/coding_standards.md`
- Technical Guide: `references/common_antipatterns.md`
- Tool Scripts: `scripts/` directory

Overview

This skill is a comprehensive code review toolkit focused on TypeScript, JavaScript, Python, Swift, Kotlin, and Go. It combines automated analysis, best-practice checks, security scanning, and report generation to speed up pull request reviews and improve code quality. Use it to identify issues, suggest fixes, and enforce team standards consistently.

How this skill works

The skill runs three main automated scripts: a PR Analyzer to inspect changes and surface risky diffs, a Code Quality Checker that runs static analysis, performance hints, and automated fix suggestions, and a Review Report Generator that compiles findings into structured output. Each script accepts a project or target path and options, integrates with existing linters and CI tools, and can be configured via templates and reference documents. Outputs include actionable recommendations, prioritized issues, and a checklist-based review report.

When to use it

During pull request reviews to augment human feedback
When onboarding new contributors to verify style and standards
Before merging critical changes to catch regressions and security issues
As part of CI pipelines for automated quality gates
When preparing release candidates to ensure performance and maintainability

Best practices

Run the Code Quality Checker locally and in CI to catch issues early
Use the PR Analyzer to focus review effort on high-risk diffs and hotspots
Customize templates and checklist items to reflect project-specific standards
Prioritize security and input validation findings before performance tweaks
Keep the reference docs (checklist, coding standards, antipatterns) updated and version-controlled

Example use cases

Automate initial review of incoming pull requests and attach a summary report
Generate a prioritized list of security and bug fixes for a refactor branch
Run performance and complexity checks on critical backend services before deployment
Create a consistent review checklist for mobile and web teams using shared templates
Integrate with GitHub Actions to block merges when critical findings are present

FAQ

Which languages and platforms are supported?

Supports TypeScript, JavaScript, Python, Swift, Kotlin, and Go across web and mobile stacks; integrates with typical frontend and backend frameworks.

How do I include these checks in CI?

Run the provided scripts from your CI pipeline (examples: python scripts/code_quality_checker.py . or python scripts/review_report_generator.py --analyze) and fail the job on configured severity thresholds.