Refactoring con IA: De Legacy Code a Clean Code

🏚️ El Desafío del Legacy Code

El código legacy (heredado) es código sin tests, difícil de entender y miedo de tocar. Refactorizarlo manualmente es lento y arriesgado. Aquí es donde la IA brilla como una herramienta de transformación masiva.

La Regla de los Scouts

“Deja el código más limpio de lo que lo encontraste”. Con IA, no solo recoges la basura, construyes un parque.

🛠️ Estrategias de Refactoring Asistido

1. “Explain First” (Entender antes de cambiar)

Antes de tocar nada, pide a la IA que te explique qué hace esa clase de 2000 líneas.

Prompt: “Actúa como un desarrollador Senior. Explica paso a paso qué hace la función processOrder en este código Java antiguo. Identifica los efectos secundarios (side effects).”

Esto te da un mapa mental y te alerta de peligros ocultos.

2. Generación de Tests de Caracterización (Safety Net)

El mayor miedo al refactorizar es romper algo. Usa la IA para generar tests que “congelen” el comportamiento actual, incluso si es incorrecto (bugs documentados).

Prompt: “Genera tests JUnit para esta clase LegacyCalculator. El objetivo es cubrir el comportamiento actual, incluyendo edge cases, para asegurar que no rompo nada al refactorizar.”

3. Migración Java -> Kotlin Idiomático

El convertidor automático de Android Studio (Ctrl+Alt+Shift+K) hace un trabajo decente, pero deja mucho código “Java en Kotlin” (!!, lateinit abusivos).

Workflow con IA:

1. Convierte el archivo a Kotlin con AS.
2. Pide a la IA: “Refactoriza este código Kotlin para hacerlo más idiomático. Usa Scope Functions (let, apply), Data Classes y elimina nulos innecesarios.”

4. Extracción de Lógica (De God Class a SRP)

Si tienes una MainActivity gigante.

Prompt: “Analiza este código. Extrae toda la lógica relacionada con la validación de usuario a una nueva clase UserValidator. Extrae la lógica de red a un UserRepository. Dame solo el código de las nuevas clases y cómo instanciarlas en la Activity.”

⚠️ Peligros del Refactoring con IA

1. Cambio de Lógica Sutil: La IA puede “optimizar” un loop y cambiar el orden de ejecución, lo cual podría afectar el resultado si hay efectos secundarios. Siempre confía en tus tests.
2. Pérdida de Comentarios: A veces la IA elimina comentarios importantes. Pide explícitamente “Mantén los comentarios relevantes o conviértelos en KDoc”.

🎯 Caso de Estudio: AsyncTask a Coroutines

Input (Legacy):

new AsyncTask<Void, Void, String>() {
    protected String doInBackground(Void... params) {
        return api.getData();
    }
    protected void onPostExecute(String result) {
        textView.setText(result);
    }
}.execute();

Prompt: “Migra este AsyncTask a Kotlin Coroutines usando viewModelScope y gestionando el ciclo de vida.”

Output (IA):

viewModelScope.launch {
    try {
        val result = withContext(Dispatchers.IO) {
            api.getData()
        }
        _uiState.value = result
    } catch (e: Exception) {
        // Error handling
    }
}

🚀 Conclusión

La IA convierte el refactoring de una tarea temida a una actividad creativa y gratificante. Te permite moverte a una velocidad increíble, pero requiere que actúes como un Auditor de Calidad estricto. Nunca hagas commit de un refactoring de IA sin revisar los tests.