Skip to content

amanpal3/Dr-SKILLs / .agent/plugins/coderabbit/skills/code-review

code-review

Verified

Reviews code like a senior software engineer. Improves readability, maintainability, performance, and scalability. Detects bugs, security risks, and bad practices. Use when the user asks to review, audit, improve, or refactor any code.

Code Review — Senior Engineer Intelligence

When to Use This Skill

  • User asks to review, audit, or critique code
  • User wants to refactor or clean up existing code
  • Checking code for bugs, security issues, or bad practices
  • Before a pull request or code merge
  • Evaluating code quality of a new codebase or file

1. Core Principles

Rule: Prioritize correctness → security → readability → performance. In that order.

  • Clarity over cleverness — Code is read 10x more than it's written
  • DRY — Don't Repeat Yourself; duplicate logic = future bug waiting to happen
  • KISS — Keep It Simple, Stupid; simple solutions scale better
  • YAGNI — You Aren't Gonna Need It; don't build for hypothetical futures
  • Single Responsibility — Every function/class does one thing, and does it well
  • Fail fast — Surface errors early; don't silently swallow failures
  • Optimize last — Correct and readable first, performant second

2. Code Quality Checklist

Readability

  • Code is understandable at first glance (no mental gymnastics needed)
  • Proper indentation and consistent formatting (use a linter/formatter)
  • No unnecessary complexity or over-abstraction
  • Comments explain why, not what (code explains what)
  • No commented-out dead code left behind

Structure

  • Functions are small and focused (Single Responsibility Principle)
  • Logical file and module organization (related things live together)
  • Nesting depth ≤ 3 levels (flatten with early returns or extraction)
  • No god objects/functions (>200 lines = red flag)

Reusability

  • No duplicate logic (DRY enforced)
  • Reusable helpers/utilities extracted into their own modules
  • Proper abstraction — not too low (copy-paste), not too high (over-engineered)

Maintainability

  • No hardcoded magic values (use named constants or config)
  • Consistent coding style across the file/project
  • Logic is easy to modify without breaking other things (low coupling)
  • Dependencies are explicit, not hidden

3. Naming Conventions

Good names are the cheapest form of documentation.

Variables — Use nouns, be descriptive

// ❌ Bad
let x = 5;
let data = [];
let flag = true;

// ✅ Good
let retryCount = 5;
let userOrders = [];
let isEmailVerified = true;

Functions — Use action verbs

// ❌ Bad
function userData() {}
function check() {}

// ✅ Good
function getUserData() {}
function validateEmailFormat() {}
function calculateOrderTotal() {}

Booleans — Prefix with is, has, can, should

// ❌ Bad
let active = true;
let permission = false;

// ✅ Good
let isActive = true;
let hasWritePermission = false;
let canDeletePost = false;

Classes — Use nouns (PascalCase)

// ❌ Bad
class manage() {}

// ✅ Good
class UserManager {}
class PaymentService {}
class OrderRepository {}

Constants — SCREAMING_SNAKE_CASE

const MAX_RETRY_LIMIT = 3;
const DEFAULT_PAGE_SIZE = 20;
const API_BASE_URL = "https://api.example.com";

4. Performance Optimization

Algorithmic Efficiency

  • Prefer O(1) lookups with Maps/Sets over O(n) array .find() or .includes()
  • Avoid nested loops on large datasets (O(n²) = danger)
  • Cache repeated expensive calculations (memoization)
// ❌ O(n) lookup every time
const user = users.find(u => u.id === targetId);

// ✅ O(1) lookup with a Map
const userMap = new Map(users.map(u => [u.id, u]));
const user = userMap.get(targetId);

Async & I/O

  • Avoid blocking the event loop (use async/await, not sync file reads)
  • Parallelize independent async operations with Promise.all()
  • Avoid N+1 query problems (batch DB calls, use joins)
// ❌ Sequential (slow)
for (const id of userIds) {
  const user = await db.getUser(id);
}

// ✅ Parallel (fast)
const users = await Promise.all(userIds.map(id => db.getUser(id)));

Resource Management

  • Lazy load heavy resources (images, large modules)
  • Debounce/throttle high-frequency event handlers (scroll, resize, keypress)
  • Minimize API/database calls (cache responses where appropriate)
  • Avoid memory leaks — clean up event listeners, subscriptions, timers

5. Security Checks

Security is non-negotiable. Review every user-facing input path.

Input Validation & Sanitization

  • All user inputs validated server-side (never trust client-side only)
  • Inputs sanitized before use in DB queries, HTML output, or shell commands

Common Vulnerabilities

VulnerabilityWhat to Check
SQL InjectionAre queries using parameterized statements / ORM?
XSSIs user content escaped before rendering to HTML?
CSRFAre state-changing endpoints protected by tokens?
IDORDoes the code verify resource ownership before access?
Path TraversalAre file paths validated and confined to safe directories?
ReDoSAre regex patterns safe from catastrophic backtracking?

Secrets & Credentials

  • No API keys, passwords, or tokens hardcoded in source
  • Secrets loaded from environment variables or secrets manager
  • .env files are gitignored
  • No sensitive data logged to console or error messages

Auth Checks

  • Authentication verified before accessing protected routes
  • Authorization checks per resource (not just "is logged in")
  • Tokens have expiry; refresh tokens are rotated on use
// ❌ Dangerous — SQL injection risk
const query = `SELECT * FROM users WHERE email = '${email}'`;

// ✅ Safe — parameterized query
const query = `SELECT * FROM users WHERE email = $1`;
db.query(query, [email]);

6. Clean Code Patterns

Early Returns (Avoid nesting)

// ❌ Deep nesting — hard to read
function processOrder(order) {
  if (order) {
    if (order.items.length > 0) {
      if (order.isPaid) {
        // actual logic here
      }
    }
  }
}

