Code Review Expert | Bootspring Docs

The Code Review Expert agent specializes in code review, best practices, code quality, identifying improvements, and ensuring maintainable, readable code.

Expertise Areas#

Functionality Review - Correctness, edge cases, error handling
Security Review - Input validation, SQL injection, XSS prevention
Performance Review - N+1 queries, memory leaks, optimization
Maintainability Review - Readability, single responsibility, DRY
Testing Review - Test coverage, meaningful tests
TypeScript Review - Type safety, proper typing patterns
React Review - Anti-patterns, hooks usage, rendering optimization
Database Review - Query efficiency, transactions, indexing

Usage Examples#

Code Quality Review#

Use the code-review-expert agent to review this React component for best practices and potential issues.

Response includes:

Functionality assessment
Anti-pattern identification
Performance suggestions
Refactoring recommendations

Security Review#

Use the code-review-expert agent to review this API route for security vulnerabilities.

Response includes:

Input validation check
SQL injection analysis
Authentication verification
Data exposure assessment

Performance Review#

Use the code-review-expert agent to identify performance issues in this database query code.

Response includes:

N+1 query detection
Index recommendations
Query optimization suggestions
Caching opportunities

Best Practices Applied#

1. Async/Await Patterns#

Parallel execution with Promise.all
Proper error handling
Avoiding sequential when parallel possible

2. React Patterns#

Avoiding useEffect for derived state
Proper dependency arrays
useCallback for stable references
useMemo for expensive computations

3. TypeScript Patterns#

Proper typing over 'any'
Safe null handling
Optional chaining with fallbacks

4. Database Patterns#

Include related data to avoid N+1
Select only needed fields
Use transactions for related operations

Common Patterns#

Async/Await Best Practice#

// Bad: Sequential when could be parallel
async function getBothUsers(id1: string, id2: string) {
  const user1 = await getUser(id1);
  const user2 = await getUser(id2);
  return [user1, user2];
}

// Good: Parallel execution
async function getBothUsers(id1: string, id2: string) {
  const [user1, user2] = await Promise.all([
    getUser(id1),
    getUser(id2),
  ]);
  return [user1, user2];
}

React Anti-Pattern Fix#

// Bad: useEffect for derived state
function BadComponent({ items }) {
  const [count, setCount] = useState(0);
  useEffect(() => {
    setCount(items.length);
  }, [items]);
  return <div>Count: {count}</div>;
}

// Good: Derive directly
function GoodComponent({ items }) {
  const count = items.length;
  return <div>Count: {count}</div>;
}

Database Query Optimization#

// Bad: N+1 query problem
const posts = await prisma.post.findMany();
for (const post of posts) {
  post.author = await prisma.user.findUnique({
    where: { id: post.authorId }
  });
}

// Good: Include related data
const posts = await prisma.post.findMany({
  include: { author: true }
});

Early Returns for Clarity#

// Bad: Deep nesting
if (user) {
  if (user.isActive) {
    if (user.hasPermission) {
      // do something
    }
  }
}

// Good: Early returns
if (!user) return;
if (!user.isActive) return;
if (!user.hasPermission) return;
// do something

Sample Prompts#

Task	Prompt
General review	"Review this code for best practices and potential issues"
Security audit	"Check this authentication code for security vulnerabilities"
Performance check	"Identify performance bottlenecks in this data fetching code"
Refactoring	"Suggest refactoring improvements for this component"
TypeScript review	"Review the type safety of this module"

Configuration#

// bootspring.config.js
module.exports = {
  agents: {
    customInstructions: {
      'code-review-expert': `
        - Focus on maintainability and readability
        - Identify security vulnerabilities
        - Check for performance issues
        - Suggest TypeScript improvements
        - Look for React anti-patterns
      `,
    },
  },
  linting: {
    eslint: true,
    typescript: 'strict',
  },
};

Security Expert - Deep security analysis
Performance Expert - Performance optimization
Testing Expert - Test coverage review