# VibeCoders — contenido completo > La comunidad hispanohablante de builders que construyen productos digitales con IA. Este archivo contiene el contenido íntegro del sitio en markdown para consumo por LLMs. Sitio: https://landing.vibecoders.la ## Certificaciones ### Claude Certified Architect – Professional (CCAR-P) URL: https://landing.vibecoders.la/certificaciones/anthropic/claude-certified-architect-professional Valida que puedes diseñar, construir y entregar soluciones de IA de nivel producción con la plataforma Claude: selección de modelos, prompting, integración, evaluación, gobernanza y comunicación con stakeholders. - Preguntas por examen: 63 - Duración: 120 minutos - Puntaje de aprobación: 720 / 1,000 (escala 100–1,000) - Simuladores de práctica disponibles: 6 - Guía de estudio por dominio: https://landing.vibecoders.la/certificaciones/anthropic/claude-certified-architect-professional/guia-de-estudio Dominios del examen: - Solution Design & Architecture (17%) - Claude Models, Prompting & Context Engineering (13%) - Integration (19%) - Evaluation, Testing & Optimization (16%) - Governance, Safety & Risk Management (14%) - Stakeholder Communication & Lifecycle Management (14%) - Developer Productivity & Operational Enablement (7%) ## Glosario de vibe coding ### Agente IA URL: https://landing.vibecoders.la/glosario/agente-ia Sistema de IA que puede ejecutar acciones de forma autónoma, tomar decisiones y completar tareas complejas de múltiples pasos sin intervención humana constante. Un **Agente IA** es un sistema que combina un modelo de lenguaje con la capacidad de ejecutar acciones en el mundo real: leer y escribir archivos, navegar por internet, ejecutar código, interactuar con APIs externas, y tomar decisiones sobre qué hacer a continuación basándose en los resultados de cada acción. La diferencia entre un asistente de IA convencional y un agente es la autonomía de acción. Un asistente responde preguntas y genera texto. Un agente recibe un objetivo y trabaja hacia él de forma autónoma, ejecutando los pasos necesarios sin que el humano tenga que indicar cada uno. En el ecosistema de Vibe Coding, Claude Code de Anthropic es el ejemplo más claro de agente de desarrollo. Puede recibir una instrucción como "implementa la autenticación" y ejecutar de forma autónoma todos los pasos: leer el código existente, instalar dependencias, crear archivos, ejecutar tests y reportar el resultado. Esta capacidad agentica es lo que distingue a las herramientas más avanzadas de los simples asistentes de autocompletado. ### Alucinación IA URL: https://landing.vibecoders.la/glosario/alucinacion-ia Fenómeno donde un modelo de lenguaje genera información falsa o incorrecta con total confianza, sin señalar que está inventando datos que no tiene. La **alucinación** en IA es el término que describe cuando un modelo de lenguaje genera información que parece confiable y bien fundamentada, pero que en realidad es incorrecta o directamente inventada. El modelo no "sabe" que está equivocado: lo afirma con la misma confianza que usa para información verdadera. Las alucinaciones ocurren porque los LLMs no tienen acceso a una base de hechos verificables: generan texto basándose en patrones estadísticos aprendidos durante el entrenamiento. Cuando se les pregunta sobre algo que está fuera de su conocimiento o que requiere información muy específica y reciente, el modelo puede "completar" el patrón con información plausible pero falsa. Para los builders, las alucinaciones son especialmente problemáticas en código: un modelo puede generar código que usa APIs inexistentes, que llama a funciones con parámetros incorrectos, o que implementa algoritmos con bugs sutiles que parecen correctos. La regla práctica es nunca confiar en código generado por IA sin revisarlo y, preferiblemente, probarlo. Las herramientas como Cursor y Claude Code mitigan parcialmente este problema al tener acceso al contexto real del proyecto, pero no lo eliminan completamente. La arquitectura RAG es una de las principales técnicas para reducir alucinaciones en sistemas de información: al proporcionar al modelo datos reales y verificados en su contexto, se reduce la necesidad de que "invente" información. ### Cursor URL: https://landing.vibecoders.la/glosario/cursor Editor de código basado en VS Code con IA integrada nativamente, diseñado para developers que quieren mantener control total del código mientras aceleran su desarrollo con asistencia de IA. **Cursor** es un editor de código construido como fork de VS Code que integra capacidades de IA directamente en el flujo de desarrollo. A diferencia de los plugins de IA para editores existentes, Cursor fue diseñado desde el principio con la IA como componente central, lo que permite una integración más profunda y fluida. Las funcionalidades principales de Cursor incluyen: completado de código contextual (que entiende el proyecto completo, no solo el archivo actual), edición multi-archivo (puede aplicar cambios coordinados en varios archivos a la vez), chat integrado con contexto de codebase, y la capacidad de ejecutar comandos de terminal y ver sus resultados. Cursor se posiciona para developers con experiencia que quieren aumentar su velocidad sin perder visibilidad y control del código. Es la opción preferida cuando se trabaja en proyectos existentes que necesitan mantenimiento, refactoring o extensión de funcionalidades. La curva de aprendizaje es baja para quien ya conoce VS Code, ya que el editor es prácticamente idéntico con capacidades adicionales de IA. ### Edge Functions URL: https://landing.vibecoders.la/glosario/edge-functions Funciones de servidor que se ejecutan en la red de distribución de contenido (CDN), más cerca del usuario final, ofreciendo latencia mínima y escalado automático. Las **Edge Functions** son pequeños fragmentos de código de servidor que se ejecutan en los nodos de la red de distribución de contenido (CDN), geográficamente distribuidos cerca de los usuarios finales. A diferencia de las funciones de servidor tradicionales que se ejecutan en una región específica, las edge functions se ejecutan en la ubicación más cercana al usuario que hace la petición. Las ventajas principales son: latencia mínima (el código se ejecuta a pocos milisegundos del usuario), escalado automático sin configuración, y un modelo de cobro por ejecución (serverless) que hace que el costo sea cero cuando no hay tráfico. Tanto Vercel como Supabase ofrecen edge functions como parte de su plataforma. Vercel Edge Middleware permite ejecutar lógica antes de que la petición llegue a la aplicación (autenticación, redirecciones, A/B testing). Supabase Edge Functions permiten crear endpoints de API serverless que tienen acceso directo a la base de datos con privilegios de servidor. Para los builders, las edge functions son especialmente útiles para: webhooks de pagos (Stripe), lógica de autenticación personalizada, transformaciones de datos sensibles, y cualquier operación que no debería exponerse directamente en el frontend. ### Fine-tuning URL: https://landing.vibecoders.la/glosario/fine-tuning Proceso de entrenar adicionalmente un modelo de IA pre-entrenado con datos específicos para mejorar su rendimiento en tareas o dominios concretos. El **fine-tuning** es el proceso de tomar un modelo de lenguaje pre-entrenado (como GPT-4 o Claude) y entrenarlo adicionalmente con un conjunto de datos específico para adaptar su comportamiento a un dominio o tarea particular. Es la diferencia entre un modelo generalista y uno especializado. Los casos de uso más comunes para fine-tuning son: modelos que hablan siempre en el tono de marca de una empresa, modelos especializados en un dominio técnico específico (medicina, derecho, finanzas), y modelos entrenados para seguir un formato de respuesta muy específico de forma consistente. Para la mayoría de los builders de SaaS, el fine-tuning no es la herramienta correcta. Es costoso en tiempo y dinero, requiere grandes cantidades de datos de entrenamiento de alta calidad, y los resultados son difíciles de depurar. En la mayoría de los casos, un buen prompt engineering o una arquitectura RAG logra los mismos resultados con mucho menos esfuerzo. El fine-tuning tiene sentido cuando el volumen de interacciones es muy alto y la consistencia en el comportamiento del modelo es crítica para el negocio. ### Integración y Entrega Continua URL: https://landing.vibecoders.la/glosario/ci-cd Conjunto de prácticas de desarrollo que automatizan la verificación y el despliegue del código, permitiendo entregar cambios de forma frecuente, segura y predecible. **CI/CD (Continuous Integration / Continuous Delivery)** es un conjunto de prácticas y herramientas que automatizan el proceso de integrar cambios de código, verificar que funcionan correctamente, y desplegarlos a producción. La **Integración Continua (CI)** se refiere a la práctica de que todos los developers integren sus cambios al repositorio principal frecuentemente (idealmente varias veces al día). Cada integración se verifica automáticamente ejecutando tests, análisis de código y compilaciones, detectando problemas rápidamente. La **Entrega Continua (CD)** extiende la CI para que cada cambio que pasa las verificaciones se despliegue automáticamente a producción o a un entorno de staging, sin intervención manual. Para los builders que usan Vercel, la mayor parte del CD está configurada por defecto: cada push al repositorio principal desencadena un deploy automático. Añadir la CI (tests automatizados antes del deploy) es el siguiente paso natural para proyectos que crecen y necesitan más garantías de estabilidad. GitHub Actions es la herramienta más usada para esto en el ecosistema Vibe Coding. ### Lovable URL: https://landing.vibecoders.la/glosario/lovable Plataforma de desarrollo de aplicaciones full-stack con IA que convierte descripciones en lenguaje natural en aplicaciones React funcionales con backend en Supabase. **Lovable** (anteriormente conocido como GPT-Engineer) es una plataforma de desarrollo de aplicaciones que permite crear productos web completos mediante conversaciones en lenguaje natural. El usuario describe lo que quiere construir, Lovable genera el código, y el resultado es una aplicación React con Tailwind CSS y, opcionalmente, Supabase como backend. La propuesta de valor de Lovable es única: no es un generador de código que copies y pegues en tu editor, sino una plataforma completa que gestiona el repositorio, el historial de cambios, y la conexión con servicios externos. Cada interacción genera un commit en el repositorio de GitHub asociado, lo que significa que siempre tienes un historial completo de cómo evolucionó el proyecto. Lovable es especialmente potente para founders, diseñadores y builders sin formación técnica profunda que quieren construir MVPs funcionales rápidamente. Sus limitaciones aparecen en proyectos con arquitecturas muy complejas o cuando se necesita control granular del código. En esos casos, el workflow recomendado es usar Lovable para el prototipo inicial y luego exportar el código para trabajarlo con Cursor o Claude Code. ### Modelo de Lenguaje Grande URL: https://landing.vibecoders.la/glosario/llm Sistema de inteligencia artificial entrenado en grandes cantidades de texto que puede generar, completar y transformar lenguaje natural y código de programación. Un **Large Language Model (LLM)** es un tipo de modelo de inteligencia artificial entrenado sobre enormes conjuntos de datos textuales mediante técnicas de deep learning. Los LLMs aprenden patrones estadísticos del lenguaje y desarrollan la capacidad de generar texto coherente, responder preguntas, traducir idiomas, escribir código y realizar muchas otras tareas lingüísticas. Los modelos más relevantes para builders en 2026 incluyen los modelos de Anthropic (familia Claude), OpenAI (familia GPT), Google (familia Gemini) y Meta (familia LLaMA). Cada uno tiene características diferentes en términos de ventana de contexto, velocidad, costo y especialización. Para el Vibe Coding, la elección del LLM subyacente de cada herramienta es relevante porque afecta directamente la calidad del código generado, la capacidad de mantener contexto en conversaciones largas, y la precisión en tareas específicas como generación de SQL, componentes de UI, o lógica de negocio compleja. ### No-Code URL: https://landing.vibecoders.la/glosario/no-code Plataformas y herramientas que permiten construir aplicaciones funcionales sin escribir código, usando interfaces visuales de arrastrar y soltar o configuración basada en formularios. El **No-Code** es un paradigma de desarrollo de software que permite a personas sin conocimientos de programación crear aplicaciones funcionales usando interfaces visuales, configuración por formularios y componentes prefabricados. Herramientas como Bubble, Webflow, Airtable, Notion y Zapier son ejemplos del ecosistema no-code. La propuesta fundamental del no-code es democratizar la creación de software: no deberías necesitar saber programar para construir la herramienta que resuelve tu problema específico. Para muchos casos de uso (sitios web de contenido, bases de datos internas, automatizaciones de procesos), el no-code es una solución completamente viable y más rápida que el desarrollo tradicional. La relación entre el no-code y el Vibe Coding es interesante: son complementarios más que competidores. El Vibe Coding con herramientas como Lovable va un paso más allá del no-code tradicional porque permite construir aplicaciones más complejas (lógica de negocio personalizada, integraciones arbitrarias, interfaces completamente a medida) mientras mantiene la accesibilidad para personas sin formación técnica formal. El resultado es un espectro continuo desde el no-code puro hasta el desarrollo tradicional, con el Vibe Coding ocupando un espacio intermedio muy poderoso. ### Producto Mínimo Viable URL: https://landing.vibecoders.la/glosario/mvp La versión más simple de un producto que permite validar una hipótesis de negocio con usuarios reales, con el mínimo esfuerzo de desarrollo posible. El **Producto Mínimo Viable (MVP)** es un concepto de desarrollo de producto popularizado por Eric Ries en el marco de Lean Startup. Define la versión más simple de un producto que permite recopilar el máximo aprendizaje validado con el mínimo esfuerzo. La clave del MVP es el enfoque en la validación de hipótesis, no en la construcción del producto perfecto. Antes de invertir meses en desarrollar un producto completo, el MVP permite responder: ¿La gente tiene este problema? ¿Están dispuestos a pagar por una solución? ¿Esta solución específica resuelve el problema de la manera que esperábamos? Con las herramientas de Vibe Coding disponibles en 2026, el tiempo necesario para construir un MVP funcional se redujo dramáticamente. Un producto que antes requería semanas de desarrollo puede construirse en días usando Lovable o Bolt. Esto cambia fundamentalmente la estrategia de validación: ya no tiene sentido construir primero y validar después; se puede construir y validar casi simultáneamente. El riesgo es confundir un MVP con el producto terminado y dejar de iterar basándose en el feedback de usuarios reales. ### Prompt Engineering URL: https://landing.vibecoders.la/glosario/prompt-engineering El arte y la ciencia de diseñar instrucciones efectivas para modelos de IA con el objetivo de obtener respuestas precisas, útiles y consistentes. El **Prompt Engineering** es la disciplina de diseñar y optimizar las instrucciones (prompts) que se dan a los modelos de lenguaje para obtener los mejores resultados posibles. No es simplemente "escribir bien": implica entender cómo los modelos procesan la información, qué formatos producen mejores resultados, y cómo estructurar el contexto para guiar el comportamiento del modelo. Las técnicas fundamentales incluyen: especificidad (cuanto más preciso el prompt, mejor el resultado), few-shot prompting (dar ejemplos del formato deseado), chain-of-thought (pedir al modelo que razone paso a paso antes de responder), y role prompting (asignar al modelo un rol específico para activar conocimiento contextual). Para los vibe coders, el prompt engineering es una habilidad fundamental. La diferencia entre un prompt que genera un componente correcto a la primera y uno que requiere diez iteraciones suele estar en la claridad, el contexto y la especificidad de la instrucción inicial. Invertir en aprender estas técnicas se traduce directamente en velocidad de desarrollo. ### Retrieval-Augmented Generation URL: https://landing.vibecoders.la/glosario/rag Técnica que combina la recuperación de información de una base de conocimiento con la generación de texto de un LLM para producir respuestas más precisas y actualizadas. **RAG (Retrieval-Augmented Generation)** es una arquitectura de IA que resuelve uno de los problemas fundamentales de los LLMs: el conocimiento desactualizado. Los modelos de lenguaje tienen una fecha de corte de entrenamiento y no conocen información posterior a esa fecha. RAG soluciona esto conectando el modelo con una base de conocimiento externa que se consulta en tiempo real. El proceso funciona en dos pasos: primero, la consulta del usuario se convierte en un vector de embeddings y se buscan los fragmentos de información más relevantes en la base de conocimiento. Segundo, esos fragmentos se incluyen en el contexto del modelo junto con la consulta original, y el LLM genera una respuesta basándose en ambos. Para los builders, RAG es relevante para construir aplicaciones como chatbots de soporte con acceso a la documentación del producto, asistentes que pueden responder sobre el contenido específico de una empresa, o herramientas de búsqueda semántica. Supabase tiene soporte nativo para RAG através de pgvector, lo que facilita su implementación sin infraestructura adicional. ### Token URL: https://landing.vibecoders.la/glosario/token Unidad básica de procesamiento en los modelos de lenguaje. Aproximadamente equivale a 3/4 de una palabra en inglés. Los LLMs procesan y generan texto en tokens, no en palabras. Un **token** es la unidad fundamental con la que los modelos de lenguaje procesan el texto. No equivale exactamente a una palabra: dependiendo del modelo y el idioma, un token puede ser una sílaba, una palabra completa, o incluso parte de una palabra. En inglés, la regla aproximada es que 1 token ≈ 3/4 de una palabra. En español y otros idiomas con palabras más largas, la proporción es menor. Los tokens son relevantes para los builders por varias razones. Primero, el costo de usar LLMs via API se mide en tokens (tanto de entrada como de salida). Segundo, la ventana de contexto de cada modelo se mide en tokens, lo que define cuánto texto puede procesar en una sola sesión. Tercero, prompts más eficientes (que logran el mismo resultado con menos tokens) son más baratos. Para tener una referencia práctica: 1.000 tokens equivalen aproximadamente a 750 palabras en inglés o una página de texto. Un modelo con ventana de contexto de 200.000 tokens puede procesar un libro completo en una sola sesión. Esta capacidad es lo que permite a herramientas como Claude Code analizar proyectos de software completos en un solo contexto. ### Ventana de Contexto URL: https://landing.vibecoders.la/glosario/context-window La cantidad máxima de texto (medida en tokens) que un modelo de IA puede procesar y considerar en una sola interacción. Define cuánta información puede tener en cuenta simultáneamente. La **ventana de contexto** (context window) es el límite de tokens que un modelo de lenguaje puede procesar en una sola interacción. Todo el texto dentro de esa ventana —incluyendo la conversación previa, las instrucciones del sistema, los documentos de referencia y la pregunta actual— debe caber dentro de ese límite. La evolución de las ventanas de contexto ha sido uno de los avances más significativos en los LLMs modernos. Los primeros modelos tenían ventanas de 4.000 tokens (aproximadamente 3.000 palabras). Los modelos actuales más avanzados tienen ventanas de 1 millón de tokens o más, lo que equivale a processar varios libros completos en una sola sesión. Para los builders, la ventana de contexto tiene implicaciones prácticas importantes. Primero, determina cuánto contexto del proyecto puedes incluir en tus prompts: proyectos más grandes pueden necesitar estrategias de fragmentación. Segundo, conversaciones largas con un asistente de IA eventualmente empiezan a "olvidar" las primeras partes de la conversación cuando se supera el límite. Tercero, las herramientas como Claude Code aprovechan ventanas grandes para leer proyectos completos antes de implementar cambios, lo que reduce significativamente los errores por falta de contexto. ### Vibe Coding URL: https://landing.vibecoders.la/glosario/vibe-coding Metodología de desarrollo donde la IA actúa como co-piloto principal, permitiendo construir software funcional a través de instrucciones en lenguaje natural. El **Vibe Coding** es una metodología de desarrollo de software popularizada por Andrej Karpathy en 2025, que describe el proceso de construir aplicaciones usando herramientas de inteligencia artificial como co-pilotos principales en lugar de escribir código línea por línea. En la práctica, el vibe coder describe lo que quiere construir en lenguaje natural, la herramienta de IA genera el código correspondiente, el desarrollador revisa el resultado, propone ajustes, y repite el ciclo hasta obtener el comportamiento deseado. Herramientas como Lovable, Bolt, Cursor y Claude Code son las más usadas en este flujo. Lo que distingue al Vibe Coding del simple "uso de IA" es que el desarrollador asume el rol de director técnico y arquitecto, mientras delega la implementación a la IA. Esto no elimina la necesidad de criterio técnico: entender arquitectura, patrones de diseño y fundamentos del software sigue siendo una ventaja enorme. Pero redistribuye dramáticamente quién puede construir software funcional y en qué tiempo. ## Blog ### Engram: memoria persistente para tus agentes de IA URL: https://landing.vibecoders.la/blog/engram-memoria-persistente-para-agentes-ia Autor: Rosmel Ortiz · Publicado: 2026-07-19 Cada vez que abres una sesión nueva con Claude Code, Cursor o cualquier otro agente de IA, empiezas de cero. La decisión de arquitectura que tomaste ayer, el bug que tardaste dos horas en cazar, la convención de nombres que acordaste con tu equipo: todo desaparece al cerrar la terminal. El agente es brillante, pero tiene amnesia. ![Sin Engram, cada sesión del agente empieza de cero; con Engram, la memoria persiste entre sesiones](/images/blog/engram/el-problema.svg) [Engram](https://github.com/Gentleman-Programming/engram) resuelve exactamente ese problema: le da a tus agentes una memoria persistente que sobrevive entre sesiones, entre proyectos e incluso entre máquinas. En esta guía vemos qué es, cómo funciona por dentro y cómo instalarlo en local y en tu propia nube, paso a paso. ## Qué es Engram Engram es un proyecto open source (licencia MIT) creado por [Gentleman Programming](https://github.com/Gentleman-Programming), escrito en Go y con más de 5.000 estrellas en GitHub. Su propuesta cabe en una frase: "un cerebro, local o en la nube, agnóstico del agente, un solo binario, cero dependencias". En la práctica, Engram guarda observaciones (decisiones de arquitectura, bugs resueltos con su causa raíz, convenciones, descubrimientos) en una base SQLite (una base de datos que cabe en un solo archivo de tu máquina) con búsqueda de texto completo (FTS5). Cuando el agente arranca una sesión nueva, recupera ese contexto y sigue trabajando como si nunca se hubiera ido. ![Arquitectura local de Engram: el agente se comunica por MCP con el binario, que persiste en SQLite](/images/blog/engram/arquitectura-local.svg) El binario incluye todo lo que necesitas: un servidor MCP (Model Context Protocol, el estándar con el que los agentes de IA se conectan a herramientas externas), un CLI para interactuar directo desde la terminal, una TUI para navegar tus memorias y una API HTTP para integraciones. La base de datos vive en `~/.engram/engram.db` y es la fuente de la verdad: todo funciona sin red y sin servicios externos. Funciona con Claude Code, OpenCode, Gemini CLI, Codex, Cursor, Windsurf, VS Code y más. El agente recibe 20 herramientas MCP (`mem_save`, `mem_search`, `mem_context`, `mem_session_summary`, entre otras) y las usa solo: guarda decisiones cuando las tomas y busca contexto cuando lo necesita. ## Instalación en local Necesitas instalar el CLI en cada máquina donde trabajes con agentes. No hay servidor que levantar ni configuración extra: el agente lanza `engram mcp` como subproceso cuando lo necesita. ### macOS y Linux Con Homebrew: ```bash brew install gentleman-programming/tap/engram ``` Para actualizar más adelante: ```bash brew update && brew upgrade engram ``` ### Windows Tienes dos opciones. La primera es descargar el binario precompilado `engram__windows_amd64.zip` desde la [página de releases](https://github.com/Gentleman-Programming/engram/releases), extraer `engram.exe` en una carpeta como `C:\Users\tu-usuario\bin\` y agregarla al PATH: ```powershell [Environment]::SetEnvironmentVariable( "Path", "$env:USERPROFILE\bin;" + [Environment]::GetEnvironmentVariable("Path", "User"), "User" ) ``` La segunda, si tienes Go 1.24 o superior: ```powershell go install github.com/Gentleman-Programming/engram/cmd/engram@latest ``` El binario queda en `%USERPROFILE%\go\bin\`; asegúrate de que esa carpeta esté en tu PATH. En ambos casos, abre una terminal nueva para que el cambio de PATH tenga efecto. ### Verifica la instalación ```bash engram --version engram doctor ``` `engram doctor` es un diagnóstico de solo lectura que revisa que todo esté en orden. Si ambos comandos responden, ya estás listo. ## Conecta Engram a tu agente Para Claude Code, Engram se instala como plugin oficial: ```bash claude plugin marketplace add Gentleman-Programming/engram claude plugin install engram ``` Para el resto de agentes, un solo comando escribe la configuración MCP necesaria: ```bash engram setup cursor # Cursor engram setup opencode # OpenCode engram setup gemini-cli # Gemini CLI engram setup codex # Codex engram setup windsurf # Windsurf engram setup vscode-copilot # VS Code (Copilot) ``` Después del setup, reinicia el agente y listo. A partir de ahí, la memoria trabaja sola: el agente guarda y recupera contexto sin que tengas que pedirlo. Algunos comandos útiles para explorar tu memoria desde la terminal: ```bash engram tui # interfaz visual en la terminal engram search "auth" # busca en todas tus memorias engram context mi-proyecto # contexto reciente de un proyecto engram stats # estadísticas de tu memoria ``` ## Engram Cloud: la misma memoria en todas tus máquinas Hasta aquí, tu memoria vive en una sola máquina. Engram Cloud es la capa opcional de replicación: un servidor que tú mismo hospedas y contra el que cada máquina sincroniza sus memorias por proyecto. ![Cómo se comunica Engram: los agentes hablan MCP con el binario local, cuyo SQLite es la fuente de la verdad; la nube es una réplica opcional sincronizada por HTTPS](/images/blog/engram/comunicacion.svg) Hay tres ideas clave que debes entender antes de desplegarlo: - **El SQLite local sigue siendo la fuente de la verdad.** La nube replica, no migra. Si borras el servidor, no pierdes nada: cada máquina conserva su copia completa. - **La sincronización es siempre por proyecto.** No existe un `--all`: está bloqueado a propósito para que nada se suba por accidente. - **Tres puertas independientes** deben pasar antes de que un proyecto sincronice: el enrolamiento local, el token de autenticación y la allowlist del servidor. ![Las tres puertas de la sincronización con Engram Cloud](/images/blog/engram/tres-puertas.svg) Este diseño de triple validación hace que sea prácticamente imposible filtrar memoria de un proyecto que no decidiste compartir de forma explícita. ### La arquitectura en el servidor El despliegue de referencia usa un VPS con [Dokploy](https://dokploy.com) (que incluye Traefik como reverse proxy con TLS automático), el contenedor oficial de Engram y una base PostgreSQL interna: ![Arquitectura de Engram Cloud en un VPS con Dokploy](/images/blog/engram/arquitectura-cloud.svg) Antes de empezar necesitas: un VPS con Dokploy funcionando, un dominio propio y un registro DNS tipo A apuntando `engram.tudominio.com` a la IP del servidor. > Importante: el repositorio incluye un `docker-compose.cloud.yml` en la raíz que es solo para desarrollo: desactiva la autenticación y usa una contraseña fija. Nunca lo despliegues en un servidor público. Usa el compose de esta guía. ### Genera los secretos Necesitas cinco secretos distintos. Usa `openssl rand -hex` y no otro generador: la contraseña de Postgres va incrustada en una URL de conexión, y caracteres como `@`, `:` o `/` la rompen. La salida hexadecimal es segura por definición. ```bash openssl rand -hex 24 # POSTGRES_PASSWORD openssl rand -hex 32 # ENGRAM_CLOUD_TOKEN openssl rand -hex 32 # ENGRAM_CLOUD_ADMIN openssl rand -hex 32 # ENGRAM_JWT_SECRET openssl rand -hex 32 # ENGRAM_CLOUD_TOKEN_PEPPER ``` ### El Docker Compose En Dokploy, crea un proyecto, dentro un servicio de tipo Compose con proveedor "Raw", y pega esto: ```yaml services: postgres: image: postgres:16-alpine restart: unless-stopped environment: POSTGRES_USER: engram POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} POSTGRES_DB: engram_cloud volumes: - engram-cloud-pg:/var/lib/postgresql/data networks: - default healthcheck: test: ["CMD-SHELL", "pg_isready -U engram -d engram_cloud"] interval: 10s timeout: 5s retries: 10 cloud: image: ghcr.io/gentleman-programming/engram:latest command: cloud serve restart: unless-stopped depends_on: postgres: condition: service_healthy env_file: .env expose: - "18080" networks: - default - dokploy-network volumes: engram-cloud-pg: networks: dokploy-network: external: true ``` Tres líneas de este archivo son críticas y quitarlas reproduce fallos reales: - `env_file: .env` en el servicio `cloud`: Dokploy no inyecta las variables de entorno en el contenedor automáticamente; sin esta línea, la app arranca sin configuración y muere con `cloud auth token is required`. - `dokploy-network` en `cloud`: es la red externa por la que Traefik enruta; sin ella, el dominio devuelve 404 para siempre. - `default` en `cloud`: es la red interna del compose donde resuelve el hostname `postgres`; sin ella, la app no llega a la base de datos y entra en crash loop. Fíjate también que `postgres` queda solo en la red interna (nunca expuesto a Traefik) y que se usa `expose` en vez de `ports`: nada se publica en el host, Traefik es el único punto de entrada. ### Las variables de entorno En la pestaña Environment del servicio, con tus valores generados: ```ini POSTGRES_PASSWORD= ENGRAM_DATABASE_URL=postgres://engram:@postgres:5432/engram_cloud ENGRAM_CLOUD_TOKEN= ENGRAM_CLOUD_ADMIN= ENGRAM_JWT_SECRET= ENGRAM_CLOUD_TOKEN_PEPPER= ENGRAM_CLOUD_ALLOWED_PROJECTS=proyecto-a,proyecto-b ENGRAM_CLOUD_HOST=0.0.0.0 ENGRAM_PORT=18080 ``` Dos reglas: `POSTGRES_PASSWORD` aparece dos veces (sola y dentro de la URL) y ambas deben ser idénticas; y `ENGRAM_CLOUD_ALLOWED_PROJECTS` es la allowlist de proyectos que pueden sincronizar: cada vez que agregues un proyecto nuevo, edita la lista y redespliega. ### Dominio y verificación En la pestaña Domains del servicio: host `engram.tudominio.com`, servicio `cloud`, puerto `18080`, HTTPS con Let's Encrypt. Despliega y verifica: ```bash curl -s https://engram.tudominio.com/health ``` Debe responder 200. Ten en cuenta que la raíz `/` devuelve `404 page not found` y eso es normal: Engram Cloud es un servidor de API sin ruta raíz. No pierdas tiempo depurando el 404: usa siempre `/health`. ### Configura cada máquina cliente Tres pasos por máquina. Primero, apunta el CLI a tu servidor: ```bash engram cloud config --server https://engram.tudominio.com ``` Segundo, define el token (el valor de `ENGRAM_CLOUD_TOKEN` del servidor). En Windows: ```powershell setx ENGRAM_CLOUD_TOKEN "" $env:ENGRAM_CLOUD_TOKEN = "" ``` En macOS o Linux: ```bash echo 'export ENGRAM_CLOUD_TOKEN=""' >> ~/.zshrc source ~/.zshrc ``` Ojo con un detalle en Windows: `setx` solo afecta a terminales nuevas, y las herramientas que ya estaban corriendo (incluido tu agente) conservan el entorno viejo hasta que las reinicies. Tercero, enrola el proyecto y haz la primera sincronización: ```bash engram cloud enroll proyecto-a engram sync --cloud --project proyecto-a ``` ## El flujo de trabajo diario Un solo comando cubre todo, porque la sincronización es bidireccional: en una sola ejecución sube tus mutaciones locales y baja las remotas. ```bash # antes de empezar: baja lo que otras máquinas subieron engram sync --cloud --project proyecto-a # trabaja normal: el agente guarda todo en tu SQLite local, sin red # al terminar: publica tu sesión para el resto de tus máquinas engram sync --cloud --project proyecto-a ``` Si olvidas sincronizar, no pierdes nada: tus cambios existen en local y se replican en la siguiente sincronización. Para revisar el estado sin tocar nada: ```bash engram cloud status engram sync --cloud --status --project proyecto-a ``` ## Suma a otro miembro del equipo Todo lo anterior funciona igual de bien para un equipo: Engram Cloud no distingue entre "tu otra máquina" y "la máquina de un compañero". Mismo servidor, mismo proyecto, memoria compartida. El onboarding tiene una parte en el servidor y otra en la máquina del nuevo integrante. ### En el servidor (tú, una sola vez) Verifica que el proyecto compartido esté en `ENGRAM_CLOUD_ALLOWED_PROJECTS`; si ya lo agregaste para tus propias máquinas, no hay nada más que hacer. Y comparte con tu compañero dos datos por un canal seguro (un gestor de contraseñas, nunca un chat en texto plano): la URL del servidor y el valor de `ENGRAM_CLOUD_TOKEN`. ### En la máquina del nuevo integrante Los cuatro pasos, en orden: ```bash # 1. Instala el CLI (brew en macOS/Linux; binario o go install en Windows) brew install gentleman-programming/tap/engram # 2. Conecta su agente (Claude Code como ejemplo) claude plugin marketplace add Gentleman-Programming/engram claude plugin install engram # 3. Apunta el CLI al servidor del equipo engram cloud config --server https://engram.tudominio.com # 4. Enrola el proyecto y haz la primera sincronización engram cloud enroll proyecto-a engram sync --cloud --project proyecto-a ``` Entre el paso 3 y el 4, el token va como variable de entorno. En Windows: ```powershell setx ENGRAM_CLOUD_TOKEN "" $env:ENGRAM_CLOUD_TOKEN = "" ``` En macOS o Linux: ```bash echo 'export ENGRAM_CLOUD_TOKEN=""' >> ~/.zshrc source ~/.zshrc ``` Esa primera sincronización descarga el historial completo del proyecto: tu compañero arranca con toda la memoria acumulada del equipo (decisiones, bugs resueltos, convenciones) desde el primer minuto. A partir de ahí, su flujo diario es el mismo que el tuyo: sincronizar al empezar y al terminar. Tres detalles que importan en equipo: - **El nombre del proyecto debe coincidir exactamente** en todas las máquinas. La sincronización es por nombre de proyecto: si tú usas `proyecto-a` y tu compañero enrola `proyectoA`, cada uno alimenta una memoria distinta y nunca se fusionan. - **El token compartido da acceso de lectura y escritura** a todos los proyectos de la allowlist. Compártelo solo con el equipo, y si alguien se va, rótalo: genera uno nuevo con `openssl rand -hex 32`, actualiza la variable en el servidor, redespliega y avisa al resto. - **Existen cuentas y tokens gestionados por usuario** (vía `engram cloud bootstrap admin` y el dashboard) para un control más fino de quién accede a qué proyecto. Para un equipo pequeño, el token compartido es el camino simple y suficiente. ## Errores comunes y su solución - `blocked_unenrolled`: el proyecto no está enrolado en esa máquina. Es la puerta local: agregarlo a la allowlist del servidor no ayuda. Ejecuta `engram cloud enroll `. - `401 unauthorized: missing authorization header`: el token no está en el shell que ejecuta la sincronización. Abre una terminal nueva o define la variable en la sesión actual. - Crash loop con `cannot parse "postgres://..."`: la contraseña de Postgres tiene caracteres no válidos para una URL. Genera una nueva con `openssl rand -hex 24` y actualízala tanto en la base como en las variables. - El dominio devuelve 404 en todas las rutas: revisa que el contenedor no esté en crash loop y que el servicio `cloud` esté conectado a `dokploy-network`. - `404` solo en la raíz `/`: no es un error, la API no tiene ruta raíz. Verifica con `/health`. ## Cierra el círculo Con esto tienes memoria persistente en local en menos de cinco minutos, y si trabajas desde varias máquinas, tu propia nube de sincronización sin depender de ningún servicio de terceros: tus memorias, tu servidor, tus reglas. Para profundizar, el punto de partida es el repositorio oficial: [github.com/Gentleman-Programming/engram](https://github.com/Gentleman-Programming/engram). Ahí encontrarás la [documentación de instalación](https://github.com/Gentleman-Programming/engram/blob/main/docs/INSTALLATION.md), la guía de [Engram Cloud](https://github.com/Gentleman-Programming/engram/blob/main/docs/engram-cloud/quickstart.md) y las [releases](https://github.com/Gentleman-Programming/engram/releases) con los binarios para cada plataforma. Y si lo pruebas, cuéntanos en la comunidad cómo te fue: ver cómo otros builders estructuran la memoria de sus agentes es de las mejores formas de mejorar la tuya. ## Sigue al creador de Engram Engram existe gracias a [Alan Buscaglia](https://www.linkedin.com/in/alanbuscaglia/), más conocido como **Gentleman Programming**, y a toda la comunidad open source que colabora en el [repositorio](https://github.com/Gentleman-Programming/engram) con código, issues y feedback. Esta guía solo documenta ese trabajo: todo el mérito de la herramienta es de ellos. Si Engram te resulta útil, la mejor manera de agradecerlo es darle una estrella al [repositorio](https://github.com/Gentleman-Programming/engram) y seguir su contenido, donde comparte arquitectura, buenas prácticas y desarrollo con IA de forma clara y sin humo: - YouTube: [youtube.com/@gentlemanprogramming](https://www.youtube.com/@gentlemanprogramming) - LinkedIn: [linkedin.com/in/alanbuscaglia](https://www.linkedin.com/in/alanbuscaglia/) ### Por qué construir en comunidad supera al builder solitario URL: https://landing.vibecoders.la/blog/comunidad-vs-soledad-builder Autor: Sheeper · Publicado: 2026-03-25 Hay un mito persistente en el mundo del emprendimiento tecnológico: el builder solitario genial que, en su habitación oscura, construye el próximo producto que cambia el mundo. Es un mito atractivo. También es, en la mayoría de los casos, una trampa. La realidad de construir un producto desde cero es mucho más mundana: hay días en que nada funciona, en que no sabes por dónde seguir, en que la motivación desaparece completamente. Y en esos días, la diferencia entre abandonar y continuar suele ser tener otras personas que están pasando por lo mismo. ## Lo que la comunidad da que el trabajo solitario no puede El feedback rápido es quizás el beneficio más inmediato. Cuando publicas lo que estás construyendo en una comunidad de personas que entienden el contexto, recibes retroalimentación honesta y relevante en horas, no en semanas. Eso es un acelerador brutal para la toma de decisiones. Pero hay algo menos obvio que el feedback: la normatividad social del progreso. Cuando ves que otros builders en tu comunidad lanzan, iteran y comparten sus aprendizajes, eso crea una presión positiva para hacer lo mismo. No es competencia tóxica: es accountability colectivo. "Si ellos pueden, yo también puedo" es uno de los motivadores más poderosos que existen. ## Los conocimientos que circulan en comunidades funcionan diferente El conocimiento que se genera en una comunidad activa de builders es diferente al que encuentras en un tutorial o en la documentación. Es conocimiento contextual: "Intenté X con Lovable y no funcionó porque Y, así que usé Z y el resultado fue este." Ese tipo de insight tarda meses en llegar a un blog post. En una comunidad, llega en tiempo real. Además, las comunidades generan conexiones que se convierten en colaboraciones. El builder que conoces hoy puede ser tu cofundador mañana, tu primer cliente la semana que viene, o simplemente la persona que te presenta a alguien que necesitas conocer. ## La soledad tiene un costo oculto El costo más alto de construir solo no es la falta de recursos ni de conocimiento. Es el agotamiento silencioso de no tener con quién compartir las victorias pequeñas ni procesar las frustraciones. Los productos que abandonamos no suelen abandonarse porque eran malas ideas: se abandonan porque el proceso fue demasiado pesado para cargarlo solo. En VibeCoders estamos construyendo exactamente ese espacio: una comunidad donde los builders que usan IA para crear productos digitales pueden encontrarse, compartir lo que aprenden y crecer juntos. Si llevas tiempo construyendo solo, quizás es el momento de cambiar eso. ### Cómo mantener arquitectura limpia cuando la IA genera tu código URL: https://landing.vibecoders.la/blog/arquitectura-limpia-con-ia Autor: Sheeper · Publicado: 2026-03-10 Hay un patrón que se repite en proyectos de Vibe Coding: en las primeras semanas, todo va rápido y bien. El builder describe features, la IA las implementa, el producto crece. Pero llegado un punto, las nuevas instrucciones empiezan a romper cosas que ya funcionaban. Los archivos tienen cientos de líneas de lógica mezclada. Nadie, ni el builder ni la propia IA, puede entender qué hace exactamente cada parte del sistema. Ese es el síntoma de deuda técnica acumulada. Y no es exclusivo del Vibe Coding: pasa en todos los proyectos que priorizan la velocidad sin pensar en la estructura. Pero la IA puede acelerarlo dramáticamente si no se aplican algunas estrategias básicas desde el inicio. ## Principio 1: Separa responsabilidades desde el día uno La regla más importante: cada archivo o módulo debe tener una sola responsabilidad clara. Un componente de React no debería contener lógica de negocio. Una función de API no debería formatear datos de UI. Una función de utilidades no debería hacer llamadas a base de datos. Cuando le des instrucciones a la IA, sé explícito: "Crea una función en `/lib/projects.ts` que haga la consulta a Supabase. El componente solo debe llamar a esa función y mostrar los resultados." Esa separación explícita en el prompt produce arquitectura mucho más limpia que dejársela a la IA decidir. ## Principio 2: Revisa el código antes de aceptarlo Este es el punto donde más builders fallan: confiar ciegamente en el output de la IA sin revisarlo. No necesitas entender cada línea, pero sí deberías poder responder: ¿qué hace este archivo? ¿por qué existe esta función? ¿dónde se llama esto? Si no puedes responder esas preguntas, tienes un problema. Usa la IA para que te explique el código que genera: "Explícame qué hace esta función y por qué la estructuraste así." Es un hábito que construye comprensión y previene bugs futuros. ## Principio 3: Establece convenciones claras y respétalas Al inicio del proyecto, define y documenta: - Estructura de carpetas: ¿dónde van los componentes? ¿los hooks? ¿la lógica de negocio? - Nomenclatura: ¿PascalCase para componentes? ¿camelCase para funciones? - Patrones para operaciones comunes: ¿cómo se hace una llamada a Supabase? ¿cómo se maneja el error? Guarda esas convenciones en un archivo `CONVENTIONS.md` en la raíz del proyecto. Cuando uses la IA, inclúyelas en el contexto: "Sigue las convenciones definidas en CONVENTIONS.md." Los modelos modernos respetan esas guías con bastante fidelidad. ## Principio 4: Refactoriza antes de que el caos llegue No esperes a que el proyecto sea inmanejable para limpiar. Dedica 20% de tu tiempo en cada sprint a refactorizar: extraer funciones repetidas, simplificar componentes que crecieron demasiado, añadir comentarios donde la lógica no es obvia. La buena noticia: la IA es excelente para refactorizar. "Extrae la lógica de autenticación de este componente a un hook personalizado" es exactamente el tipo de instrucción que los modelos ejecutan bien. El builder que entiende cuándo y qué refactorizar tiene una ventaja enorme sobre quien solo sabe pedir features nuevos. La arquitectura limpia no es un lujo para proyectos grandes. Es la diferencia entre un producto que escala y uno que se convierte en una trampa de mantenimiento. ### De idea a MVP en 72 horas usando herramientas de IA URL: https://landing.vibecoders.la/blog/de-idea-a-mvp-con-ia Autor: Sheeper · Publicado: 2026-02-20 Construir un MVP solía ser el mayor cuello de botella para los founders no técnicos. Necesitabas contratar un desarrollador, esperar semanas, gastar miles de dólares... y al final obtener algo que no era exactamente lo que tenías en mente. Con las herramientas de IA disponibles hoy, ese proceso se puede comprimir a 72 horas sin sacrificar la calidad del producto. Esta guía documenta el proceso exacto que hemos visto funcionar una y otra vez en la comunidad VibeCoders. ## Hora 0–4: Definir el producto con precisión Antes de abrir cualquier herramienta de IA, necesitas responder tres preguntas: 1. ¿Qué problema concreto resuelve tu producto? 2. ¿Para quién específicamente lo resuelve? 3. ¿Cuál es la acción principal que el usuario debe poder hacer? No sigas hasta tener respuestas claras. La IA puede construir cualquier cosa que le describes, pero si tu descripción es vaga, el resultado también lo será. Escribe un documento de una sola página: el problema, el usuario, y el flujo principal. Nada más por ahora. ## Hora 4–12: Estructura y diseño con Lovable Con el documento en mano, abre Lovable y empieza con un prompt claro. No escribas "quiero una app de gestión de tareas". Escribe: "Quiero una app donde equipos pequeños puedan crear proyectos, asignar tareas a miembros del equipo, y ver el progreso en un tablero kanban. Los usuarios se autentican con email y contraseña. Necesito una pantalla de login, un dashboard con los proyectos, y una vista de detalle de proyecto con el tablero." Lovable generará la estructura base. Desde ahí, itera: ajusta el diseño, añade las pantallas que faltan, conecta Supabase para la base de datos. El ciclo es: describe → revisa → ajusta → repite. ## Hora 12–36: Lógica de negocio y datos Esta es la fase más importante y donde más builders se atascan. Necesitas definir: - Las tablas en Supabase (usuarios, proyectos, tareas, membresías) - Las reglas de acceso: ¿quién puede ver qué? ¿quién puede editar qué? - Los flujos principales: crear proyecto, invitar miembro, completar tarea Usa Claude Code o el chat de Cursor para generar el SQL de las tablas y las políticas de Row Level Security en Supabase. La IA puede generar código correcto si le das el contexto exacto de tu modelo de datos. ## Hora 36–60: Pulir la experiencia Con la funcionalidad core funcionando, es hora de mejorar la experiencia: - Manejo de errores: ¿qué pasa cuando algo falla? - Estados vacíos: ¿qué ve el usuario cuando no hay datos? - Feedback visual: loading states, confirmaciones de acciones, toasts Estos detalles marcan la diferencia entre un prototipo y un producto que la gente quiere usar. Documéntalos como user stories y pásalos a Lovable o Cursor para implementarlos. ## Hora 60–72: Deploy y distribución Conecta tu repositorio de GitHub a Vercel. Con el plan gratuito de Vercel tienes más que suficiente para un MVP. Configura las variables de entorno para Supabase, haz el deploy, y verifica que todo funciona en producción. Comparte el link con al menos 5 personas que encajan con tu perfil de usuario objetivo. No con amigos que van a decir "está bien". Con personas que realmente tienen el problema que intentas resolver. La retroalimentación de esas primeras conversaciones vale más que cualquier feature que puedas añadir en las próximas semanas. El MVP no es el producto terminado. Es el comienzo del aprendizaje real. ### Las mejores herramientas de IA para builders en 2026 URL: https://landing.vibecoders.la/blog/mejores-herramientas-ia-2026 Autor: Sheeper · Publicado: 2026-02-03 El ecosistema de herramientas de IA para developers y builders evolucionó a una velocidad vertiginosa en los últimos doce meses. Si en 2024 la conversación giraba en torno a si estas herramientas eran "reales" o un hype pasajero, en 2026 ya nadie duda de que son parte del stack de cualquier builder serio. La pregunta ahora es: ¿cuál usas para qué? ## Cursor: el editor para quienes ya saben programar Cursor se consolidó como la herramienta preferida de developers con experiencia. Es un fork de VS Code que integra IA directamente en el flujo de trabajo. La clave de Cursor es que asumes el control total del código: tú ves todo, tú apruebas todo, y la IA sugiere en contexto. **Ideal para**: proyectos existentes, refactoring, debugging, developers que quieren aumentar su velocidad sin perder control. ## Lovable: de idea a producto en horas Lovable apunta a un segmento diferente: founders, diseñadores y builders que quieren construir productos completos sin necesariamente dominar el código. Su interfaz de chat convierte instrucciones en lenguaje natural en aplicaciones React funcionales con Supabase como backend. **Ideal para**: MVPs de SaaS, landing pages con lógica, prototipos que necesitan convertirse en productos reales. ## Bolt: velocidad máxima para prototipos Bolt es la opción cuando necesitas velocidad por encima de todo. Genera proyectos completos en segundos y su integración con StackBlitz permite verlos en el navegador inmediatamente, sin configurar nada localmente. **Ideal para**: demos, hackathons, pruebas de concepto rápidas, cuando el tiempo es más valioso que la arquitectura perfecta. ## Claude Code: el asistente con contexto profundo Claude Code de Anthropic destaca por su capacidad de mantener contexto en proyectos complejos y su razonamiento detallado. No genera interfaces visuales, pero para código de backend, APIs, scripts y automatizaciones es excepcionalmente preciso. **Ideal para**: lógica de negocio compleja, APIs, automatizaciones, developers que priorizan la calidad sobre la velocidad. ## Windsurf: el editor que aprende tu proyecto Windsurf introduce el concepto de "flows": secuencias de acciones que la IA ejecuta de forma autónoma en tu codebase. Es la opción más cercana a tener un agente que realmente entiende la estructura de tu proyecto. **Ideal para**: proyectos medianos-grandes, equipos pequeños, cuando quieres delegar tareas completas y no solo completar código. ## ¿Con cuál empezar? Nuestra recomendación práctica: si eres nuevo en el desarrollo, empieza con Lovable. Si ya tienes experiencia, prueba Cursor. Si estás en un hackathon o necesitas un prototipo mañana, usa Bolt. Y cuando el proyecto crezca, evalúa Windsurf o Claude Code para las partes más complejas. Las mejores builders usan varias herramientas según el contexto. ### ¿Qué es el Vibe Coding y por qué está cambiando el desarrollo de software? URL: https://landing.vibecoders.la/blog/que-es-vibe-coding Autor: Sheeper · Publicado: 2026-01-15 El término **Vibe Coding** fue acuñado por Andrej Karpathy a principios de 2025 y en pocos meses se convirtió en uno de los conceptos más discutidos del ecosistema tecnológico. La idea es simple pero poderosa: en lugar de escribir código línea por línea, le describes a una herramienta de IA lo que quieres construir, revisas el resultado, lo ajustas, y repites el proceso hasta que funciona. No es que el programador desaparezca. Es que el rol cambia radicalmente. En el Vibe Coding, tú eres el arquitecto, el diseñador de producto y el director técnico al mismo tiempo. La IA es tu equipo de implementación. Y eso tiene implicaciones enormes para quién puede construir software hoy. ## ¿Por qué importa ahora? Herramientas como Lovable, Bolt, Cursor y Claude Code alcanzaron un nivel de madurez que antes era imposible de imaginar. Un founder sin formación técnica formal puede hoy lanzar un SaaS funcional en 72 horas. Un diseñador puede construir su propio portfolio con lógica dinámica. Un consultor puede automatizar procesos de su cliente sin depender de un desarrollador. El Vibe Coding no reemplaza el conocimiento técnico profundo: lo redistribuye. Quien entiende de arquitectura, de patrones de diseño y de los fundamentos del software sigue teniendo ventaja. Pero ahora esa ventaja se amplifica enormemente con las herramientas de IA en lugar de limitarse a quien puede escribir código desde cero. ## Lo que cambia y lo que no Lo que cambia: la barrera de entrada. Antes necesitabas meses de aprendizaje antes de poder construir algo útil. Hoy puedes tener un MVP funcional en días, incluso sin haber escrito una línea de código en tu vida. Lo que no cambia: la necesidad de pensar bien los problemas. Las herramientas de IA no saben qué producto construir, no conocen a tus usuarios, no entienden las restricciones de tu negocio. Eso sigue siendo 100% tu responsabilidad. El Vibe Coder exitoso es aquel que combina visión de producto con capacidad de iterar rápido usando IA. En VibeCoders, estamos construyendo la comunidad donde esos builders se encuentran, comparten lo que aprenden y se ayudan mutuamente a crecer. Bienvenido al movimiento. ## Charlas ### Automatización sin código con N8N URL: https://landing.vibecoders.la/charlas/automatizacion-n8n Speaker: Nicolás Dubois (Automation Engineer & Builder) Aprende a construir flujos de automatización poderosos usando N8N, conectar más de 400 servicios y liberar tiempo para lo que realmente importa. En esta primera sesión de VibeCoders, Nicolás Dubois nos mostró cómo N8N puede transformar radicalmente la forma en que un builder opera su producto. N8N es una herramienta de automatización de flujos de trabajo de código abierto que permite conectar más de 400 servicios sin necesidad de escribir código. ## Lo que aprendimos en esta sesión Nicolás comenzó con un caso real: su propio proceso de onboarding para nuevos usuarios de su SaaS. Antes de N8N, ese proceso tomaba 2 horas por semana de trabajo manual. Con los flujos que construyó en vivo durante la sesión, se automatizó completamente. El workflow que construimos paso a paso incluía: recepción de nuevo usuario desde Supabase, envío de email de bienvenida personalizado, creación de registro en Notion, notificación al canal de Slack del equipo, y activación de una secuencia de onboarding en ActiveCampaign. Todo sin escribir una línea de código. ## Por qué N8N sobre Zapier o Make La pregunta del público fue inevitablemente sobre por qué N8N y no Zapier o Make. La respuesta de Nicolás fue directa: el modelo self-hosted de N8N elimina los costos de ejecución que en Zapier o Make pueden escalar rápidamente. Para un indie builder con volúmenes medianos de automatizaciones, N8N instalado en un VPS de $5/mes puede reemplazar planes de $100+/mes en Zapier. ## Takeaways clave La sesión dejó tres aprendizajes fundamentales: primero, identifica los procesos repetitivos antes de automatizar, porque automatizar un proceso malo solo lo hace más rápido pero igual de malo. Segundo, empieza por el flujo más doloroso, no el más fácil. Tercero, N8N tiene una curva de aprendizaje inicial que vale completamente la pena superar. ### Supabase para Vibe Coders: backend completo sin dolor URL: https://landing.vibecoders.la/charlas/supabase-para-builders Speaker: Martín Acosta (Full-stack Builder & Supabase enthusiast) Todo lo que necesitas saber sobre Supabase para construir el backend de tu SaaS: base de datos, autenticación, storage y edge functions en una sola plataforma. Martín Acosta llegó a esta segunda sesión con una premisa clara: Supabase es probablemente la mejor inversión de tiempo que puede hacer un builder que quiere escalar sin contratar un backend engineer. En 58 minutos, recorrimos desde la configuración inicial hasta el deployment de edge functions en producción. ## Supabase como plataforma completa Lo que hace poderoso a Supabase no es ninguna característica individual, sino la integración de todo el stack: PostgreSQL como base de datos, autenticación gestionada, storage para archivos, realtime para actualizaciones en vivo, y edge functions para lógica de servidor. Todo en un dashboard unificado con un generoso free tier. Martín mostró cómo, para su último SaaS, el tiempo desde "idea" hasta "producto con autenticación y base de datos funcionando" fue de menos de 3 horas usando Lovable + Supabase. ## El componente más subestimado: RLS Row Level Security fue el tema que más tiempo ocupó en la sesión, y con razón. RLS es el mecanismo de Supabase para controlar qué usuario puede ver o modificar qué datos. Sin RLS bien configurado, tu aplicación tiene vulnerabilidades de seguridad graves aunque el frontend parezca funcionar bien. La demostración en vivo fue impactante: en menos de 5 minutos, Martín mostró cómo acceder directamente a la API de Supabase sin autenticación para extraer todos los datos de una tabla que no tenía RLS activado. Después mostró cómo una política RLS de tres líneas bloqueaba ese acceso completamente. ## Lo que la IA puede y no puede hacer aquí Una advertencia importante de Martín: los modelos de IA generan políticas RLS, pero no siempre correctas. Siempre hay que testear manualmente que las políticas funcionan como se espera. Este es uno de los puntos donde el criterio humano sigue siendo irremplazable. ### Diseño de UI con IA: de wireframe a interfaz pulida URL: https://landing.vibecoders.la/charlas/diseno-ui-con-ia Speaker: Lucía Fernández (Product Designer & Vibe Coder) Cómo usar herramientas de IA para diseñar interfaces de usuario que se ven profesionales sin necesidad de ser diseñador, y los límites de lo que la IA puede hacer por ti. Lucía Fernández tiene una perspectiva única: viene del diseño profesional y ahora usa IA para acelerar su proceso. Eso le da una visión crítica que no tienen quienes vienen puramente del lado técnico. Su charla fue una de las más debatidas en la comunidad. ## Lo que la IA hace bien en diseño La generación de componentes UI es donde la IA brilla más. Herramientas como v0 de Vercel pueden generar layouts complejos, formularios bien estructurados, y componentes de tabla o dashboard en segundos a partir de una descripción en texto. Para un builder sin formación en diseño, esto es transformador. Lucía mostró en tiempo real cómo tomó un prompt de "tabla de precios para un SaaS con tres planes" y en tres iteraciones con v0 llegó a un componente que habría tomado 2 horas hacer en Figma desde cero. ## Lo que la IA no puede hacer Aquí fue donde la charla se puso más interesante. La IA genera componentes. No genera sistemas de diseño coherentes. No entiende la jerarquía visual de tu producto. No sabe que ese botón amarillo debe aparecer exactamente una vez por pantalla porque es tu CTA principal. La consistencia visual y la jerarquía de información siguen requiriendo criterio humano. El builder que entiende aunque sea los fundamentos de diseño (espacio en blanco, contraste, jerarquía tipográfica) usará las herramientas de IA para diseño infinitamente mejor que quien no los conoce. ## El flujo de trabajo recomendado El flujo que Lucía propone: (1) sketch en papel de los flujos principales, (2) generación de componentes individuales con v0, (3) integración y ajuste en el código, (4) revisión de consistencia manual. La IA está en el paso 2, no en el resto. ### Deploy en Vercel: de localhost a producción en minutos URL: https://landing.vibecoders.la/charlas/deployar-en-vercel Speaker: Diego Ramírez (DevOps Engineer & Builder) Estrategias probadas para deployar tus aplicaciones en Vercel de forma correcta: preview deployments, variables de entorno, dominios y monitoreo básico. Diego Ramírez abrió su charla con una estadística que golpeó al público: el 40% de los proyectos que los builders presentan en la comunidad no están en producción porque "no saben cómo deployar". Eso es tiempo y potencial desperdiciado que se puede solucionar en una tarde. ## Por qué Vercel para builders Vercel resuelve el problema del deployment de aplicaciones web modernas mejor que cualquier alternativa para el segmento indie builder. No necesitas configurar nginx, no necesitas entender docker por defecto, no necesitas administrar un servidor. Conectas tu repositorio de GitHub y Vercel se encarga del resto. El free tier es generoso: proyectos ilimitados, 100GB de bandwidth al mes, y preview deployments automáticos para cada pull request o branch. Para un MVP o proyecto en etapa temprana, eso es más que suficiente. ## El patrón que más personas hacen mal Variables de entorno. Diego mostró el error más común: commitear el archivo `.env` al repositorio con claves de API en texto plano. Ese error puede resultar en facturas enormes de servicios cloud o en datos de usuarios comprometidos. La solución correcta: usar el panel de Vercel para configurar las variables de entorno por ambiente (development, preview, production) y nunca commitear secrets al repositorio. Si ya lo hiciste, hay que regenerar las claves y hacer un limpiado del historial de git. ## Preview deployments: el feature subestimado El feature que más cambió el workflow de Diego fue los preview deployments automáticos. Cada branch tiene su propia URL con el build completo. Esto significa que puedes compartir un link con usuarios para obtener feedback antes de mergear a main. Es testing de producto gratuito y automatizado. ### Testing asistido por IA: cómo garantizar calidad sin frenar la velocidad URL: https://landing.vibecoders.la/charlas/testing-con-ia Speaker: Ana Torres (QA Engineer & Builder) Estrategias prácticas para integrar tests en proyectos de Vibe Coding sin sacrificar la velocidad de desarrollo que hace poderoso a este enfoque. Ana Torres llegó a VibeCoders con una misión: desmitificar el testing en proyectos de Vibe Coding. Hay una creencia extendida de que testear y moverse rápido son incompatibles. Ana demostró que es falso, con ejemplos concretos. ## El problema real con el testing en Vibe Coding El problema no es que el testing sea difícil. Es que los builders no saben qué testear. Si intentas tener cobertura del 100% del código que genera la IA, efectivamente se convierte en un cuello de botella. Pero nadie debería buscar eso. La pregunta correcta es: ¿qué partes de mi aplicación, si fallan, destruyen la experiencia de mi usuario? Esas partes necesitan tests. El resto puede esperar. ## Lo que sí debes testear siempre Ana identificó tres categorías que siempre merecen tests en un SaaS: flujos de autenticación (login, registro, recuperación de contraseña), lógica de pago (si usas Stripe o similar, los webhooks y la activación de planes), y las transformaciones de datos críticas (cálculos de precios, generación de reportes, formateo de información importante). La IA genera esos tests con notable precisión si le das el contexto correcto. Ana mostró un prompt que genera tests de Vitest para funciones de transformación de datos: especificar los inputs, los outputs esperados y los casos edge es todo lo que necesitas. ## Testing E2E: solo para los flujos principales Para testing end-to-end, Ana recomienda Playwright y una regla simple: tests E2E solo para los 3-5 flujos que, si se rompen, hacen que el producto sea inutilizable. Registro + onboarding, flujo de pago, y la acción core del producto. Nada más. La IA puede generar los scripts de Playwright si grabas el flujo una vez con el modo record de la herramienta. Es una inversión de 30 minutos que previene regresiones durante meses. ### Claude Code en la práctica: el agente de desarrollo más poderoso del mercado URL: https://landing.vibecoders.la/charlas/claude-code-en-practica Speaker: Pol Baladas (AI Engineer & Developer Advocate) Una exploración profunda de Claude Code de Anthropic: cómo usarlo para tareas complejas de desarrollo, sus capacidades agenticas, y los patrones que funcionan mejor. Claude Code representa un salto cualitativo respecto a los asistentes de código anteriores. No es solo un completador de código: es un agente que puede ejecutar comandos, leer y escribir archivos, y mantener contexto sobre proyectos completos durante sesiones extendidas. Pol Baladas llegó con ejemplos en vivo que dejaron al público impresionado. ## Lo que diferencia a Claude Code La diferencia fundamental está en las capacidades agenticas. Claude Code puede ejecutar tests, leer el output de la terminal, ver qué archivos existen en el proyecto, y tomar decisiones basadas en todo ese contexto. No solo escribe código: comprende el estado actual del sistema y trabaja hacia un objetivo. Durante la demo en vivo, Pol le pidió a Claude Code que "implementara la autenticación con Supabase en este proyecto Astro". Sin más instrucciones, el agente leyó los archivos existentes, identificó la estructura del proyecto, instaló las dependencias necesarias, creó los archivos correspondientes, y ejecutó el check de TypeScript para verificar que todo compilaba. Todo solo. ## AGENTS.md: la memoria del proyecto Uno de los patrones más poderosos que Pol compartió es el uso de un archivo `AGENTS.md` en la raíz del proyecto. Este archivo le dice al agente cómo es el proyecto, qué convenciones usa, qué no debe hacer, y cómo está estructurado el código. Con un buen `AGENTS.md`, Claude Code genera código coherente con el estilo del proyecto desde el primer prompt, sin necesitar repetir el contexto en cada sesión. ## MCP: el protocolo que expande todo El Model Context Protocol (MCP) permite conectar Claude Code con herramientas externas: bases de datos, APIs, sistemas de archivos, servicios web. Pol mostró una integración con Supabase via MCP que permite al agente inspeccionar el schema de la base de datos y generar migraciones correctas sin salir de Claude Code. ## Las limitaciones honestas Pol cerró con algo raro en las charlas de herramientas: hablar honestamente de las limitaciones. Claude Code falla en tareas que requieren contexto visual (no puede ver screenshots), en proyectos con más de ~500 archivos sin estructura clara, y cuando las instrucciones son ambiguas. El operador humano sigue siendo esencial para definir qué se quiere, no solo pedirle al agente que "lo arregle todo". ### Monetización para indie builders: de usuarios gratis a ingresos recurrentes URL: https://landing.vibecoders.la/charlas/monetizar-tu-saas Speaker: Carolina Vega (Indie SaaS Founder) Estrategias probadas para monetizar un SaaS construido por una persona: modelos de pricing, integración de pagos, y cómo hacer la transición del free al paid sin perder usuarios. Carolina Vega construyó su primer SaaS monetizado sin saber exactamente cómo hacerlo, aprendiendo sobre la marcha. Su segunda vez fue completamente diferente. Esta charla condensó esos aprendizajes en una guía práctica para la comunidad. ## El error más común: esperar demasiado para cobrar El error número uno que Carolina ve en builders de la comunidad es esperar a tener el producto "terminado" para cobrar. El producto nunca está terminado. Y esperar significa acumular usuarios en un tier gratuito del que luego es muy difícil mover. La recomendación: define tu modelo de pricing antes de lanzar, aunque sea una hipótesis. Lanza con un plan de pago desde el primer día, aunque también tengas un free tier. La gente que paga desde el inicio es tu feedback más valioso. ## Modelos que funcionan para indie builders Carolina comparó tres modelos que ha usado personalmente: freemium (gratis hasta cierto límite, pago para más), trial (acceso completo por 14 días, luego pago), y pago desde el inicio sin free tier. Su conclusión: depende del perfil de usuario y del valor percibido del producto. Para productos con alto valor percibido desde el primer uso (herramientas de productividad, automatizaciones que ahorran tiempo), el trial funciona mejor. Para herramientas que necesitan tiempo para mostrar su valor, el freemium permite que los usuarios lleguen al momento "aha" antes de pedirles que paguen. ## Stripe + IA: la integración más rápida La demostración técnica mostró cómo integrar Stripe en un SaaS existente usando Claude Code. El proceso completo (webhooks, gestión de suscripciones, portal de facturación) tomó 40 minutos en live coding. Hace dos años, eso habría sido un día entero de trabajo. La clave está en el manejo correcto de webhooks: la mayoría de los bugs de facturación en SaaS vienen de webhooks mal implementados. Carolina mostró una checklist de los eventos que hay que manejar siempre: `customer.subscription.created`, `customer.subscription.updated`, `customer.subscription.deleted`, y `invoice.payment_failed`. ### Lovable en producción: lecciones de 6 meses usando la herramienta en proyectos reales URL: https://landing.vibecoders.la/charlas/lovable-en-produccion Speaker: Rosmel Rodríguez (Founder VibeCoders) Lo que nadie te cuenta sobre usar Lovable en proyectos que llegan a producción: limitaciones reales, workarounds, patrones que funcionan y cuándo salir del modo chat. Esta fue la charla más personal de toda la serie. Rosmel compartió seis meses de trabajo real con Lovable, incluyendo los fracasos y las lecciones aprendidas de la manera difícil. No es una charla de marketing de la herramienta: es una evaluación honesta de lo que funciona y lo que no. ## Las primeras semanas: la luna de miel Las primeras semanas con Lovable son casi mágicas. Describes una feature, aparece implementada. Pides un cambio de diseño, se aplica. El feedback loop es tan rápido que la sensación es de productividad ilimitada. Y en cierta medida, para proyectos en etapa temprana, eso es real. El primer producto construido con Lovable llegó a su primer usuario en 5 días. Cinco días desde el concepto hasta alguien usando el producto en producción. Eso hubiera sido imposible dos años antes. ## Mes 2-3: cuando el contexto se fragmenta El problema que nadie menciona: Lovable trabaja con el estado actual del código, pero el contexto de "por qué esto está así" se pierde con el tiempo. Cuando empiezas a pedir cambios en features que se construyeron hace un mes, la IA a veces no comprende las decisiones anteriores y genera código que rompe cosas que ya funcionaban. La solución que encontré: mantener un documento `CONTEXT.md` actualizado que explica las decisiones arquitectónicas principales y el estado actual del producto. Incluirlo al inicio de sesiones importantes con Lovable reduce dramáticamente los problemas de contexto. ## Patrones que funcionan Tres patrones que recomiendo después de seis meses: (1) Trabajar en features atómicas: una sola cosa por sesión, no pedir cinco cambios a la vez. (2) Hacer commits frecuentes: antes de cada sesión importante, commit del estado estable para poder revertir si algo se rompe. (3) Revisar el diff antes de aceptar: Lovable muestra los cambios antes de aplicarlos; ese paso de revisión previene el 80% de los problemas. ## Cuándo salir del modo Lovable Lovable es perfecta para el 80% del trabajo en un indie SaaS. Para el 20% restante (lógica de negocio compleja, integraciones con APIs raras, optimizaciones de performance), es mejor usar Cursor o Claude Code directamente en el repositorio. El error es insistir con Lovable en partes del proyecto donde no es la herramienta correcta. ## Aprende vibe coding ### Módulo 1: Introducción al vibe coding URL: https://landing.vibecoders.la/learn/01-introduccion Descubre qué es el vibe coding, por qué está cambiando la industria y cómo puedes empezar hoy mismo sin experiencia previa. ## ¿Qué es el vibe coding? El vibe coding es una nueva forma de construir productos digitales donde la inteligencia artificial actúa como tu co-piloto principal. En lugar de escribir cada línea de código desde cero, describes lo que quieres construir en lenguaje natural y la IA genera, refina y depura el código por ti. El término fue acuñado por Andrej Karpathy en 2025 y rápidamente se convirtió en el enfoque preferido de miles de fundadores, diseñadores y emprendedores que quieren lanzar productos sin años de experiencia técnica. ## ¿Por qué importa ahora? Hasta hace poco, construir un producto digital requería: - 2 a 5 años aprendiendo programación - Un equipo de ingenieros - Un presupuesto significativo para desarrollo Con el vibe coding, una sola persona puede lanzar un producto funcional en días o semanas. No es magia — es una colaboración efectiva entre la visión humana y la capacidad de ejecución de la IA. ## Las herramientas del ecosistema Las principales herramientas que usarás en este curso son: **Editores con IA:** - **Cursor** — Editor basado en VS Code con IA integrada. Ideal si quieres control total sobre el código. - **Claude Code** — Terminal inteligente de Anthropic. Excelente para proyectos complejos. **Constructores no-code/low-code:** - **Lovable** — Genera apps completas desde una descripción. Perfecto para empezar. - **Bolt** — Alternativa similar, con enfoque en velocidad de iteración. **Diseño:** - **v0 de Vercel** — Genera componentes UI desde texto. Ideal para interfaces. ## Tu primer paso En el siguiente módulo aprenderás a elegir la herramienta correcta para tu proyecto específico. Cada herramienta tiene sus fortalezas y es importante elegir la adecuada antes de empezar. Por ahora, te recomendamos crear una cuenta gratuita en al menos una de estas plataformas para que puedas experimentar mientras avanzas en el curso. > **Consejo**: No intentes aprender todas las herramientas al mismo tiempo. Elige una, domínala y luego expande tu repertorio. ### Módulo 2: Cómo elegir tu herramienta URL: https://landing.vibecoders.la/learn/02-elegir-herramienta Aprende a seleccionar la herramienta de vibe coding más adecuada para tu proyecto según el tipo de producto, el nivel de control que necesitas y tu presupuesto. ## No existe la herramienta perfecta, sino la herramienta correcta para ti Uno de los errores más frecuentes en personas que empiezan con vibe coding es elegir la herramienta más popular o la que vieron en un tutorial de YouTube, sin considerar sus propias necesidades. Cada herramienta del ecosistema tiene un propósito específico y entender esas diferencias te ahorrará semanas de frustración. La pregunta clave no es "¿cuál es la mejor herramienta?" sino "¿qué tipo de producto estoy construyendo y cuánto control necesito sobre el código?". A partir de esa respuesta, la elección se vuelve mucho más clara. ## Dos grandes categorías Las herramientas de vibe coding se dividen en dos grupos principales: **Constructores no-code (Lovable, Bolt):** generan una aplicación completa desde una descripción en lenguaje natural. No necesitas saber nada de programación. Son ideales para validar ideas rápidamente, construir MVPs y explorar conceptos sin fricción técnica. La desventaja es que tienes menos control sobre la arquitectura del código resultante. **Editores con IA (Cursor, Claude Code):** son entornos de desarrollo tradicionales potenciados con inteligencia artificial. Tienes acceso completo al código, puedes integrar cualquier librería y aplicar tus propias convenciones. Requieren un nivel mínimo de comodidad con archivos de código, aunque no necesitas ser programador experto. ## Cómo decidir Sigue estas preguntas en orden: 1. **¿Necesitas lanzar en menos de una semana?** → Empieza con Lovable o Bolt. 2. **¿Tu producto tiene requisitos técnicos específicos (autenticación compleja, APIs externas, lógica de negocio elaborada)?** → Cursor o Claude Code te dan más margen. 3. **¿Tu presupuesto inicial es cero?** → Bolt y v0 tienen planes gratuitos generosos. Cursor también. 4. **¿Quieres aprender sobre el código que genera la IA?** → Un editor con IA te da visibilidad total. No hay respuesta incorrecta. Lo importante es que empieces y ajustes según lo que vayas aprendiendo en la práctica. > **Consejo**: Muchos builders profesionales usan varias herramientas en combinación. Por ejemplo, v0 para diseñar la interfaz y luego Cursor para integrar la lógica de negocio. No tienes que elegir una sola para siempre. ### Módulo 3: Tu primer prompt efectivo URL: https://landing.vibecoders.la/learn/03-primer-prompt Aprende a escribir prompts claros y detallados que la IA pueda ejecutar correctamente, evitando los errores más comunes que frustran a los principiantes. ## La IA ejecuta lo que describes, no lo que imaginas El mayor salto de mentalidad que necesitas hacer al empezar con vibe coding es entender que la IA interpreta tus palabras literalmente. Si tu descripción es vaga, el resultado será impredecible. Si tu descripción es precisa, el resultado se acercará mucho a lo que tienes en mente. Un error clásico es escribir "quiero una app de notas" y esperar que la IA adivine tu visión completa. En cambio, si describes "quiero una app de notas donde el usuario puede crear carpetas, escribir notas con formato markdown y exportarlas como PDF", obtienes algo muy diferente y mucho más útil. ## La anatomía de un prompt efectivo Un buen prompt de vibe coding tiene cuatro partes: **1. Contexto del producto:** Describe qué es lo que estás construyendo y para quién. Ejemplo: "Estoy construyendo una herramienta para freelancers que necesitan enviar propuestas a clientes." **2. Funcionalidad core:** Lista las 3-5 funciones más importantes. Sé específico. No "gestión de clientes" sino "formulario para agregar clientes con nombre, email y empresa". **3. Estilo visual:** Menciona referencias si las tienes. "Estilo minimalista, fondo blanco, tipografía sans-serif, sin colores llamativos." O simplemente "similar a Notion en cuanto a limpieza visual". **4. Restricciones técnicas:** Si sabes que necesitas integrarse con algún servicio (Supabase, Stripe, SendGrid), menciónalo desde el inicio. Cambiarlo después es más costoso. ## Tu primer prompt en la práctica Toma 10 minutos antes de escribir tu primer prompt y responde estas preguntas por escrito: - ¿Qué problema resuelve mi producto? - ¿Quién lo va a usar? - ¿Cuáles son las 3 acciones principales que el usuario debe poder hacer? - ¿Qué no debe incluir en esta primera versión? Con esas respuestas, construye tu prompt. No tiene que ser perfecto: en el siguiente módulo aprenderás a iterar y mejorar el resultado. > **Consejo**: Incluye siempre la frase "en una primera versión" en tu prompt inicial. Esto le indica a la IA que debe priorizar lo esencial y no agregar complejidad innecesaria. ### Módulo 4: Iteración y refinamiento URL: https://landing.vibecoders.la/learn/04-iteracion Aprende a trabajar en ciclos cortos con la IA: revisar el resultado, identificar qué ajustar y formular el siguiente prompt para acercarte progresivamente a tu visión. ## El vibe coding es un diálogo, no un comando único Muchas personas esperan que el primer prompt genere el producto terminado. Eso no es realista ni con la mejor IA del mercado. El proceso de vibe coding se parece más a trabajar con un colaborador muy capaz pero que necesita dirección constante: produces algo, lo revisas, das feedback específico, produces la siguiente versión. Este ciclo — generar, revisar, corregir — es donde ocurre la mayor parte del aprendizaje y donde se define la calidad del producto final. No es un defecto del proceso; es el proceso. ## El ciclo de iteración Cada ciclo tiene tres pasos: **Paso 1 — Revisar con intención.** Cuando el resultado llega, no lo evalúes en términos de "me gusta / no me gusta". Evalúa funcionalidad: ¿la acción principal que describí funciona? ¿El flujo es coherente? Anota exactamente qué no funciona, en términos concretos. **Paso 2 — Aislar el problema.** No intentes corregir todo de una vez en un solo prompt. Elige el problema más importante o el que bloquea todo lo demás. Escribe un prompt que describa específicamente ese problema y qué esperas como solución. **Paso 3 — Validar el avance.** Después de cada cambio, vuelve a probar las funcionalidades que ya funcionaban. A veces al corregir algo se rompe otra cosa. Mejor detectarlo temprano. ## Cómo formular prompts de refinamiento La diferencia entre un prompt de inicio y uno de refinamiento es que el segundo tiene contexto. Puedes ser mucho más específico: - ❌ "El formulario no funciona bien" - ✅ "Cuando el usuario hace clic en Guardar sin haber completado el campo Email, no aparece ningún mensaje de error. Necesito que se muestre un texto en rojo debajo del campo que diga 'El email es obligatorio'." La especificidad es tu mejor herramienta. Cuanto más precisas tus instrucciones, menos interpretación necesita la IA y mejor es el resultado. ## Cuándo detenerse y empezar de nuevo A veces el código acumulado llega a un estado donde cada cambio rompe algo más. Reconocer ese momento es una habilidad importante. Si después de tres ciclos de corrección el estado del proyecto empeora, considera hacer un "reset" parcial o total y empezar desde un punto más estable, con lo que aprendiste en el proceso. > **Consejo**: Mantén un documento de texto simple con la lista de funcionalidades que ya funcionan. Antes de cada prompt de refinamiento, verifica que esa lista sigue siendo válida. Ese documento es tu red de seguridad. ### Módulo 5: Lanza tu producto al mundo URL: https://landing.vibecoders.la/learn/05-lanzar Aprende a preparar tu producto para el lanzamiento público: dominio, deploy, primeros usuarios y cómo recoger feedback que realmente sirve para seguir construyendo. ## Lanzar antes de estar "listo" El mayor obstáculo en el lanzamiento de un producto no es técnico: es psicológico. Hay siempre algo más que pulir, una funcionalidad que falta, un detalle visual que mejorar. Si esperas a que el producto esté "listo", no lanzas nunca. La realidad es que los usuarios reales descubren problemas que tú nunca encontrarías solo. La única forma de saber si tu producto resuelve un problema real es ponerlo frente a personas reales. Todo lo que construyes antes de ese momento es una suposición. ## El stack mínimo para lanzar Con las herramientas de vibe coding, el deploy se simplifica mucho. Los pasos básicos son: **1. Plataforma de hosting:** Vercel y Railway son las opciones más populares. Ambas tienen planes gratuitos que cubren proyectos pequeños. Conectas tu repositorio y el deploy es automático. **2. Dominio propio:** Un dominio cuesta entre $10 y $15 al año. No es opcional si quieres que la gente tome tu producto en serio. Namecheap y Cloudflare son los registradores más recomendados por la comunidad. **3. URL de feedback:** Antes de lanzar, define cómo vas a recoger feedback. Puede ser tan simple como un formulario de Google Forms o un canal de Discord. Lo importante es tener un canal activo desde el primer día. ## Tu primer lanzamiento No intentes llegar a miles de personas en el primer día. Define un grupo pequeño y específico: 20-50 personas que tengan el problema que resuelves. Comparte el producto con ellas directamente, con un mensaje personal que explique qué construiste y por qué. Las preguntas más valiosas que puedes hacerles son: - ¿Entendiste qué hace el producto en los primeros 30 segundos? - ¿Pudiste completar la tarea principal sin ayuda? - ¿Qué es lo que más te faltó? Con las respuestas a esas tres preguntas tienes todo lo que necesitas para planificar las próximas dos semanas de desarrollo. > **Consejo**: El lanzamiento no es el final del proceso, es el inicio. Una vez que tienes los primeros usuarios, el vibe coding te permite iterar rápido en respuesta a feedback real. Esa velocidad de iteración es tu mayor ventaja competitiva. ## Recursos ### Plantilla: Spec de producto para vibe coding URL: https://landing.vibecoders.la/recursos/plantilla-spec-producto Una plantilla estructurada para documentar el spec de tu producto antes de empezar a construir con IA. Define el problema, los usuarios, las funcionalidades core y los criterios de éxito. ## ¿Para qué sirve esta plantilla? Antes de escribir el primer prompt a una herramienta de vibe coding, conviene tener claro qué se está construyendo. Esta plantilla te guía para documentar los elementos esenciales de tu producto en menos de 30 minutos. El documento resultante tiene dos usos: primero, clarificar tu propia visión. Segundo, servir como contexto inicial para la IA cuando empieces a construir. --- ## Plantilla ### 1. Nombre del producto `[Nombre tentativo]` ### 2. El problema En una o dos oraciones: ¿qué problema resuelve este producto? ``` [Describe el problema aquí. Sé específico: quién lo tiene, cuándo ocurre, qué consecuencias tiene.] ``` ### 3. El usuario objetivo ¿Para quién es este producto? Describe a la persona concreta que lo va a usar: ``` Edad aproximada: Rol o situación: Nivel técnico: Lo que más le frustra hoy con las soluciones existentes: ``` ### 4. La solución ¿Qué hace tu producto para resolver ese problema? ``` [Describe la solución en 2-3 oraciones. No menciones tecnología todavía — solo el qué.] ``` ### 5. Funcionalidades core (versión 1) Lista las 3-5 funcionalidades más importantes. Estas son las que van en el primer prompt: ``` 1. 2. 3. 4. (opcional) 5. (opcional) ``` ### 6. Lo que NO incluye la versión 1 Tan importante como lo anterior. Define los límites: ``` - No incluye: - No incluye: - No incluye: ``` ### 7. Criterios de éxito mínimos ¿Cómo sabes que la versión 1 funciona? Define 2-3 métricas o acciones concretas: ``` 1. El usuario puede [acción principal] sin ayuda externa. 2. El tiempo de [tarea clave] es menor a [X] minutos. 3. ``` ### 8. Stack sugerido (si ya lo sabes) ``` Frontend: Backend: Base de datos: Hosting: ``` --- ## Cómo usar esta plantilla con Lovable o Cursor Una vez completada, usa las secciones 2, 4 y 5 como base para tu prompt inicial. Incluye el problema, la solución y la lista de funcionalidades core. Agrega la sección 6 al final del prompt con "No incluir en esta versión:". Este contexto inicial le da a la IA suficiente información para generar algo coherente con tu visión, en lugar de tomar decisiones arbitrarias. ### Prompts básicos para Lovable URL: https://landing.vibecoders.la/recursos/prompts-lovable-basicos Colección de prompts probados para las situaciones más comunes en Lovable: crear formularios, configurar autenticación, conectar Supabase y manejar errores frecuentes. ## Cómo usar esta colección Estos prompts están diseñados para copiar y adaptar directamente en Lovable. Cada uno incluye placeholders entre corchetes que debes reemplazar con los detalles de tu proyecto. Están organizados por situación. Busca la que corresponde a lo que necesitas hacer en este momento. --- ## Prompts de inicio ### Crear una app desde cero ``` Crea una aplicación web para [descripción del producto en 1-2 oraciones]. Los usuarios deben poder: 1. [Funcionalidad principal] 2. [Segunda funcionalidad] 3. [Tercera funcionalidad] Estilo visual: [minimalista / moderno / corporativo]. Paleta de colores: [colores o referencias]. No incluir en esta versión: [lista de funcionalidades excluidas]. ``` ### Agregar una pantalla nueva ``` Agrega una pantalla de [nombre de la pantalla] al proyecto. Esta pantalla debe mostrar [qué se muestra] y permitir al usuario [qué acciones puede hacer]. Mantén el mismo estilo visual que el resto de la aplicación. ``` --- ## Prompts de autenticación ### Configurar login y registro ``` Configura autenticación de usuarios con Supabase Auth. Los usuarios deben poder registrarse con email y contraseña, iniciar sesión y cerrar sesión. Agrega las páginas de Login y Registro con el mismo estilo visual del proyecto. Protege todas las rutas que requieren usuario autenticado. ``` ### Agregar login con Google ``` Agrega la opción de "Iniciar sesión con Google" en las páginas de Login y Registro. Mantén el botón con el estilo visual del proyecto. Asegúrate de que el callback de autenticación redirige correctamente a la pantalla principal de la aplicación. ``` --- ## Prompts de formularios ### Formulario con validación ``` Crea un formulario para [propósito del formulario] con los campos: [lista de campos con tipo: texto, email, número, selector, etc.]. Incluye validación en el cliente para campos obligatorios y formato correcto de email. Muestra mensajes de error claros en rojo debajo de cada campo con problema. Al enviar correctamente, muestra una confirmación y [acción posterior: redirige a X / limpia el formulario / etc.]. ``` --- ## Prompts de corrección ### Corregir un error específico ``` En la pantalla de [nombre de la pantalla], cuando el usuario [acción que causa el error], ocurre el siguiente problema: [descripción exacta del problema]. El comportamiento esperado es: [qué debería pasar]. Por favor, corrige solo este problema sin modificar otras partes de la aplicación. ``` ### Revertir un cambio ``` El último cambio introdujo un problema en [parte de la aplicación]. Por favor, revierte únicamente los cambios en [archivo o componente específico] al estado anterior, manteniendo el resto de los cambios recientes. ``` --- ## Prompts de estilo ### Ajustar un componente visual ``` En el componente [nombre del componente], ajusta el estilo de la siguiente manera: [descripción detallada del cambio visual]. No cambies la funcionalidad, solo el aspecto visual. ``` --- ## Consejos para mejores resultados - **Sé específico sobre lo que NO cambiar**: si solo quieres modificar un componente, dilo explícitamente. - **Un problema por prompt**: no intentes corregir varios problemas en el mismo mensaje. - **Describe el comportamiento actual Y el esperado**: da contexto suficiente para que Lovable entienda qué está mal y qué se espera. ## Herramientas ### Bolt URL: https://landing.vibecoders.la/tools/bolt Prototipa aplicaciones web completas en segundos desde el navegador. Pros: Generación de prototipos funcionales extremadamente rápida · Funciona completamente desde el navegador, sin instalar nada · Soporte para múltiples frameworks: React, Vue, Svelte, Astro y más Contras: El límite de tokens del plan gratuito se agota rápido en proyectos reales · Menos capacidad de personalización profunda comparado con editores con IA Ideal para: Prototipos rápidos para presentar ideas a clientes o inversores · Exploración de conceptos de producto antes de comprometerse con un stack · Aprendizaje de frameworks sin necesidad de configurar un entorno local ## El prototipado más rápido del ecosistema Bolt se distingue por una característica específica: la velocidad con la que convierte un prompt en un prototipo funcional. Donde otros constructores pueden tardar varios minutos en generar la primera versión, Bolt produce algo interactivo en cuestión de segundos. Esa velocidad lo hace especialmente valioso en las fases más tempranas de exploración de un producto. A diferencia de Lovable, Bolt no está atado a un stack específico: puede generar proyectos en React, Vue, Svelte o Astro según lo que necesites. Todo funciona directamente en el navegador mediante WebContainers, lo que significa que no necesitas configurar nada en tu máquina para ver el resultado funcionando. ## Limitaciones para proyectos en producción El plan gratuito de Bolt tiene un límite de tokens que se agota con relativa rapidez si iteras activamente. Para proyectos en producción, generalmente conviene migrar el código generado por Bolt a un entorno más robusto — por ejemplo, Cursor — una vez que el prototipo está validado. Bolt es mejor entendido como una herramienta de exploración y validación inicial, no como el entorno donde vas a construir tu producto a largo plazo. Eso no es una crítica: es el caso de uso para el que fue diseñado y en el que brilla. > Bolt es perfecto para la fase de "¿esto tiene sentido?". Una vez confirmado, Cursor o Claude Code son los entornos donde llevas el proyecto a producción. ### Claude Code URL: https://landing.vibecoders.la/tools/claude-code El agente de terminal de Anthropic para proyectos de código complejos. Pros: Razonamiento profundo y comprensión de contexto superior en proyectos complejos · Operación completa desde la terminal, ideal para flujos de trabajo avanzados · Excelente para refactorizaciones grandes y análisis de código existente · Integración nativa con herramientas del sistema y comandos de shell Contras: Requiere suscripción de pago sin opción gratuita para uso intensivo · No tiene interfaz visual propia: se usa desde la terminal o editores compatibles Ideal para: Builders técnicos que trabajan con proyectos de código base extensa · Tareas de refactorización, migración o análisis de código heredado · Proyectos donde la calidad del razonamiento es más importante que la velocidad ## Razonamiento primero, código después Claude Code es la interfaz de terminal de Anthropic para trabajar con código. A diferencia de Cursor, no es un editor visual: se opera desde la línea de comandos y funciona en cualquier entorno donde puedas abrir una terminal. Su principal fortaleza es la capacidad de razonamiento: puede analizar proyectos complejos, entender dependencias entre módulos y proponer soluciones arquitectónicas coherentes antes de tocar una sola línea de código. Para builders con experiencia técnica, Claude Code es frecuentemente la herramienta más efectiva en tareas que requieren comprensión profunda del contexto: migraciones de base de datos, refactorizaciones grandes, debugging de problemas difíciles de reproducir o implementación de funcionalidades que afectan múltiples partes del sistema simultáneamente. ## Cuándo elegir Claude Code sobre otras opciones Claude Code no compite directamente con Lovable o Bolt porque está orientado a un perfil de usuario diferente. Es más poderoso pero también más exigente: requiere que el usuario sepa dirigirlo con precisión, entienda la estructura de su proyecto y pueda evaluar críticamente las propuestas que hace el agente. Si estás empezando, comienza con Lovable. Si ya tienes un proyecto en marcha y necesitas un colaborador técnico de alto nivel para tareas complejas, Claude Code es difícil de superar en calidad de razonamiento. > Claude Code es también la herramienta que usa el equipo de VibeCoders para construir y mantener esta misma plataforma. Lo que ves aquí fue en gran parte generado con su ayuda. ### Cursor URL: https://landing.vibecoders.la/tools/cursor El editor de código con IA más popular entre builders profesionales. Pros: Autocompletado y generación de código contextual con acceso completo al proyecto · Modo Agent que implementa funcionalidades completas con mínima supervisión · Compatible con cualquier framework, lenguaje y stack tecnológico · Plan gratuito generoso con 2000 completions al mes Contras: Requiere comodidad básica con archivos de código y terminales · La curva de aprendizaje inicial es mayor que en constructores no-code Ideal para: Builders que quieren control total sobre el código de su producto · Proyectos que requieren integraciones técnicas específicas · Personas que ya tienen experiencia básica con algún lenguaje de programación ## El editor preferido de la comunidad builder Cursor es un fork de VS Code que integra modelos de lenguaje directamente en el flujo de trabajo de desarrollo. A diferencia de los constructores no-code, Cursor no genera una aplicación completa desde cero: es un entorno donde tú tienes el código abierto y la IA actúa como un colaborador que puede leer, entender y modificar cualquier parte del proyecto. La característica más poderosa de Cursor es el modo Agent: en lugar de sugerir cambios línea por línea, el agente analiza el contexto completo del proyecto, planifica los pasos necesarios y ejecuta una secuencia de modificaciones de forma autónoma. El resultado es que puedes pedir "agrega autenticación con Google y actualiza el navbar para mostrar el avatar del usuario" y Cursor lo implementa en varios archivos de forma coherente. ## Para quién es ideal Cursor es la herramienta correcta cuando ya superaste la fase de validación inicial y estás construyendo un producto que necesita durabilidad técnica. Si tu app tiene que escalar, integrarse con APIs externas complejas o seguir convenciones de código específicas, Cursor te da el control que los constructores no-code no ofrecen. El plan gratuito es genuinamente útil para proyectos pequeños o para aprender. El plan Pro de $20/mes es imprescindible si lo usas diariamente como herramienta principal de trabajo. > Cursor tiene una comunidad muy activa en Reddit y Discord donde comparten prompts, workflows y configuraciones. Explorar esos recursos acelera mucho el aprendizaje inicial. ### Lovable URL: https://landing.vibecoders.la/tools/lovable Construye aplicaciones web completas describiendo lo que quieres en lenguaje natural. Pros: Genera aplicaciones completas con frontend y backend integrado en minutos · Interfaz de chat intuitiva, sin necesidad de conocimiento técnico previo · Integración nativa con Supabase para base de datos y autenticación · Permite editar el código generado directamente en GitHub Contras: El plan gratuito tiene un límite de mensajes diarios que se agota rápido · Proyectos complejos con lógica de negocio específica requieren muchas iteraciones Ideal para: Fundadores no técnicos que quieren validar una idea rápidamente · MVPs de aplicaciones SaaS con autenticación y base de datos · Personas que están aprendiendo vibe coding por primera vez ## La puerta de entrada al vibe coding Lovable es probablemente la herramienta que más personas han usado para dar sus primeros pasos en vibe coding. La razón es simple: el tiempo desde "tengo una idea" hasta "tengo algo funcionando en el navegador" puede ser de menos de 30 minutos, sin escribir una sola línea de código manualmente. La plataforma genera aplicaciones web completas con React en el frontend y Supabase como backend. El flujo de trabajo consiste en describir lo que quieres construir en un chat, revisar el resultado en tiempo real y continuar iterando mediante prompts adicionales. Lo que diferencia a Lovable de otras herramientas similares es la calidad del código que genera y la profundidad de la integración con Supabase, que incluye configuración automática de tablas, autenticación de usuarios y reglas de seguridad. ## Limitaciones a considerar El principal punto débil de Lovable es el plan gratuito: tiene un límite de mensajes que se agota con rapidez si estás iterando activamente. Para proyectos en desarrollo real, el plan de pago es prácticamente necesario. Además, cuando los requisitos del producto se vuelven muy específicos o la lógica de negocio es compleja, puede ser más eficiente migrar a un editor con IA como Cursor para tener mayor control sobre la implementación. > Lovable es la mejor opción para empezar. Cuando hayas validado tu idea y necesites más control, la combinación con Cursor o Claude Code es la evolución natural. ### v0 URL: https://landing.vibecoders.la/tools/v0 Genera componentes de interfaz de usuario desde descripciones en texto. Pros: Genera componentes React con Tailwind CSS listos para copiar y usar · Resultados visuales de alta calidad basados en shadcn/ui · Ideal para construir interfaces sin depender de un diseñador Contras: Enfocado en componentes individuales, no en aplicaciones completas · El código generado puede requerir ajustes para integrarse en proyectos con convenciones propias Ideal para: Builders que necesitan componentes de UI de calidad sin diseñador · Prototipado rápido de interfaces para presentaciones o demos · Complementar proyectos de Cursor o Lovable con componentes visuales puntuales ## El diseñador IA de Vercel v0 es una herramienta de Vercel especializada en la generación de componentes de interfaz de usuario. A diferencia de Lovable o Bolt, no genera aplicaciones completas: su enfoque es producir componentes individuales — tablas, formularios, dashboards, navbars, tarjetas — en React con Tailwind CSS y basados en la biblioteca shadcn/ui. El flujo de trabajo es sencillo: describes el componente que necesitas, v0 genera varias variantes, eliges la que más se acerca a tu visión y la copias directamente a tu proyecto. El código generado es limpio, semántico y sigue convenciones modernas, lo que facilita la integración en proyectos existentes. ## El complemento perfecto para otros flujos v0 funciona mejor como complemento de otras herramientas, no como herramienta principal. Cuando estás construyendo en Cursor o en Lovable y necesitas un componente visual específico que la IA de esas plataformas no genera con la calidad que esperas, v0 es la solución natural. El plan gratuito es suficiente para uso ocasional. Si generas muchos componentes regularmente, el plan de pago elimina las restricciones de uso mensual. > Muchos builders tienen v0 siempre abierto en una pestaña del navegador mientras trabajan en su proyecto principal. Es el equivalente digital de "preguntarle al diseñador" algo rápido.