code-review

Code Review Patterns

1. Code Quality Checks

Naming Conventions

• Variables: camelCase for locals, PascalCase for classes/types
• Constants: SCREAMING_SNAKE_CASE or camelCase depending on scope
• Files: Match the primary export name
• Boolean variables: Use is, has, should, can prefixes

Function Quality

• Single responsibility principle
• Max 20-30 lines per function
• Max 3-4 parameters (use object for more)
• Early returns to reduce nesting
• Meaningful function names (describe what, not how)

Code Smells to Detect

Smell	Detection	Suggestion
Long function	>30 lines	Break into smaller functions
Deep nesting	>3 levels	Extract to helper functions
Magic numbers	Unnamed literals	Extract to named constants
Duplicate code	Similar blocks	Extract to shared function
Dead code	Unused imports/vars	Remove
Large files	>300 lines	Consider splitting

2. Error Handling Patterns

Good Patterns

// Early return with error
function process(data: Data): Result | Error {
  if (!data) return new Error('Data required')
  if (!data.valid) return new Error('Invalid data')
  return processValidData(data)
}

// Result type pattern
type Result<T> = { ok: true; value: T } | { ok: false; error: string }

Anti-Patterns

// Swallowing errors
try { something() } catch (e) { /* silent */ }

// Empty catch blocks
try { risky() } catch (e) {}

// Catching without handling
try { operation() } catch (e) { throw e }

3. Performance Checks

Common Issues

• N+1 queries in loops
• Missing memoization opportunities
• Large bundle imports
• Synchronous operations that could be async
• Unnecessary re-renders (React)
• Missing indexes on queried fields

Red Flags

// In loop - potential N+1
for (const user of users) {
  await fetchUserDetails(user.id)
}

// Better
const details = await Promise.all(
  users.map(u => fetchUserDetails(u.id))
)