Checklist de revision de codigo con Claude Code

Optimizando la revision de codigo con Claude Code

La revision de codigo es un proceso importante para mantener la calidad, pero la carga sobre los revisores es un desafio significativo. Aprovechando Claude Code, puedes realizar revisiones eficientes basadas en checklists sistematicos.

Verificacion de seguridad

> Revisa el codigo de este PR desde la perspectiva de seguridad.
> Verifica XSS, inyeccion SQL y vulnerabilidades de autenticacion.

// Checklist de seguridad
const securityChecks = {
  // 1. Validacion de entrada
  inputValidation: {
    check: 'La entrada del usuario esta sanitizada',
    bad: `element.innerHTML = userInput;`,
    good: `element.textContent = userInput;`,
  },

  // 2. Inyeccion SQL
  sqlInjection: {
    check: 'Se usan consultas parametrizadas',
    bad: `db.query(\`SELECT * FROM users WHERE id = \${userId}\`);`,
    good: `db.query('SELECT * FROM users WHERE id = ?', [userId]);`,
  },

  // 3. Autenticacion y autorizacion
  auth: {
    check: 'Los endpoints de API tienen middleware de autenticacion',
    bad: `app.get('/api/admin/users', handler);`,
    good: `app.get('/api/admin/users', requireAuth, requireAdmin, handler);`,
  },

  // 4. Exposicion de informacion secreta
  secrets: {
    check: 'Las variables de entorno no se filtran al cliente',
    bad: `const apiKey = "sk-1234567890abcdef";`,
    good: `const apiKey = process.env.API_KEY;`,
  },
};

Verificacion de rendimiento

// Checklist de rendimiento
const performanceChecks = [
  {
    item: 'No se producen consultas N+1',
    bad: `
      const users = await db.user.findMany();
      for (const user of users) {
        const posts = await db.post.findMany({ where: { userId: user.id } });
      }`,
    good: `
      const users = await db.user.findMany({
        include: { posts: true },
      });`,
  },
  {
    item: 'No hay re-renderizados innecesarios',
    bad: `
      function Component() {
        const handler = () => doSomething();
        return <Child onClick={handler} />;
      }`,
    good: `
      function Component() {
        const handler = useCallback(() => doSomething(), []);
        return <Child onClick={handler} />;
      }`,
  },
  {
    item: 'Se aplica virtualizacion a listas grandes',
    check: 'Listas de mas de 1000 elementos -> considerar react-virtual',
  },
];

Verificacion de legibilidad y mantenibilidad

> Sugiere mejoras de legibilidad para este codigo.
> Verifica convenciones de nombres, longitud de funciones y adecuacion de comentarios.

// Puntos de verificacion de legibilidad

// 1. Longitud de funciones (ideal: menos de 30 lineas)
// No recomendado: todo el procesamiento en una sola funcion
async function processOrder(order: Order) {
  // 100 lineas de procesamiento...
}

// Recomendado: dividir por responsabilidad
async function processOrder(order: Order) {
  const validated = validateOrder(order);
  const priced = calculateTotal(validated);
  const payment = await processPayment(priced);
  return createConfirmation(payment);
}

// 2. Patron de retorno anticipado
// No recomendado: anidamiento profundo
function getDiscount(user: User) {
  if (user) {
    if (user.isPremium) {
      if (user.orders > 10) {
        return 0.2;
      }
      return 0.1;
    }
    return 0.05;
  }
  return 0;
}

// Recomendado: retorno anticipado
function getDiscount(user: User) {
  if (!user) return 0;
  if (!user.isPremium) return 0.05;
  if (user.orders > 10) return 0.2;
  return 0.1;
}

// 3. Eliminacion de numeros magicos
// No recomendado
if (status === 3) { /* ... */ }

// Recomendado
const ORDER_STATUS = { PENDING: 1, PROCESSING: 2, COMPLETED: 3 } as const;
if (status === ORDER_STATUS.COMPLETED) { /* ... */ }

Verificacion de manejo de errores

// Puntos de verificacion de manejo de errores

// No recomendado: suprimir errores
try {
  await saveData(data);
} catch (e) {
  // No hacer nada
}

// Recomendado: manejo adecuado de errores
try {
  await saveData(data);
} catch (error) {
  logger.error('Fallo al guardar datos', { error, data: data.id });
  throw new AppError('SAVE_FAILED', 'Fallo al guardar los datos', { cause: error });
}

Script de automatizacion de revision

// scripts/review-check.ts
import { execSync } from 'child_process';

interface ReviewIssue {
  file: string;
  line: number;
  severity: 'error' | 'warning' | 'info';
  message: string;
}

function checkForIssues(): ReviewIssue[] {
  const issues: ReviewIssue[] = [];
  const diff = execSync('git diff --cached --name-only').toString().split('\n');

  for (const file of diff.filter(f => f.endsWith('.ts') || f.endsWith('.tsx'))) {
    const content = execSync(`git show :${file}`).toString();
    const lines = content.split('\n');

    lines.forEach((line, index) => {
      // Verificacion de console.log
      if (line.includes('console.log') && !file.includes('scripts/')) {
        issues.push({
          file, line: index + 1, severity: 'warning',
          message: 'Queda un console.log',
        });
      }

      // Verificacion de TODO/FIXME
      if (/\/\/\s*(TODO|FIXME|HACK)/i.test(line)) {
        issues.push({
          file, line: index + 1, severity: 'info',
          message: 'Hay un comentario TODO/FIXME',
        });
      }

      // Verificacion de tipo any
      if (/:\s*any\b/.test(line)) {
        issues.push({
          file, line: index + 1, severity: 'warning',
          message: 'Se esta usando el tipo any',
        });
      }
    });
  }

  return issues;
}

const issues = checkForIssues();
issues.forEach(i => console.log(`[${i.severity}] ${i.file}:${i.line} - ${i.message}`));

Resumen

La revision de codigo esta estrechamente relacionada con las estrategias de testing. Con Claude Code, puedes realizar revisiones sistematicas y eficientes desde las perspectivas de seguridad, rendimiento y legibilidad. Combinandolo con las tecnicas de programacion en pareja con IA, puedes lograr tanto calidad como velocidad en las revisiones. Para las mejores practicas de revision de codigo, consulta Google Engineering Practices.