La IA no crea lo que tú no sabes

Una confesión después de 5 meses de enseñar y programar con asistentes inteligentes

Tengo una regla personal: nunca uses algo complejo si puedes hacerlo sencillo. Suena obvio, pero en el mundo de la programación parece una herejía. Hay una presión constante por usar el framework de moda, la arquitectura más distribuida, el lenguaje más trendy. Y ahora, con la IA, la presión se multiplica.

"La IA te va a reemplazar", "La IA hace código mejor que tú", "Si no usas IA te quedas atrás". Llevo meses programando con IA. Probando OpenCode, Hermes, OpenDesign. Y he llegado a una conclusión incómoda: La IA no crea lo que tú no sabes.

El mito de la IA creadora

Hay una idea errónea de que la IA es una especie de maga que genera soluciones desde la nada. Que puedes pedirle cualquier cosa y ella te dará el código perfecto. No es así.

La IA es un predictor estadístico. Genera lo que es más probable basado en lo que ha visto. Si le pides algo complejo, te va a dar algo que parece complejo, pero que puede estar lleno de errores, de malas prácticas, de suposiciones incorrectas.

Y aquí está el problema: solo puedes detectar esos errores si ya sabes lo que estás buscando.

• Si no sabes cómo funciona un fetch, no vas a notar que la IA está manejando mal los errores de red.
• Si no entiendes Java Beans, no vas a ver que está violando principios básicos de encapsulamiento.
• Si no conoces MongoDB en profundidad, no te darás cuenta de que la consulta que generó va a explotar en producción.

La IA no te da conocimiento. Te da código. Y el código sin conocimiento es peligroso.

Mi stack simple: Por qué no necesito más

Uso Nginx como proxy. Tomcat como servidor de aplicaciones. MongoDB como base de datos. Java con Beans. JavaScript vainilla con Fetch API. ES6 para mantenerlo limpio.

Nada de Spring Boot. Nada de React. Nada de microservicios. Nada de 50 dependencias en un package.json.

¿Por qué? Porque cuando la IA me genera algo, puedo leerlo completo. Puedo entender cada línea. Puedo saber si está haciendo algo extraño. Puedo depurarlo sin tener que aprender una capa de abstracción nueva.

Un stack simple es un stack depurable. Y en la era de la IA, la depuración es más importante que la generación de código.

// Ejemplo: Un bean simple en Java
// La IA puede generar esto, pero ¿entiendes por qué?
public class UsuarioBean {
    private String id;
    private String nombre;
    private String email;

    public UsuarioBean() {}

    public String getId() { return id; }
    public void setId(String id) { this.id = id; }

    public String getNombre() { return nombre; }
    public void setNombre(String nombre) { this.nombre = nombre; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

// Si no entiendes Java Beans, la IA te puede generar algo que funcione
// pero que no siga las convenciones del framework que estás usando.
// Y cuando falle, no sabrás por qué.

El vendedor de humo: La urgencia fabricada

Hay un negocio que me enferma: el de crear urgencia. "Si no aprendes IA ahora, te quedas sin trabajo en 6 meses." "Si no compras mi curso de Python en 21 días, nunca serás programador." "Si no usas este framework, tu código es obsoleto."

Es mentira. Todo es mentira.

La programación no es una carrera de 100 metros. Es una maratón. Y los que corren con urgencia, los que toman atajos, los que compran soluciones rápidas, son los primeros en quemarse y en fracasar.

Mi asistente lleva 5 meses aprendiendo conmigo. Es excelente. Estudioso. Motivado. Y aún así, no está listo. ¿Y sabes qué? Eso está bien. No tiene que estar listo en 21 días. No tiene que ser senior en 6 meses. Tiene que construir cimientos sólidos. Tiene que equivocarse. Tiene que preguntar. Tiene que frustrarse y volver a intentarlo.

Nunca, nunca, le pido a la IA que resuelva algo que yo no entiendo. Porque si no entiendo el problema, no puedo evaluar la solución.

// Cómo uso la IA en mi día a día
// 1. Le pido que me genere un mapper
// 2. Reviso que el mapper cumpla con la lógica de negocio
// 3. Lo ajusto si es necesario
// 4. Lo integro

// La IA genera esto:
const mapUsuario = (data) => ({
    id: data._id,
    nombreCompleto: `${data.nombre} ${data.apellido}`,
    email: data.correo?.toLowerCase() || 'sin-email'
});

// Yo reviso y sé que:
// - Si data._id no existe, va a fallar
// - Si data.correo es null, el optional chaining lo maneja
// - El operador || da un valor por defecto
// - La lógica de negocio está correcta

El valor del stack simple con IA

¿Por qué insisto tanto en la simplicidad del stack? Porque la IA funciona mejor cuando el dominio es pequeño y bien definido.

Si usas un stack simple:

• La IA tiene menos "ruido" en su contexto
• Genera código más predecible
• Es más fácil verificar lo que genera
• El código generado es más fácil de mantener por humanos

Si usas un stack complejo:

• La IA alucina más a menudo
• Genera código que depende de bibliotecas que quizá no tienes
• Es más difícil saber si lo que generó es correcto
• El código generado es más difícil de mantener sin el framework

Una invitación a la honestidad

Si estás empezando, te invito a ser honesto contigo mismo:

• ¿Quieres aprender rápido o quieres aprender bien?
• ¿Quieres copiar código o quieres entenderlo?
• ¿Quieres vender humo o quieres construir cosas reales?

Si eliges lo segundo, acepta que va a tomar tiempo. Acepta que vas a sentirte tonto muchas veces. Acepta que la IA no es una varita mágica. Pero también acepta que, cuando finalmente entiendas algo, nadie te lo va a quitar. Y que ese conocimiento, construido con paciencia, vale más que 100 cursos de 21 días.

La verdad que nadie cuenta

La industria tech está llena de vendedores de humo. Gente que gana dinero vendiendo la ilusión de que aprender a programar es fácil y rápido.

¿La verdad? Programar es difícil. Es frustrante. Es lleno de momentos en los que quieres tirar la computadora por la ventana. Pero también es maravilloso. Es creativo. Es resolver puzzles todo el día. Es ver cómo algo que existía solo en tu cabeza se convierte en realidad.

Y eso, lo difícil y lo maravilloso, solo se logra con tiempo. No con cursos de 21 días. No con prompts mágicos de IA. No con frameworks que prometen hacerlo todo. Con tiempo. Con práctica. Con errores. Con paciencia.

Lo que viene

Seguiré escribiendo sobre mi experiencia. Sobre lo que funciona y lo que no. Sobre los errores que cometo y los que veo cometer. Sobre la IA, los stacks simples y la honestidad intelectual.

No prometo ser el más popular. Prometo ser el más honesto.

Si llegaste hasta aquí, gracias por leer. ¿Cuánto tiempo llevas programando? ¿Qué es lo que más te ha costado aprender? ¿Has sentido alguna vez que te vendieron humo con un curso exprés? Comparte tu historia. Quiero leerte.