¿Qué pasaría si pudieras describir un videojuego en lenguaje natural, presionar enter, y ver a un agente de IA escribir y depurar código en C hasta que algo jugable apareciera en tu terminal?
Sí se puede, y te alcanza con una tarde. Con una CLI de IA, un compilador de C y la librería ncurses, puedes construir un juego de bloques cayentes inspirado en Tetris que corre directamente en tu terminal, en una sola sesión. No necesitas ser programador de C para empezar, y yo tampoco lo era: mi propio tetris.c, escrito a mano, nunca pasó del compilador, y justo ahí empieza de verdad este proyecto. Al final te quedas con tres cosas que vale la pena tener: un binario que compilaste tú, un código en C legible que puedes desarmar línea por línea, y un flujo de trabajo que puedes reutilizar en la siguiente idea que se te ocurra.
Eso es exactamente lo que esta guía te enseña a hacer.
Actualización, agosto de 2026. Este post documenta una sesión que corrí en febrero de 2026 con Gemini CLI. En el Google I/O del 19 de mayo de 2026, Google anunció que está consolidando sus herramientas de desarrollo bajo la marca Antigravity y retirando Gemini CLI, y el 18 de junio de 2026 Gemini CLI dejó de responder peticiones para usuarios gratuitos y para suscriptores de Google AI Pro y Ultra. Las organizaciones con licencia de Gemini Code Assist Standard o Enterprise no se ven afectadas. El sucesor es Antigravity CLI, y el Paso 1 te da su comando de instalación actual. Dejé el resto del post tal como ocurrió, porque lo que se transfiere a la herramienta nueva es el flujo de trabajo, no el binario específico.
Un juego que cambió la historia#
En 1984, un científico soviético llamado Alexey Pajitnov se sentó frente a una Electronika 60 y escribió un programa en Pascal. La idea era elegante: siete piezas geométricas caen desde arriba de la pantalla, las rotas y las acomodas para completar filas, y las filas completas desaparecen. Lo llamó Tetris.
Ese programa se convirtió en uno de los juegos más jugados de la historia, distribuido en prácticamente todas las plataformas imaginables durante cuatro décadas. Aunque la idea se describe en una frase, construir siquiera un clon funcional en aquella época implicaba dominar ciclos de tiempo, renderizado en terminal, matemáticas de rotación y horas de debugging paciente. Era trabajo de ingeniería real, con todo lo que eso implica.
Hoy puedes pedirle a un agente de IA que produzca el código C equivalente en una sola sesión. Ese contraste es el verdadero tema de este proyecto: cuarenta años de avance tecnológico, comprimidos en una conversación con un agente.
Sí puedes construir esto. Las mecánicas de los juegos de bloques cayentes (las formas de las piezas, la gravedad, la lógica de limpieza de filas) no tienen protección de derechos de autor. Lo que hace que Tetris sea Tetris como marca (el nombre registrado, el logo, la música Korobeiniki) pertenece a The Tetris Company. Lo que construyes aquí es un clon independiente con fines educativos, y el valor de ingeniería es exactamente el mismo.
Dónde empezó realmente este proyecto#
Antes de ser una guía, esto fue un archivo que no compilaba.
En ese momento estaba aprendiendo C, así que escribí mi propio tetris.c a mano. No compiló, y después de un rato viendo los errores seguía sin entender por qué. Mi primer impulso no fue borrarlo y dejar que un agente empezara de cero, fue pedir un diagnóstico, así que abrí Gemini CLI en esa carpeta y escribí exactamente esto:
hi, I was trying to do the tetris game but coul not compile it. Could you please check the code for any errors? @tetris.cTal cual, con todo y errores de dedo. En español sería algo como “hola, estaba intentando hacer el juego de tetris pero no pude compilarlo. ¿Puedes revisar el código por si tiene errores?”. El @tetris.c del final es la forma en que Gemini CLI carga un archivo a la conversación, así que el agente leyó mi código real y no una descripción de él.
La revisión fue honesta, y no fue la respuesta que esperaba: el archivo era un desastre. Yo mismo lo acepté en mi siguiente mensaje. Catorce minutos después de pedir una revisión de código, borré mi intento y le pedí al agente que empezara desde cero.
Vale la pena nombrar esa decisión, porque es un criterio que los ingenieros usamos todo el tiempo y del que casi no hablamos: saber cuándo seguir reparando un borrador y cuándo una reescritura limpia es simplemente el camino más rápido. Si vas a empezar este proyecto con un intento fallido propio, no estás atrasado. Estás justo donde yo estaba.
Lo que necesitas#
- Una terminal de Linux o WSL2 en Windows 11
- GCC (el compilador de C):
sudo apt install gcc - La librería de desarrollo de ncurses:
sudo apt install libncurses-dev - Un agente de IA en la terminal: hoy Antigravity CLI, y Gemini CLI en la sesión que describe este post
- Una cuenta para autenticar el agente en el primer arranque (Gemini CLI pedía una cuenta de Google gratuita; sigue el flujo de inicio de sesión que te pida tu herramienta)
ncurses es lo que hace que una terminal se comporte como una pantalla y no como un log que se desplaza. Te da posicionamiento del cursor, lectura del teclado sin esperar a que se presione enter, y pares de color, que es justo lo que necesita un juego de bloques cayentes y nada más.
Si es la primera vez que configuras WSL2, los primeros pasos de mi post sobre cómo desplegar una IA privada con Ollama cubren todo el proceso de instalación.
Paso 1: Instala un agente de IA en la terminal#
La herramienta actual es Antigravity CLI, el sucesor de Gemini CLI. Está reescrito en Go y puede correr varios agentes en paralelo en segundo plano. Se instala con un solo script.
En macOS, Linux o WSL:
curl -fsSL https://antigravity.google/cli/install.sh | bashEn Windows, desde PowerShell:
irm https://antigravity.google/cli/install.ps1 | iexDespués sigue las instrucciones de primer arranque de la propia herramienta para autenticarte.
Para dejarlo asentado, y no como un paso a seguir, el agente que usé en febrero de 2026 fue Gemini CLI, corriendo sobre Gemini 2.5 Pro. El log de esa sesión no guarda el modelo, pero todas las sesiones de Gemini CLI de esa época en mi máquina corrieron con Gemini 2.5, y otras cuatro sesiones de ese mismo día quedaron registradas con 2.5 Pro. En aquel entonces la CLI a veces caía en Gemini 2.5 Flash, así que tómalo como el modelo que la herramienta me estaba sirviendo en ese momento y no como un dato que pueda señalar en el registro.
Gemini CLI se distribuía como un paquete npm y necesitaba Node.js 18 o posterior:
npm install -g @google/gemini-cli # retirado el 18 de junio de 2026
geminiEn aquel momento bastaba con iniciar sesión con una cuenta de Google gratuita. Ese es justo el camino que dejó de funcionar, así que si tienes abierto un tutorial más viejo en otra pestaña, esta es la razón por la que no te responde nada.
En cualquiera de los dos casos, terminas en una sesión interactiva con el agente dentro de la terminal. Funciona como un chat con manos: describes lo que quieres, y el agente razona, escribe el código y ejecuta comandos en tu nombre.
Paso 2: Pide el juego#
Este es el prompt que produjo el juego completo. Es una sola frase, y la cito tal como la escribí:
thank you but you are right, this code was a mess. Could you create the tetris game in c instead? I deleted the previous file so please start overEn español: “gracias, pero tienes razón, este código era un desastre. ¿Podrías crear el juego de tetris en C mejor? Borré el archivo anterior, así que empieza desde cero”.
Esa es toda la especificación. No mencioné ninguna librería, ni el tamaño del tablero, ni el esquema de controles, ni la regla de puntaje, ni el comando de compilación. Lo que regresó fue un solo archivo de C de 234 líneas, escrito y compilado por el propio agente, y cada decisión de diseño de esta lista es suya, no mía:
- ncurses como capa de renderizado, un solo archivo con
#include <ncurses.h>, enlazado con-lncurses. - Un tablero de 10 por 20 (
BOARD_WIDTH 10,BOARD_HEIGHT 20) con bordes dibujados con|y-. - Las siete piezas con sus cuatro estados de rotación, guardadas en una sola tabla
const int PIECES[7][4][4][4]en lugar de calcular las rotaciones. - Controles con flechas: izquierda y derecha para mover, arriba para rotar en sentido horario con
(rotation + 1) % 4, abajo para caída suave, yqoQpara salir. - Siete pares de color con
init_pair(), uno por pieza: cian, amarillo, magenta, verde, rojo, azul y blanco. - Gravedad de intervalo fijo: el ciclo principal duerme 20 ms por vuelta y baja la pieza cuando su contador pasa de 20, o sea alrededor de 400 ms por fila, y nunca acelera.
- Puntaje cuadrático:
score += lines_cleared * lines_cleared * 100, así que limpiar cuatro filas de un solo golpe vale 4 × 4 × 100 = 1,600 puntos, contra los 4 × 100 = 400 que juntarías limpiándolas de una en una.
Son buenos valores por defecto, y ahí está lo verdaderamente interesante. ncurses es la opción natural para un juego de terminal, 10 por 20 es el tablero estándar, las flechas son lo primero que va a apretar cualquier jugador, y premiar las limpiezas múltiples es lo que le da al juego su tensión de riesgo y recompensa. Una petición de una línea aterrizó en convenciones que a mí me habría tomado un rato investigar.
Aun así, el trade-off existe y va en una sola dirección: todo lo que no especifiques lo decide el agente por ti, y lo decide en silencio. Mi propio juego es la prueba. La gravedad nunca acelera, así que no hay curva de dificultad, y tampoco hay panel de siguiente pieza ni mecánica de hold. Nada de eso es un error. Simplemente son cosas que nunca pedí.
Entonces la regla práctica no es “sé específico o va a fallar”, porque aquí la vaguedad claramente no falló. Es esta otra: sé específico en lo que de verdad te importa. Si quieres un tablero más ancho, controles WASD, wall kicks al rotar o una velocidad que suba con el puntaje, nómbralos en el prompt. Agregar el comando de compilación y una línea como “asegúrate de que compile y corra” también ayuda, porque convierte una tarea de generación de texto en una tarea verificable. Todo lo demás lo puedes delegar con tranquilidad.
Sea lo que sea que decidas especificar, envía el prompt y deja que el agente trabaje.
Paso 3: Observa el ciclo de depuración#
Esta es la parte que vale la pena ver con atención. Gemini CLI no te entrega un bloque de texto para que tú lo pegues en algún lado. Escribió tetris.c directamente en la carpeta del proyecto y ahí mismo lo compiló, y cuando terminó la sesión el binario ya estaba junto al código fuente. La unidad de trabajo es un programa que corre, no un fragmento que todavía tienes que armar.
El ciclo que sí puedo documentar a detalle es el primero, el que corrió sobre mi archivo roto. Le di al agente código que no compilaba, leyó el archivo real, me explicó qué estaba mal, y la conclusión a la que llegamos fue que reescribir me iba a dejar con un juego funcional más rápido que reparar. Ese es el mismo ciclo que hace cualquier desarrollador: leer la falla, razonar la causa, comparar el arreglo contra el rediseño, y actuar. La diferencia es que todo eso ocurrió en minutos, no a lo largo de una noche entera.
Cuántos intentos necesitó el agente en su propia reescritura, honestamente no te lo puedo decir, porque mi log solo guarda mi lado de la conversación. Lo que sí te puedo decir es lo que quedó en disco: un archivo de C autocontenido que compila limpio con gcc tetris.c -o tetris -lncurses y un juego que se puede jugar.
Lo que sí puedo medir con precisión es el reloj, que además es el número que casi todos quieren cuando preguntan para qué sirve un agente. Desde mi primer prompt hasta tener un binario compilado y jugable pasaron 24 minutos con 44 segundos. La reescritura por sí sola, desde el mensaje de “empieza desde cero” hasta un programa que corría, tomó 11 minutos con 19 segundos, y el binario apareció quince segundos después que el archivo fuente. Esas cifras salen de evidencia y no de mi memoria: las dos marcas de tiempo de los prompts están en el log de Gemini CLI, en ~/.gemini/tmp/<hash>/logs.json (06:35:59 y 06:49:24 UTC), y las otras dos son las fechas de modificación de tetris.c (07:00:28) y del binario que quedó junto a él (07:00:43). El log trabaja en UTC y mi máquina iba ocho horas atrás, y por eso el log dice 2 de febrero mientras que este post está fechado la noche del 1 de febrero. Así que te puedo decir exactamente cuánto tardó sin poder decirte cuántos intentos le costó, y las dos mitades de esa frase vale la pena decirlas en voz alta.
Además, leer el código que regresa es una de las formas más directas de aprender C y ncurses. Seguir cómo is_valid_position() valida cada movimiento, cómo place_piece() recorre las filas hacia abajo después de una limpieza, y cómo los pares de color se amarran al tipo de pieza enseña más que un capítulo de sintaxis, y el aprendizaje ocurre como consecuencia natural de construir el proyecto. Si quieres leer el archivo completo antes de escribir una sola línea propia, lo que salió de esa sesión es público en EmilianFC20/tetris-in-c con licencia MIT, subido tal cual lo produjo el agente y sin pulir a propósito. El binario compilado no está ahí, y es a propósito también: compilarlo te toca a ti.
Aunque el ciclo sea rápido, el ingeniero del cuarto sigues siendo tú. El trabajo del agente es producir un candidato. El tuyo es leerlo, correrlo y decidir si realmente hace lo que pediste.
Paso 4: Compila y juega#
En mi sesión el agente ya había escrito tetris.c y lo había compilado antes de regresarme el trabajo, así que no quedaba nada por construir. Si tu agente se detiene en el archivo fuente, o si estás haciendo esto a mano, este es el comando:
gcc tetris.c -o tetris -lncursesEl flag -lncurses es el que siempre se olvida. Le indica al linker que enlace tu programa contra la librería de ncurses, y sin él el código compila sin problema y luego truena en la etapa de enlazado con referencias indefinidas a funciones como initscr.
Si el compilador no encuentra ncurses.h, instala primero los headers de desarrollo:
sudo apt install libncurses-devLuego corre el juego:
./tetris
Controles:
| Tecla | Acción |
|---|---|
| ← / → | Mover pieza a la izquierda o derecha |
| ↑ | Rotar pieza en sentido horario |
| ↓ | Caída suave (descenso más rápido) |
| q | Salir |
El puntaje se calcula por filas eliminadas en cada colocación. Limpiar varias filas en un solo movimiento vale mucho más que limpiarlas de una en una, así que conviene armar el tablero a propósito para hacer limpiezas múltiples en lugar de soltar las piezas donde vayan cayendo.
Lo que ganas al construirlo#
Cuando ese juego aparece en tu terminal por primera vez, hay un momento de satisfacción genuina. Describiste algo, y apareció software funcionando.
Debajo de ese momento te quedan tres cosas concretas. La primera, un programa que armaste y compilaste tú, que se siente muy distinto a descargar el binario de alguien más. La segunda, un código en C completo y autocontenido que puedes leer como material de estudio: el estado del juego, el ciclo de entrada, el manejo del tiempo, la lógica de rotación y el renderizado en terminal, todo en un archivo lo bastante chico como para tenerlo entero en la cabeza. La tercera, un flujo de trabajo repetible, porque nada del proceso fue exclusivo de Tetris.
El mío está publicado en EmilianFC20/tetris-in-c por si quieres algo contra qué comparar el tuyo, o nada más leer las 234 líneas y ver hasta dónde llegó una sola frase en inglés.
Ese último punto es lo que convierte a los agentes de IA en la terminal en un multiplicador de capacidad real. No necesitas dominar la gestión de memoria en C, las APIs de renderizado en terminal ni las matrices de rotación antes de poder construir algo que funcione. En lugar de estudiar durante meses y después construir, puedes empezar por el resultado que quieres, leer el código generado para entender qué hace, y construir tu modelo mental del lenguaje de adentro hacia afuera. La distancia entre “tengo una idea” y “tengo un programa corriendo” nunca había sido tan corta.
Eso fue exactamente lo que encontré cuando construí este proyecto. Estaba aprendiendo C y explorando Gemini CLI al mismo tiempo, y la intersección resultó buena: una meta concreta, un lenguaje que apenas estaba aprendiendo, y un agente que podía hacer el primer borrador de la implementación mientras yo me enfocaba en entender lo que producía. Aunque el juego terminado es la parte que se puede jugar, del intento fallido fue de donde más aprendí. Escribir un archivo que no compilaba, escuchar una evaluación honesta de por qué, y elegir una reescritura limpia en lugar de un rescate me dijo mucho más sobre dónde estaba realmente mi C que cualquier programa funcionando. Cada tropiezo fue simplemente otra capa por entender, y otra oportunidad para seguir mejorando.
Eso sí, el contraste con 1984 vale la pena tenerlo presente. El trabajo de Pajitnov representa un nivel de dedicación y oficio que merece respeto genuino, y lo que ofrecen los agentes de IA no es un reemplazo para esa profundidad. Es una rampa de entrada más rápida al punto donde puedes empezar a construir comprensión propia y real.
¿Qué sigue?#
Una vez que tu juego esté corriendo, hay varios caminos que vale la pena explorar:
- Dificultad progresiva: aumentar la velocidad de caída conforme sube el puntaje, para que el juego rete al jugador a seguir mejorando.
- Panel de siguiente pieza: mostrar un panel lateral con la pieza que viene para que el jugador pueda planear con anticipación.
- Mecánica de hold: dejar que el jugador guarde una pieza y la intercambie más adelante.
- Puntaje máximo persistente: guardar el mejor puntaje en un archivo y mostrarlo al iniciar.
- Renderizado gráfico con SDL2: reemplazar ncurses con SDL2 para un juego en ventana con gráficos reales y sonido.
Cada una de estas ideas es también un buen segundo ejercicio del mismo flujo: describe el cambio con precisión, deja que el agente lo redacte, y lee lo que regresó antes de aceptarlo.
Si construyes tu propia versión de esto, me encantaría saber qué extendiste o cambiaste.
Tetris® es una marca registrada de The Tetris Company, LLC. Este proyecto es una reimplementación educativa e independiente de la mecánica de bloques cayentes y no tiene afiliación ni respaldo de The Tetris Company.