Code reviewer

Skill OpenSIN-AI/OpenSIN-Skills/engineering-team/code-reviewer

The world's largest open-source AI agent skill library — 280+ skills across 9 knowledge domains + 46 operational actions. Built on alirezarezvani/claude-skills + OpenSIN-AI.

Install

npx -y skills add OpenSIN-AI/OpenSIN-Skills --skill code-reviewer

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Code review automation for TypeScript, JavaScript, Python, Go, Swift, Kotlin. Analyzes PRs for complexity and risk, checks code quality for SOLID violations and code smells, generates review reports. Use when reviewing pull requests, analyzing code quality, identifying issues, generating review checklists.

SKILL.md

4.6 KB, as published. Nobody here has run it

Code Reviewer

Automated code review tools for analyzing pull requests, detecting code quality issues, and generating review reports.

Tools
Reference Guides
Languages Supported

Tools

PR Analyzer

Analyzes git diff between branches to assess review complexity and identify risks.

# Analyze current branch against main
python scripts/pr_analyzer.py /path/to/repo

# Compare specific branches
python scripts/pr_analyzer.py . --base main --head feature-branch

# JSON output for integration
python scripts/pr_analyzer.py /path/to/repo --json

What it detects:

Hardcoded secrets (passwords, API keys, tokens)
SQL injection patterns (string concatenation in queries)
Debug statements (debugger, console.log)
ESLint rule disabling
TypeScript any types
TODO/FIXME comments

Output includes:

Complexity score (1-10)
Risk categorization (critical, high, medium, low)
File prioritization for review order
Commit message validation

Code Quality Checker

Analyzes source code for structural issues, code smells, and SOLID violations.

# Analyze a directory
python scripts/code_quality_checker.py /path/to/code

# Analyze specific language
python scripts/code_quality_checker.py . --language python

# JSON output
python scripts/code_quality_checker.py /path/to/code --json

What it detects:

Long functions (>50 lines)
Large files (>500 lines)
God classes (>20 methods)
Deep nesting (>4 levels)
Too many parameters (>5)
High cyclomatic complexity
Missing error handling
Unused imports
Magic numbers

Thresholds:

Issue	Threshold
Long function	>50 lines
Large file	>500 lines
God class	>20 methods
Too many params	>5
Deep nesting	>4 levels
High complexity	>10 branches

Review Report Generator

Combines PR analysis and code quality findings into structured review reports.

# Generate report for current repo
python scripts/review_report_generator.py /path/to/repo

# Markdown output
python scripts/review_report_generator.py . --format markdown --output review.md

# Use pre-computed analyses
python scripts/review_report_generator.py . \
  --pr-analysis pr_results.json \
  --quality-analysis quality_results.json

Report includes:

Review verdict (approve, request changes, block)
Score (0-100)
Prioritized action items
Issue summary by severity
Suggested review order

Verdicts:

Score	Verdict
90+ with no high issues	Approve
75+ with ≤2 high issues	Approve with suggestions
50-74	Request changes
<50 or critical issues	Block

Reference Guides

Code Review Checklist

references/code_review_checklist.md

Systematic checklists covering:

Pre-review checks (build, tests, PR hygiene)
Correctness (logic, data handling, error handling)
Security (input validation, injection prevention)
Performance (efficiency, caching, scalability)
Maintainability (code quality, naming, structure)
Testing (coverage, quality, mocking)
Language-specific checks

Coding Standards

references/coding_standards.md

Language-specific standards for:

TypeScript (type annotations, null safety, async/await)
JavaScript (declarations, patterns, modules)
Python (type hints, exceptions, class design)
Go (error handling, structs, concurrency)
Swift (optionals, protocols, errors)
Kotlin (null safety, data classes, coroutines)

Common Antipatterns

references/common_antipatterns.md

Antipattern catalog with examples and fixes:

Structural (god class, long method, deep nesting)
Logic (boolean blindness, stringly typed code)
Security (SQL injection, hardcoded credentials)
Performance (N+1 queries, unbounded collections)
Testing (duplication, testing implementation)
Async (floating promises, callback hell)

Languages Supported

Language	Extensions
Python	`.py`
TypeScript	`.ts`, `.tsx`
JavaScript	`.js`, `.jsx`, `.mjs`
Go	`.go`
Swift	`.swift`
Kotlin	`.kt`, `.kts`

Gives 0 of the 12 instructions most code review skills give

Counted across 610 of the 674 authors here whose files we hold, read 2026-08-06

push back with technical reasoning if wrongin 60 of 610, across 24 files
ask for clarification on unclear itemsin 51 of 610, across 16 files
fix critical issues immediatelyin 45 of 610, across 29 files
implement one item at a timein 45 of 610, across 11 files
group findings by severityin 44 of 610, across 43 files
verify feedback against the codebasein 42 of 610, across 8 files
dispatch a code reviewer subagentin 39 of 610, across 23 files
fix important issues before proceedingin 37 of 610, across 22 files
test each fix individuallyin 35 of 610, across 7 files
reply in github comment threadsin 33 of 610, across 5 files
check for security vulnerabilitiesin 31 of 610, across 27 files
factualize corrections without over-explainingin 30 of 610, across 2 files

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once.