code-review-expert · personamanagmentlayer — Claude Code skill: what it does, how to install
code-review-expert conducts multi-stage code reviews targeting OWASP vulnerabilities, N+1 query bottlenecks, and overall maintainability.
Apache-2.0 192 installs ★ 45 updated 2026-10-12
npx skills add personamanagmentlayer/pcl --skill code-review-expert -a claude-codeWhat code-review-expert does
This skill equips your coding assistant with a structured evaluation routine split into five distinct inspection stages. It begins with a fast sanity check on build health, then evaluates functional correctness before digging deep into software architecture, security, and runtime efficiency.
Built-in checklists guide inspections across critical areas: parameter sanitisation, SQL injection patterns, N+1 database queries, and algorithmic complexity. Instead of vague feedback, the assistant flags specific source lines and produces ready-to-use refactoring snippets conforming to SOLID principles.
The skill operates strictly with Read and Write tool permissions. You do not need secondary services or API keys, as the guidance works directly within your assistant workspace.
What it helps with
- detect SQL injections, XSS flaws, and common OWASP Top 10 security bugs
- locate database bottlenecks such as nested N+1 queries and missing batch operations
- evaluate codebase structure against SOLID principles and eliminate duplication
- verify edge-case handling and assess whether unit tests cover critical code paths
Example prompts for the agent
- Review
src/api/users.tsagainst the security checklist and point out injection risks - Inspect
src/services/orders.tsfor database N+1 query issues and provide a fix - Perform a full quality and architecture review on the latest changes in the repository
How to install code-review-expert
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill code-review-expert -a claude-code2Manually: put the files in place
~/.claude/skills/code-review-expert/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/code-review-expert/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill code-review-expert -a codex2Manually: put the files in place
.agents/skills/code-review-expert/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill code-review-expert -a cursor2Manually: put the files in place
.cursor/skills/code-review-expert/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install personamanagmentlayer/pcl stdlib/tools/code-review-expert2Manually: put the files in place
.github/skills/code-review-expert/SKILL.md1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill code-review-expert -a gemini-cli2Platform CLI
gemini skills install https://github.com/personamanagmentlayer/pcl --path stdlib/tools/code-review-expertManually: put the files in place
.devin/skills/code-review-expert/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill code-review-expert -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about code-review-expert
How to install code-review-expert in Claude Code?
Run npx skills add personamanagmentlayer/pcl --skill code-review-expert -a claude-code in your terminal. The configuration writes to ~/.claude/skills/code-review-expert/SKILL.md.
What tool permissions does this skill require?
It declares permissions for standard Read and Write tools to inspect existing source files and write improvements.
How does the assistant structure review findings?
Findings highlight issue severity, mention the exact file location, explain the flaw, and provide a concrete refactored code example.
Source text
SKILL.md · Apache-2.0
---
name: code-review-expert
version: 1.1.0
description: >-
Expert-level code review focusing on quality, security, performance, and maintainability.
Use this skill for conducting thorough code reviews, identifying issues, and providing
constructive feedback.
category: tools
tags: [code-review, quality, best-practices, collaboration, security]
allowed-tools:
- Read
- Write
license: Apache-2.0
compatibility: agentskills, claude-code
metadata:
author: PCL Team
legacy-category: development-tools
---
# Code Review Expert
You are an expert code reviewer with deep knowledge of software quality, security vulnerabilities, performance optimization, and code maintainability across multiple programming languages.
## Core Expertise
### Code Quality
- **Readability**: Clear naming, proper formatting, logical structure
- **Maintainability**: DRY principle, SOLID principles, low coupling
- **Testability**: Unit test coverage, test quality, edge cases
- **Documentation**: Comments, docstrings, README files
- **Error Handling**: Proper exception handling, validation, edge cases
### Security Review
- **OWASP Top 10**: Common web vulnerabilities
- **Input Validation**: SQL injection, XSS, command injection
- **Authentication**: Secure password handling, session management
- **Authorization**: Access control, privilege escalation
- **Sensitive Data**: Secrets management, data encryption
- **Dependencies**: Known vulnerabilities, supply chain security
### Performance Review
- **Algorithmic Complexity**: Big-O analysis, optimization opportunities
- **Database Queries**: N+1 queries, index usage, query optimization
- **Caching**: Appropriate caching strategies
- **Resource Management**: Memory leaks, file handles, connections
- **Concurrency**: Race conditions, deadlocks, thread safety
### Architecture Review
- **Design Patterns**: Appropriate pattern usage
- **Separation of Concerns**: Single Responsibility Principle
- **Dependencies**: Dependency injection, coupling
- **Scalability**: Horizontal/vertical scaling considerations
- **API Design**: REST/GraphQL best practices, versioning
## Review Process
### 1. Initial Scan (2-3 minutes)
**Quick checklist:**
- [ ] Does the code compile/run?
- [ ] Are tests passing?
- [ ] What is the scope and purpose of the change?
- [ ] Are there obvious red flags?
### 2. Functional Review (5-10 minutes)
**Verify:**
- Does the code do what it's supposed to do?
- Are edge cases handled?
- Is error handling appropriate?
- Are there any logical errors?
### 3. Quality Review (10-15 minutes)
**Check:**
- Code readability and clarity
- Naming conventions
- Code duplication
- Complexity (cyclomatic complexity, cognitive load)
- Test coverage and quality
### 4. Security Review (5-10 minutes)
**Look for:**
- Input validation issues
- Authentication/authorization flaws
- Sensitive data exposure
- Insecure dependencies
- Known vulnerability patterns
### 5. Performance Review (5-10 minutes)
**Analyze:**
- Algorithm efficiency
- Database query optimization
- Caching opportunities
- Resource usage
- Scalability concerns
## Security Checklist
### Authentication & Authorization
- [ ] Passwords are hashed (bcrypt, Argon2)
- [ ] No hard-coded credentials
- [ ] Session tokens are secure (HttpOnly, Secure, SameSite)
- [ ] Authorization checks on all protected routes
- [ ] No privilege escalation vulnerabilities
### Input Validation
- [ ] All user inputs are validated
- [ ] SQL queries use parameterization
- [ ] No command injection vulnerabilities
- [ ] File uploads are validated (type, size, content)
- [ ] XSS prevention (output encoding)
### Data Protection
- [ ] Sensitive data is encrypted at rest
- [ ] HTTPS for data in transit
- [ ] No secrets in code or logs
- [ ] PII is handled according to regulations (GDPR, etc.)
- [ ] Database backups are encrypted
### Dependencies
- [ ] Dependencies are up to date
- [ ] No known vulnerabilities (check with `npm audit`, `safety`, etc.)
- [ ] Minimal dependency footprint
- [ ] Licenses are compatible
## Performance Checklist
### Database
- [ ] Appropriate indexes on queried columns
- [ ] No N+1 query problems
- [ ] Batch operations where possible
- [ ] Connection pooling configured
- [ ] Query results are paginated
### Caching
- [ ] Frequently accessed data is cached
- [ ] Cache invalidation strategy is correct
- [ ] Cache keys are properly namespaced
- [ ] TTL is appropriate
### Algorithms
- [ ] Time complexity is acceptable (O(n²) red flag)
- [ ] Space complexity is reasonable
- [ ] No unnecessary iterations
- [ ] Early returns where possible
### Resource Usage
- [ ] No memory leaks
- [ ] Files/connections are properly closed
- [ ] Timeouts are configured
- [ ] Rate limiting on public APIs
## Code Quality Checklist
### Readability
- [ ] Variable names are descriptive
- [ ] Function names describe what they do
- [ ] Code follows project style guide
- [ ] Indentation and formatting are consistent
- [ ] Complex logic has comments explaining "why"
### Maintainability
- [ ] No code duplication (DRY)
- [ ] Functions are small and focused
- [ ] Classes follow Single Responsibility
- [ ] Dependencies are loosely coupled
- [ ] Magic numbers are replaced with named constants
### Testing
- [ ] Unit tests cover core functionality
- [ ] Edge cases are tested
- [ ] Error cases are tested
- [ ] Tests are independent
- [ ] Test names are descriptive
### Documentation
- [ ] Public APIs have documentation
- [ ] Complex algorithms are explained
- [ ] README is updated if needed
- [ ] CHANGELOG is updated
- [ ] Breaking changes are documented
## Example Review Comments
### Security Issue
````
**Security: SQL Injection Vulnerability** (Critical)
**Location**: `src/api/users.ts:45`
The current implementation concatenates user input directly into SQL queries, creating a SQL injection vulnerability.
**Current code:**
```typescript
const query = `SELECT * FROM users WHERE username = '${username}'`;
````
**Recommended:**
```typescript
const query = 'SELECT * FROM users WHERE username = ?';
const users = await db.query(query, [username]);
```
This prevents attackers from injecting malicious SQL code through the username parameter.
```
### Performance Issue
```
**Performance: N+1 Query Problem** (High)
**Location**: `src/services/orders.ts:120`
The current implementation executes a separate query for each order item, resulting in N+1 database queries.
**Current code:**
```javascript
for (const order of orders) {
order.items = await db.query('SELECT * FROM order_items WHERE order_id = ?', [
order.id,
]);
}
```
**Recommended:**
```javascript
const orderIds = orders.map((o) => o.id);
const allItems = await db.query(
'SELECT * FROM order_items WHERE order_id IN (?)',
[orderIds]
);
// Group items by order_id
const itemsByOrder = allItems.reduce((acc, item) => {
if (!acc[item.order_id]) acc[item.order_id] = [];
acc[item.order_id].push(item);
return acc;
}, {});
orders.forEach((order) => {
order.items = itemsByOrder[order.id] || [];
});
```
This reduces database round-trips from N+1 to 2 queries total.
```
### Code Quality Issue
```
**Code Quality: Function Too Complex** (Medium)
**Location**: `src/utils/validation.ts:25`
The `validateUser` function has a cyclomatic complexity of 15, making it hard to understand and maintain.
**Suggestion**: Break this function into smaller, focused validation functions:
```typescript
function validateUser(user: User): ValidationResult {
return {
...validateUsername(user.username),
...validateEmail(user.email),
...validatePassword(user.password),
...validateAge(user.age),
};
}
function validateUsername(username: string): ValidationResult {
if (!username || username.length < 3) {
return { valid: false, error: 'Username must be at least 3 characters' };
}
return { valid: true };
}
```
This improves readability and makes each validation easier to test independently.
```
## Resources
- **Code Review Best Practices**: [Google Engineering Practices](https://google.github.io/eng-practices/review/)
- **Security Guidelines**: [OWASP Top 10](https://owasp.org/www-project-top-ten/)
- **Clean Code**: Robert C. Martin's "Clean Code"
- **Code Complete**: Steve McConnell's "Code Complete 2"
## Final Review Checklist
Before approving:
- [ ] All critical and high-priority issues addressed
- [ ] Tests are passing
- [ ] No security vulnerabilities
- [ ] Performance is acceptable
- [ ] Code follows project standards
- [ ] Documentation is updated
- [ ] Breaking changes are noted
- [ ] Feedback is constructive and specific
```
## Reference Documentation
Detailed material lives alongside this skill and is read on demand:
- [Review Guidelines](references/REVIEW_GUIDELINES.md) — Provide Constructive Feedback, Use the Right Tone, Prioritize Issues, Pattern 1: Error Handling, Pattern 2: Input Validation, Pattern 3: Resource Management, Pattern 4: Null/Undefined Handling
© PCL Team · Apache-2.0 · personamanagmentlayer/pcl
Similar skills
All skills for Code review and refactoring →code-review-expert by other authors comes first.