// ✅ Early returns — flat and readable
function processOrder(order) {
  if (!order) return;
  if (order.items.length === 0) return;
  if (!order.isPaid) return;

  // actual logic here
}

Avoid Magic Numbers

// ❌ Magic number
if (status === 3) { ... }
setTimeout(fn, 86400000);

// ✅ Named constant
const STATUS_SHIPPED = 3;
const ONE_DAY_MS = 24 * 60 * 60 * 1000;

if (status === STATUS_SHIPPED) { ... }
setTimeout(fn, ONE_DAY_MS);

Prefer Composition over Inheritance

// ❌ Deep inheritance chains are rigid
class Animal { ... }
class Dog extends Animal { ... }
class GuideDog extends Dog { ... }

// ✅ Composable behaviors
const canBark = (state) => ({ bark: () => `${state.name} says woof!` });
const canGuide = (state) => ({ guide: () => `${state.name} is guiding` });
const createGuideDog = (name) => {
  const state = { name };
  return { ...canBark(state), ...canGuide(state) };
};

7. Error Handling

Errors are first-class citizens. Handle them explicitly, always.

Rules

  • Use try/catch around all async operations and external calls
  • Never silently swallow errors (catch (e) {} is forbidden)
  • Provide meaningful error messages — include context
  • Log errors with enough info to debug (stack trace, request ID, user context)
  • Distinguish between operational errors (expected) and programmer errors (bugs)
// ❌ Swallowed error
try {
  await fetchUser(id);
} catch (e) {}

// ✅ Handled with context
try {
  const user = await fetchUser(id);
  return user;
} catch (error) {
  logger.error(`Failed to fetch user ${id}:`, error.message);
  throw new AppError('USER_FETCH_FAILED', 'Could not retrieve user data', 500);
}

Edge Cases to Always Handle

  • Null / undefined values (use optional chaining ?. and nullish coalescing ??)
  • Empty arrays or objects before iteration
  • Network timeouts and API failures
  • Unexpected user input (wrong type, out-of-range values)
  • Database connection failures
  • File not found / permission denied

8. Refactoring Guidelines

When to Refactor

  • Function > 30 lines → extract smaller functions
  • File > 300 lines → split into modules
  • Same logic appears 2+ times → extract to utility
  • Condition > 3 levels deep → flatten with early returns
  • Confusing name → rename immediately

Refactoring Checklist

  • Break large functions into smaller, named ones
  • Remove all duplicate code paths
  • Simplify complex conditionals
  • Replace hardcoded values with constants/config
  • Improve naming throughout
  • Extract shared utilities to a dedicated file
  • Add or improve error handling after changes

Safe Refactoring Steps

  1. Cover the existing behavior with tests (if not already)
  2. Make one small change at a time
  3. Run tests after each change
  4. Commit working states frequently

9. Scalability Considerations

  • Stateless services — Don't store session state in memory; use Redis or DB
  • Horizontal scaling — Code shouldn't assume it runs on one machine
  • Database indexing — Index columns used in WHERE, JOIN, and ORDER BY
  • Pagination — Never return unbounded lists from DB or API
  • Queue heavy work — Long operations (email, video processing) go in a job queue
  • Rate limiting — Protect APIs from abuse at scale
  • Feature flags — Allow safe rollout and instant rollback
// ❌ Unbounded query — dangerous at scale
const orders = await db.query("SELECT * FROM orders");

// ✅ Paginated query
const orders = await db.query(
  "SELECT * FROM orders ORDER BY created_at DESC LIMIT $1 OFFSET $2",
  [pageSize, page * pageSize]
);

10. Review Output Format

When reviewing code, always structure the output as:

🔍 Issues Found

List each issue with:

  • Type: Bug / Security / Performance / Readability / Maintainability
  • Location: File name + line number (if known)
  • Description: What is wrong and why it matters

💡 Suggested Improvements

  • Cleaner alternative approach
  • Better structure or pattern to use
  • Optimization opportunity

✏️ Refactored Code (if applicable)

Provide the corrected/improved version with clear diff or before/after blocks.

📊 Impact Summary

Brief explanation of:

  • Why the change was made
  • What improves (readability / performance / security / reliability)
  • Risk level of the current code (Low / Medium / High / Critical)

Example Output Format

🔍 Issue 1 — Security (Critical)
Location: auth.js, line 42
Problem: SQL query is built via string concatenation, allowing SQL injection.

💡 Fix: Use parameterized queries.

✏️ Before:
  const q = `SELECT * FROM users WHERE email = '${email}'`;

✏️ After:
  const q = `SELECT * FROM users WHERE email = $1`;
  db.query(q, [email]);

📊 Impact: Eliminates SQL injection vulnerability. Critical — fix before deployment.

11. Common Red Flags (Instant Review Triggers)

PatternProblem
catch (e) {}Silent error swallowing
console.log in productionDebug code left in
TODO: commentsUnfinished work shipped
any type in TypeScriptDefeats the purpose of TypeScript
Hardcoded localhost or IPBreaks in any other environment
SELECT * in SQL queriesFetches unneeded data, breaks on schema change
eval() or innerHTML with user dataXSS vulnerability
Math.random() for security tokensNot cryptographically secure
Synchronous file reads in Node.jsBlocks event loop
Unbounded loops without exit conditionsInfinite loop risk

Resources

  • Clean Code — Robert C. Martin (Book)
  • Refactoring — Martin Fowler (Book)
  • OWASP Top 10: owasp.org/www-project-top-ten
  • Google Engineering Practices: google.github.io/eng-practices/review
  • MDN Web Docs: developer.mozilla.org
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 468kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 468kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 468kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall