Generación de Código que Realmente Funciona

La Trampa del Copy-Paste

Aquí va el error más común que los developers cometen con generación de código por IA: escriben un prompt vago, reciben 50 líneas de código genérico, lo pegan y se pasan la siguiente hora arreglándolo para que encaje en su codebase.

Eso no es desarrollo asistido por IA. Eso es desarrollo obstruido por IA.

La solución no es mejor IA. Son mejores prompts. Cuando le das a la IA el contexto correcto, no solo genera código — genera código que parece como si tu equipo lo hubiera escrito.

Déjame mostrarte la diferencia.

Vago vs. Específico: Un Ejemplo Real

El prompt vago:

Escribe una función para manejar registro de usuarios.

Te devuelve algo genérico. Quizás Express.js, quizás Flask, quizás algo sin framework. Usa convenciones que no sigues y patrones que no encajan con tu codebase.

El prompt específico:

Escribe un endpoint de registro de usuarios para nuestra API Express.js.

Nuestros patrones:
- Usamos TypeScript con modo estricto
- Los controllers son clases con métodos estáticos
- La validación usa esquemas Zod
- Los errores lanzan AppError(statusCode, message)
- Passwords hasheados con bcrypt (12 rondas)
- Respuestas siguen { success: boolean, data?: T, error?: string }

Aquí va un endpoint existente de referencia:

static async login(req: Request, res: Response) {
  const { email, password } = LoginSchema.parse(req.body);
  const user = await UserRepository.findByEmail(email);
  if (!user) throw new AppError(401, 'Invalid credentials');
  const valid = await bcrypt.compare(password, user.passwordHash);
  if (!valid) throw new AppError(401, 'Invalid credentials');
  const token = generateToken(user.id);
  res.json({ success: true, data: { token, user: sanitize(user) } });
}

Escribe el método register siguiendo los mismos patrones.

El segundo prompt produce código que entra directo en tu codebase. Mismos patrones, mismo manejo de errores, mismo formato de respuesta. ¿Por qué? Porque le mostraste a la IA exactamente cómo se ve “correcto.”

Las Tres Capas de Contexto

Al generar código, piensa en el contexto en tres capas:

Capa 1: Contexto del Proyecto

¿Qué stack usas? ¿Qué convenciones sigue tu equipo? ¿Qué patrones ya están establecidos?

Proyecto: API REST Node.js/TypeScript
Framework: Express con patrón de middleware
Base de datos: PostgreSQL vía Prisma ORM
Auth: JWT con refresh tokens
Testing: Jest + Supertest

No necesitas repetir esto cada vez — pero para conversaciones nuevas con la IA, un breve resumen del proyecto ahorra mucho ir y venir.

Capa 2: Contexto de Código

¿Qué código existente es relevante? Este es el contexto más poderoso que puedes dar. Pega:

• El archivo al que estás agregando (o al menos las partes relevantes)
• Interfaces o tipos relacionados
• Funciones similares que demuestren tus patrones
• Esquemas de base de datos o modelos involucrados

Capa 3: Contexto de Tarea

¿Qué necesita pasar específicamente? Sé concreto:

Agrega un endpoint PATCH /users/:id/preferences que:
- Acepte actualizaciones parciales a preferencias del usuario
- Valide que notification_email sea un email válido si se proporciona
- Valide que theme sea uno de: 'light', 'dark', 'system'
- Retorne el objeto de preferencias actualizado
- Requiera autenticación (usa nuestro authMiddleware)

✅ Revisión Rápida: ¿Cuáles son las tres capas de contexto que deberías dar al generar código con IA?

Generando Código Incrementalmente

Las tareas grandes producen peores resultados que las pequeñas. Cuando pides un feature completo de una vez, la IA tiene que manejar demasiadas cosas: tipos, validación, lógica de negocio, manejo de errores, queries a la base de datos, formateo de respuestas.

Mejor divídelo:

Paso 1: Tipos e interfaces primero

Basándote en nuestro esquema Prisma de User, crea un esquema
de validación Zod para actualizar preferencias de usuario.
Campos: theme (light/dark/system), notification_email
(email válido), language (código ISO 639-1).
Todos los campos opcionales para actualizaciones parciales.

Paso 2: Lógica de negocio

Escribe el método updatePreferences para UserService.
Debe aceptar un userId y el objeto de preferencias parciales
validado. Usa nuestro patrón existente de
UserService.updateProfile (mostrado abajo).

[pega el método updateProfile]

Paso 3: Controller y ruta

Crea el método del controller y el registro de ruta para
PATCH /users/:id/preferences. Sigue el patrón de nuestras
rutas existentes de usuario (mostradas abajo).

[pega el archivo de rutas relevante]

Cada pieza es enfocada. Cada pieza construye sobre output verificado del paso anterior. Y si algo sale mal, sabes exactamente dónde.

Manejando Errores de la IA en Código Generado

El código generado por IA a veces está mal. No catastróficamente mal — generalmente sutilmente mal. Estos son los patrones a vigilar:

APIs alucinadas. La IA inventa un método que no existe en la versión de la librería que usas. Siempre verifica que los métodos, parámetros y tipos de retorno existan en tu versión.

# La IA podría generar esto para pandas 2.x
df.append(new_row)  # MAL: .append() fue removido en pandas 2.0
# Correcto:
df = pd.concat([df, pd.DataFrame([new_row])])

Patrones obsoletos. Los datos de entrenamiento de la IA incluyen código viejo. Podrías recibir componentWillMount en React o var en JavaScript moderno. Especifica tus versiones explícitamente.

Manejo de errores faltante. La IA tiende a generar el happy path hermosamente y olvidar edge cases. Después de generar código, siempre pregunta: “¿Qué manejo de errores le falta a este código?”

Suposiciones incorrectas sobre tus datos. La IA podría asumir que un campo siempre está presente cuando es nullable, o que un array nunca está vacío. Cruza con tu esquema real.

Puntos ciegos de seguridad. El código generado por IA a veces se salta sanitización de input, usa métodos criptográficos deprecados o crea vulnerabilidades de SQL injection. Nunca confíes a la IA código crítico de seguridad sin revisión cuidadosa.

El Principio de “Muestra, No Digas”

El patrón más efectivo de generación de código es mostrar a la IA lo que quieres a través de ejemplos en vez de describirlo con palabras.

Decir (menos efectivo):

Escribe funciones que sigan principios de programación
funcional con inmutabilidad y funciones puras.

Mostrar (mucho más efectivo):

Escribe la función calculateDiscount siguiendo el mismo
patrón que estas funciones existentes:

const calculateTax = (price: number, rate: number): Money => ({
  amount: Math.round(price * rate * 100) / 100,
  currency: 'USD',
});

const calculateShipping = (weight: number, zone: Zone): Money => ({
  amount: ZONE_RATES[zone] * Math.ceil(weight),
  currency: 'USD',
});

La IA inmediatamente detecta tus patrones: TypeScript con tipos explícitos, funciones puras, el tipo de retorno Money, la convención de redondeo. No tuviste que explicar nada de eso.

Ejercicio Práctico

Prueba esto con tu propio codebase ahora:

1. Elige un feature que necesites construir (o que construiste recientemente)
2. Encuentra 1-2 componentes/funciones similares existentes
3. Escribe un prompt que incluya tu contexto de proyecto, los ejemplos de código y los requerimientos específicos
4. Genera el código
5. Compáralo con lo que habrías escrito manualmente

Fíjate qué acertó la IA y qué necesitó ajustes. Esa brecha se reducirá dramáticamente conforme mejores dando contexto.

Conclusiones Clave

• Prompts específicos con ejemplos le ganan a solicitudes vagas siempre
• Proporciona tres capas de contexto: proyecto, código y tarea
• Divide tareas complejas de generación en pasos más pequeños y enfocados
• Siempre verifica el output de la IA — vigila APIs alucinadas y manejo de errores faltante
• Muestra tus patrones a la IA con ejemplos de código, no con descripciones en prosa
• El código generado por IA es un primer borrador, no un producto final

Siguiente

En la Lección 3: Debugging y Resolución de Errores con IA, aprenderás a convertir mensajes de error crípticos en explicaciones claras y sugerencias de corrección cuando las cosas se pongan feas.