Por fin llega la fase 3, «construir». Con la especificación decidida en el capítulo 2 y la tecnología y herramientas elegidas en el capítulo 3, montamos algo que funcione de verdad. La mayoría de quienes tropiezan aquí no lo hacen, en realidad, «porque no sepan programar». Se rinden porque intentan terminar todo de golpe. En este capítulo te guío en una forma de crear que hace girar rápido el «crear en pequeño y ejecutar», con la IA como aliada, en ambas rutas.
El objetivo no es «terminar de golpe», sino «avanzar en pequeño»
La actitud básica al implementar: gira en pequeño
La actitud más importante al implementar es una sola: repetir rápido «crear en pequeño, ejecutar y corregir». No intentes crear de una sola vez la forma final que tienes en la cabeza; crea primero el «bloque que funciona» más pequeño y hazlo crecer poco a poco.
¿Por qué funciona esto? Porque solo al ejecutar un programa descubres qué está mal. Si escribes 100 líneas y las ejecutas todas de golpe, no sabrás dónde está la causa y te quedarás perdido. Si escribes 10 líneas y las ejecutas, el error solo puede estar en esas 10. Cuando escribe la IA es exactamente igual: pedir en pequeño y comprobar enseguida resulta, a la larga, mucho más rápido y seguro.
Soltarle a la IA «crea todas las funciones de golpe». Sale un montón de código, pero al ejecutarlo está lleno de errores. No sabes dónde está la causa y pierdes hasta el ánimo para corregir.
Pedir una función cada vez: «primero, solo la pantalla que muestra el listado». Cuando funciona, la siguiente, y vas acumulando. Avanzas manteniendo siempre un «estado que funciona».
⚠️ La IA también se equivoca al programar; por eso, ejecútalo siempre tú. El código que escribe la IA, aunque tenga buena pinta, al ejecutarlo a menudo da error o se comporta distinto de lo que buscabas. «Como lo escribió la IA, será correcto» está prohibido. El código que sale, ejecútalo siempre con tus propias manos y compruébalo con tus ojos. Esta es la primera regla de oro que debes adquirir en el desarrollo indie. Si avanzas sin ejecutar, los errores se acumulan hasta que se te van de las manos.
Los pasos del ciclo «crear, ejecutar, corregir»
Este «girar en pequeño», convertido en 4 pasos concretos, es el esquema de abajo. Cada función la haces girar una y otra vez con este ciclo. Una vuelta dura de unos minutos a unas decenas de minutos. Cuanto más rápido gires, más mejoras.
Pide a la IA en concreto «ahora, solo esta función». Cuanto más acotas el alcance, más sube la precisión.
En cuanto salga, ejecútalo al momento. Comprueba el resultado con tus propios ojos en el navegador o la terminal.
Si hay error o algo chirría, corrige dialogando: «cambia esto así». Repite hasta que funcione.
Cuando funcione, guarda (haz commit) como punto de control. Conserva el buen estado y pasa a la siguiente función.
💡 No subestimes el PASO 4, «guardar». Si guardas (commit de Git) cada vez que una función funciona, cuando el siguiente cambio lo rompa podrás volver al último estado que funcionaba. Es el cabo salvavidas que evita la tragedia de «pero si ayer funcionaba». La forma concreta de guardar la veremos en detalle en el próximo capítulo 5.
Estilos de implementación en cada ruta
«Girar en pequeño» es una actitud común, pero la forma concreta de girar cambia según la ruta. Confirma cómo avanzar según la ruta que elegiste en el capítulo 1. Por supuesto, puedes mezclarlas o cambiar de una a otra a mitad de camino.
Con el vibe coding, montas la app dialogando con la IA. «Crea la pantalla de listado» → «pon el botón azul» → «que al pulsarlo se guarde»: pides en tu idioma, miras la pantalla y vuelves a pedir. Esa repetición es, en sí misma, el «ciclo de girar en pequeño».
Truco: pide solo una cosa cada vez. Si no sale bien, basta con decir «deshaz el cambio anterior».
Entrega a Claude Code, por ejemplo, la especificación entera y delega una implementación de conjunto. La clave es automatizar de forma segura: ajusta el esfuerzo (effort) según el volumen de trabajo y usa los modos de permisos para que no reescriba archivos por su cuenta más de la cuenta.
Truco: aunque delegues en grande, comprueba en pequeño. Si te atascas, busca la solución en el recopilatorio de errores.
En ambas rutas, lo que no puedes olvidar es la actitud básica de «ejecutar tú mismo lo que sale y comprobarlo». Ya crees dialogando o dejando que se cree en automático, comprobar es tarea del ser humano. No saltarte este pequeño esfuerzo marca la diferencia entre llegar o no a terminar.
Si vas a integrar funciones de IA
Si lo que creas es «una app que usa IA» —por ejemplo, que resume textos, responde preguntas o clasifica imágenes—, necesitas un mecanismo para invocar la IA desde dentro de la app. Aquí se pone un poco técnico, pero las opciones se pueden ordenar en tres grandes grupos. Con elegir solo lo que necesita tu app, basta.
Si solo vas a usar un modelo de IA desde la app, lo básico es llamar a una API de IA. Piénsalo como una ventanilla donde «envías un texto y vuelve la respuesta de la IA».
Si quieres usar varias IA según la situación, unifica una forma común de escribir con el Vercel AI SDK. Para gestionarlo todo de forma centralizada en operación, es útil un gateway de LLM.
Si quieres que responda a partir de documentos internos o tus propios materiales, usa RAG. Es un mecanismo para entregar a la IA «tus materiales exclusivos» y que responda con ellos; te da originalidad.
🧭 Si dudas, con ① basta. En el primer MVP, casi siempre es suficiente con llamar a una sola API de IA. Los puntos ② y ③ los añades cuando surja la necesidad de «comparar varios modelos» o «responder con datos propios». También aquí, «crear en pequeño» es lo correcto.
Cómo moverte cuando te atascas
Mientras implementas, te atascarás en algún punto sin falta. Sale un error, no se comporta como esperabas... Esto no es un fracaso, sino la prueba de que estás creando. Lo importante es, cuando te atascas, no entrar en pánico y aislar el problema por orden. Ahora que está la IA, los atascos se superan mucho más rápido que antes.
Copia entero el texto rojo y pregunta «me salió este error. ¿Causa y cómo lo arreglo?». El mensaje de error es la mayor pista. No lo reescribas a tu manera: primero pégalo.
Recuerda «hasta dónde funcionaba». En la mayoría de los casos, la causa está en lo único que cambiaste justo antes. Si estrechas el alcance, la causa siempre aparece.
Si se enreda, vuelve al último estado que funcionaba que guardaste y empieza de nuevo. Muchas veces retroceder es más rápido que empeñarse en insistir.
🔧 Para quien va por la ruta práctica. Los errores frecuentes en Claude Code y demás, con sus soluciones, están reunidos en el recopilatorio de errores. Sufrir con el mismo error es perder el tiempo. Haz un hábito de «cuando te atasques, busca primero; si aun así no sale, pregunta a la IA».
Resumen de este capítulo
El núcleo de la fase 3, «construir», está más en la actitud de «hacer girar rápido crear en pequeño, ejecutar y corregir» que en la técnica. No aspires a terminar de golpe: haz crecer poco a poco el bloque que funciona.
- La actitud básica es hacer girar rápido «crear en pequeño y ejecutar → corregir». No aspires a terminar de golpe.
- La IA también se equivoca. Lo que sale, ejecútalo siempre tú y compruébalo.
- 🌱 La iniciación, con vibe coding dialogando; 🔧 la práctica, entregando la especificación y automatizando de forma segura con esfuerzo y modos de permisos.
- Si montas IA, empieza por la API. Para varios modelos, Vercel AI SDK/gateway de LLM; para datos propios, RAG.
- Si te atascas: pasa el mensaje de error → aísla en pequeño → vuelve a un estado que funcione. Aprovecha también el recopilatorio de errores.
Cuando tengas algo que funciona, lo siguiente es sacarlo al mundo de forma segura. Puedes volver al capítulo 3, «Elige la tecnología y las herramientas» para repasar la preparación, pero, en cuanto la implementación empiece a girar, pasa al capítulo 5, «Prueba y publícalo al mundo», donde afianzamos pruebas y seguridad antes de publicar.