Cuando escribiste tu primera línea de código, ya estabas haciendo lo mismo que hoy al escribirle a un modelo de IA.
Solo que el idioma era más difícil.
El ensamblador te obligaba a hablarle a la máquina en su propio lenguaje: registros, instrucciones, direcciones de memoria. Era eficiente. Era también casi inhumano. Luego llegaron C, Java, Python: la máquina fue aprendiendo un idioma más cercano al tuyo. Y ahora, con los modelos de lenguaje, la máquina llegó por fin a tu terreno.
Setenta años moviéndose en la misma dirección: cerrar la brecha entre cómo piensas y cómo le dices a la máquina lo que quieres.
El vibe coding no es una moda. Es la conclusión lógica de ese recorrido.
Lo que no cambia
Cuando hay que escribir la función de Fibonacci, algunos programadores la hacen recursiva. Otros la hacen iterativa. Ambas están bien. Ambas hacen lo mismo.
Pero no son iguales.
La recursiva revela un pensamiento que ve el problema como un árbol que se llama a sí mismo. La iterativa revela uno que ve una secuencia que avanza paso a paso. Son firmas cognitivas. El mismo resultado, dos modelos mentales distintos.
Lo mismo pasa con los prompts.
Dos personas le piden a un modelo que les genere el mismo componente. Una escribe tres líneas y obtiene algo funcional. Otra escribe diez líneas y obtiene exactamente lo que necesitaba, con los casos edge ya contemplados, con el tono correcto, con la restricción de performance que nadie le pidió explícitamente pero que estaba implícita en cómo describió el problema.
La diferencia no está en el modelo. Está en quien lo usa.
El conocimiento técnico no desapareció con el lenguaje natural. Se convirtió en la calidad del pensamiento detrás del prompt. Quien sabe más, pide mejor.
Lo que sí cambia —y es importante nombrarlo
En C#, class siempre es class. No hay sinónimos. No hay interpretación. Si escribes mal, el compilador te lo dice en voz alta, en rojo, con número de línea incluido.
En lenguaje natural, las palabras tienen contexto, ambigüedad, significados que cambian según lo que viene antes. El modelo no te interrumpe si le preguntas mal. Te da una respuesta. Una respuesta plausible, coherente, bien redactada —y a veces completamente equivocada respecto a lo que necesitabas.
El error se volvió silencioso.
Eso es un cambio real. El compilador era incómodo, pero honesto. El modelo es amable, y esa amabilidad te puede costar caro si no desarrollas el músculo de detectar cuándo el output parece correcto pero no lo es.
El protocolo de sincronización
Cambiar de idioma no basta. Hay que sintonizar.
Cuando llegas a un modelo nuevo —o cuando empiezas un proyecto nuevo con tu modelo habitual— hay una etapa que la mayoría salta: la calibración inicial. Y ese salto se paga después, en respuestas que no llegan a donde querías, en iteraciones innecesarias, en tiempo perdido corrigiendo lo que pudo no haberse descarrilado.
Antes de pedir que ejecute, plantea el contexto. No el requerimiento solo —el contexto: qué problema estás resolviendo, desde qué posición, qué resultado esperas y en qué formato.
Luego, antes de que arranque: pídele que te diga lo que entendió y cómo lo piensa abordar.
Eso es el protocolo. Y esa pausa vale más de lo que parece.
Si entendió bien, saberlo te da confianza y refuerza el patrón. Si se confundió en algo, lo corriges antes de que construya veinte líneas sobre una premisa incorrecta. Si propuso un enfoque que no habías considerado, lo evalúas —a veces la sugerencia del modelo es mejor que el camino que tenías en mente, y a veces no lo es, pero el criterio para distinguirlos lo tienes tú.
La retroalimentación no es opcional. Es el mecanismo de ajuste. Y aplica a todo. Lo que no retroalimentas, no mejora.
La memoria viva
Hay una capa más. Una que casi nadie construye, y que marca la diferencia entre usar un modelo y trabajar con uno.
Los prompts son la conversación. Útiles, poderosos, perecederos. Cada sesión empieza desde cero.
Pero existe algo más duradero: un archivo —puede ser un .md, puede ser otro formato— donde vas registrando lo que el modelo va aprendiendo de ti. Cómo estructuras los problemas. Qué analogías usas. Qué tipo de output te funciona mejor. En qué áreas tiendes a ser impreciso y cómo corriges eso. Cuándo prefieres que te dé opciones y cuándo prefieres que decida.
Ese archivo no es el historial de chat. Es una destilación. Y si vive en tu ambiente de desarrollo —accesible al IDE, al agente, a cualquier herramienta con la que trabajes— deja de ser un apunte personal y se convierte en contexto activo. El modelo no te lee la mente: lee lo que le das. Darle eso es lo que hace la diferencia entre un asistente genérico y uno calibrado a tu forma de pensar.
El workspace donde escribo esto ya funciona así. Hay archivos que documentan cómo pienso, qué proyectos manejo, qué tono busco, qué errores cometo. No los escribí en un día —fueron creciendo sesión tras sesión. Pero hoy, cuando abro una conversación nueva, no empiezo desde cero. El modelo ya sabe dónde estamos.
Eso no es magia. Es sistema.
La habilidad central de este momento es pensar con claridad y saber expresarlo. La máquina ya llegó hasta tu idioma. La pregunta es si tú estás afinando el tuyo.
La brecha se cerró. Lo que queda es calibración.
ArchMindset — software, equipos, y lo que aprendí cuando todo tronó.
← Ver todos los artículos