code-quality

Code Quality & Refactoring

Best practices for writing clean, maintainable, and high-quality code based on proven patterns from Vercel, Anthropic, and industry standards.

When to Use This Skill

• Reviewing code for quality issues
• Refactoring existing code
• Reducing complexity
• Improving testability
• Applying design patterns
• Code review feedback

Code Quality Principles

SOLID Principles

// ❌ BAD: Class doing too much (violates SRP)
class TaskManager {
  createTask(title: string) { /* ... */ }
  updateTask(id: string, data: Partial<Task>) { /* ... */ }
  deleteTask(id: string) { /* ... */ }
  sendTaskNotification(taskId: string) { /* ... */ }
  generateTaskReport(taskId: string) { /* ... */ }
  syncTaskToExternalService(taskId: string) { /* ... */ }
}

// ✅ GOOD: Single Responsibility Principle
class TaskRepository {
  create(title: string): Task { /* ... */ }
  update(id: string, data: Partial<Task>): Task { /* ... */ }
  delete(id: string): void { /* ... */ }
}

class TaskNotificationService {
  notify(taskId: string): void { /* ... */ }
}

class TaskReportGenerator {
  generate(taskId: string): Report { /* ... */ }
}

Open/Closed Principle

// ❌ BAD: Must modify class to add new behavior
class AttentionHandler {
  handle(type: AttentionType, step: AgentStep) {
    if (type === 'supervised') {
      // supervised logic
    } else if (type === 'delegated') {
      // delegated logic
    } else if (type === 'sensitive') {
      // sensitive logic
    }
    // Adding new type requires modifying this class
  }
}

// ✅ GOOD: Open for extension, closed for modification
interface AttentionStrategy {
  handle(step: AgentStep): Promise<boolean>;
}

class SupervisedStrategy implements AttentionStrategy {
  async handle(step: AgentStep): Promise<boolean> {
    // Always require approval
    return await requestUserApproval(step);
  }
}

class DelegatedStrategy implements AttentionStrategy {
  async handle(step: AgentStep): Promise<boolean> {
    // Auto-approve
    return true;
  }
}

class SensitiveStrategy implements AttentionStrategy {
  private sensitiveTools = ['run_command', 'delete_file'];
  
  async handle(step: AgentStep): Promise<boolean> {
    if (this.sensitiveTools.includes(step.toolCall?.name ?? '')) {
      return await requestUserApproval(step);
    }
    return true;
  }
}

// New attention types just add new strategy classes