Especialista en Deuda Tecnica y Code Smells
Un agente de IA especializado en identificar code smells, deuda tecnica y problemas de mantenibilidad que causaran problemas a medida que tu codigo crece. Encuentra problemas estructurales antes de que se acumulen.
Problemas estructurales que dificultan mantener, extender o entender el codigo
Problemas estructurales que indican problemas mas profundos en el diseno de tu codigo
Problemas de diseno orientado a objetos que dificultan cambiar y probar el codigo
Violaciones de principios de diseno fundamentales que llevan a codigo rigido y fragil
Caminos de codigo demasiado complejos para entender, probar o mantener de forma segura
Limites objetivos que senalan cuando el codigo necesita refactorizacion
Los metodos deben caber en una pantalla
Las clases deben tener responsabilidad unica
Considera usar un objeto de opciones
Extrae funciones o usa retornos tempranos
Demasiados caminos para probar confiablemente
Extrae a una funcion compartida
Ve como el Asesor de Refactorizacion identifica problemas y sugiere patrones especificos
function processOrder(order) {
// Validar orden
if (!order.items || order.items.length === 0) {
throw new Error('Orden vacia')
}
if (!order.customer) {
throw new Error('Sin cliente')
}
// Calcular totales
let subtotal = 0
for (const item of order.items) {
subtotal += item.price * item.quantity
}
const tax = subtotal * 0.1
const total = subtotal + tax
// Aplicar descuentos
let discount = 0
if (order.customer.isPremium) {
discount = total * 0.15
} else if (subtotal > 100) {
discount = total * 0.05
}
return total - discount
}Metodo haciendo 4 cosas: validacion, calculo, impuestos, descuentos
function processOrder(order) {
validateOrder(order)
const subtotal = calculateSubtotal(order.items)
const total = applyTax(subtotal)
return applyDiscount(total, order.customer)
}
function validateOrder(order) {
if (!order.items?.length) throw new Error('Orden vacia')
if (!order.customer) throw new Error('Sin cliente')
}
function calculateSubtotal(items) {
return items.reduce((sum, item) =>
sum + item.price * item.quantity, 0)
}Extract Method: cada funcion hace una sola cosa bien
function calculateShipping(order) {
switch (order.shippingType) {
case 'express':
return order.weight * 5.0 + 15
case 'standard':
return order.weight * 2.5 + 5
case 'economy':
return order.weight * 1.0
case 'freight':
return order.weight * 0.5 + 50
default:
throw new Error('Tipo desconocido')
}
}Switch que crece con cada nuevo tipo de envio
interface ShippingStrategy {
calculate(weight: number): number
}
const shippingStrategies: Record<string, ShippingStrategy> = {
express: { calculate: w => w * 5.0 + 15 },
standard: { calculate: w => w * 2.5 + 5 },
economy: { calculate: w => w * 1.0 },
freight: { calculate: w => w * 0.5 + 50 },
}
function calculateShipping(order) {
const strategy = shippingStrategies[order.shippingType]
if (!strategy) throw new Error('Tipo desconocido')
return strategy.calculate(order.weight)
}Patron Strategy: agregar nuevos tipos sin modificar codigo existente
class OrderProcessor {
calculateTax(order) {
const subtotal = order.items.reduce((sum, item) =>
sum + item.price * item.quantity, 0)
const taxRate = order.customer.region === 'EU'
? order.customer.country.vatRate
: 0.0
return subtotal * taxRate
}
}OrderProcessor conoce demasiado sobre los internos de Order y Customer
class Order {
calculateSubtotal() {
return this.items.reduce((sum, item) =>
sum + item.price * item.quantity, 0)
}
calculateTax() {
return this.calculateSubtotal() * this.customer.getTaxRate()
}
}
class Customer {
getTaxRate() {
return this.region === 'EU' ? this.country.vatRate : 0.0
}
}Mover comportamiento a la clase que posee los datos
El Asesor de Refactorizacion no solo mide metricas — entiende patrones de diseno y sugiere tecnicas de refactorizacion especificas que mejoraran la estructura de tu codigo.
Identifica code smells y anti-patrones en la estructura de tu codigo
Sugiere patrones especificos: Extract Method, Replace Conditional, Move Method
Verifica adherencia a SRP, OCP, LSP, ISP y DIP
Medir Metricas
Calcula longitud de metodos/clases y puntuaciones de complejidad
Identificar Patrones
Detecta code smells y anti-patrones de diseno
Verificar SOLID
Verifica la adherencia a los principios de diseno
Sugerir Refactorizacion
Recomienda patrones especificos como Extract Method, Replace Conditional with Polymorphism
Se enfoca en problemas que CAUSARAN problemas de mantenimiento, no en detalles de estilo
Codigo copiado y pegado que debe cambiarse en multiples lugares
Clases haciendo demasiadas cosas, imposibles de probar
Funciones con demasiados caminos para probar confiablemente
Omitidos en favor de problemas estructurales
La deuda tecnica se acumula exponencialmente.
El Asesor de Refactorizacion la detecta temprano.
Deja que el Asesor de Refactorizacion detecte problemas estructurales antes de que se acumulen. Gratis por 14 dias, sin tarjeta de credito.