Base: anatomía del loop|INEMA.CLUB-PRO

Clase 8 · 20 min

Tu primer loop: objetivo pequeño con criterio nivel 3

Es hora de juntar las piezas en un loop de verdad, pequeño a propósito: una función para contar palabras, seis tests congelados con hash y una condición de /goal nivel 3 con tope de turnos. Lo bastante pequeño para terminar en minutos; lo bastante completo para tener las cinco piezas. Al final, el mapa de la formación y tu plan con fechas.

Empezar la lección
Una placa de circuito pequeña sobre una mesa oscura, con un cable fino cerrando un lazo alrededor de ella.

En esta lección vas a

  1. 1Montar el proyecto con tests congelados y hash
  2. 2Escribir la condición del /goal en el nivel 3, con tope
  3. 3Verificar por tu cuenta, sin creer en el resumen
  4. 4El mapa de los seis cursos y tu plan con fechas

Objetivo: correr tu primer loop con /goal en un proyecto pequeño, con tests congelados, criterio nivel 3 y tope de turnos, y salir con el plan de la formación.

01Lo que montaste en este curso

Cuatro entregas que se vuelven tu primer loop. Haz clic en un ejercicio para ver el "listo cuando".

Clase 1Piezas

objetivo, estado, acción, verificación, parada

3 ejercicios

Un loop que se detiene por el test o por el tope.

Ver la clase
Clase 5Estado

archivos y git

3 ejercicios

Ciclo descartable que retoma sin rehacer.

Ver la clase
Clase 6Criterio

escala 0–4

3 ejercicios

Criterio nivel 3 que corre y traba el atajo.

Ver la clase
Clase 7Topes

turnos, tiempo, memoria, estancamiento, costo

3 ejercicios

Loop que se detiene solo cuando se atasca.

Ver la clase
Al final del curso 0Un loop pequeño corriendo con las cinco piezas, criterio nivel 3 y tope, y el vocabulario de los otros cinco cursos.
24 ejercicios
Haz clic en un ejercicio para ver qué hacer y el "listo cuando".
  1. 1/5

    Piezas

    El esqueleto: las cinco piezas en un lazo de bash, con dos puertas de salida y un código de salida distinto para cada una.

  2. 2/5

    Estado

    La memoria fuera del modelo: lista con passes, progreso y un commit por ítem verificado.

  3. 3/5

    Criterio

    La verificación que no se burla: comando, conteo mínimo y archivo congelado.

  4. 4/5

    Topes

    La puerta de seguridad: cada tope atrapa una forma en que el loop no termina, y la puerta humana atrapa lo que no se puede hacer sin ti.

  5. 5/5

    Las cuatro entregas juntas

    Piezas, estado, criterio y topes son lo que usas a continuación. El resto de las clases (harness, motores, LOOP-R) dice dónde vive cada pieza y qué curso la profundiza.

Los ejercicios de las clases 2, 3 y 4 entran en el plan de abajo.

02El proyecto del primer loop

Una carpeta, un archivo de pruebas congelado por hash y ninguna línea de la función. Quien escribe la función es el agente.

Terminal · crear la carpeta y congelar las pruebas
mkdir -p ~/ensaio-loop/conta/tests && cd ~/ensaio-loop/conta && git init -q
# pega el archivo de pruebas del próximo bloque en tests/test_conta.py, después:
sha256sum tests/test_conta.py > tests.sha256
git add -A && git commit -qm "testes congelados"
python3 -m pytest -q -p no:cacheprovider tests/ | tail -1   # todavía falla: conta.py no existe
tests/test_conta.py
from conta import conta_palavras


def test_vazio():
    assert conta_palavras("") == 0


def test_uma():
    assert conta_palavras("loop") == 1


def test_espacos_repetidos():
    assert conta_palavras("  o   loop  para ") == 3


def test_quebra_de_linha_e_tab():
    assert conta_palavras("objetivo\nestado\tação") == 3


def test_pontuacao_nao_e_palavra():
    assert conta_palavras("pronto , quando - passa") == 3


def test_acentos():
    assert conta_palavras("verificação e parada") == 3
Claude Code · la condición del /goal (nivel 3, con tope)
/goal python3 -m pytest -q -p no:cacheprovider tests/ imprime 6 passed, sha256sum -c tests.sha256 imprime OK y git diff --exit-code -- tests/ sale con código 0, con las tres salidas impresas en la conversación, o detente después de 8 turnos
Terminal · tú lo verificas, sin creer en el resumen
cd ~/ensaio-loop/conta
python3 -m pytest -q -p no:cacheprovider tests/ | tail -1
sha256sum -c tests.sha256
git diff --exit-code -- tests/; echo "rc=$?"
loop-codex.sh · el mismo loop con codex exec (ejercicio 3)
#!/usr/bin/env bash
# Laço seu: no máximo 3 ciclos de codex exec; quem decide parar são os três comandos.
set -u
cd ~/ensaio-loop/conta
passes() {
  python3 -m pytest -q -p no:cacheprovider tests/ 2>&1 | tail -1 | grep -q '^6 passed' &&
  sha256sum -c --quiet tests.sha256 &&
  git diff --quiet -- tests/
}
for ciclo in 1 2 3; do
  if passes; then echo "PRONTO no ciclo $((ciclo - 1))"; exit 0; fi
  echo "ciclo $ciclo: codex exec"
  timeout 15m codex exec --sandbox workspace-write \
    "Crie conta.py com conta_palavras(texto) que faça os testes de tests/ passarem. Não altere nada em tests/."
done
if passes; then echo "PRONTO no ciclo 3"; exit 0; fi
echo "PARADO: teto de 3 ciclos"; exit 2
Ejemplo del repositorio

Con la misma condición, en modo sin interfaz (claude -p "/goal …"), el agente escribió conta.py y terminó imprimiendo:

- python3 -m pytest -q -p no:cacheprovider tests/ → 6 passed in 0.01s
- sha256sum -c tests.sha256 → tests/test_conta.py: OK
- git diff --exit-code -- tests/ → saiu com código 0

Su función y la tuya pueden ser diferentes; lo que tiene que coincidir son las tres salidas.

03Práctica

En tu máquina. El ejercicio 2 gasta poco de tu cuota.

E1 · El proyecto listo para el loop

10 min

Crea la carpeta, el archivo de pruebas, el hash y el primer commit. Corre pytest antes de que exista la función.

Listo cuando: sha256sum -c tests.sha256 → tests/test_conta.py: OK, git log --oneline | wc -l → 1, y pytest todavía falla (la función no existe).

E2 · El primer loop corriendo

15 min

Abre Claude Code en la carpeta y pega la condición del /goal. Déjalo correr sin interferir; si Claude pide permiso para correr pytest, apruébalo.

Listo cuando: El estado del goal muestra la condición alcanzada, y los tres comandos de verificación, corridos por ti, dan 6 passed, tests/test_conta.py: OK y rc=0.

E3 · El mismo loop con Codex

15 min

Borra conta.py y ejecuta el mismo pedido con codex exec con sandbox de escritura, usando el loop-codex.sh del bloque de arriba: máximo 3 ciclos, parando cuando los tres comandos pasan.

Listo cuando: Tu ciclo termina antes de la 3.ª vuelta, y los mismos tres comandos dan 6 passed, OK y rc=0; git diff --stat -- tests/ sale vacío.

04Genera tu plan con fechas

Elige la fecha de inicio y cuánto tiempo tienes por semana. El plan lista los ejercicios de las ocho clases en orden.

05Prueba de la lección

Pregunta 1 de 4

¿Por qué la condición del /goal pide "las tres salidas impresas en la conversación"?competencia

06En tres frases

Pequeño y completoEl primer loop tiene las cinco piezas en un problema que termina en minutos.
Congelar antes de soltarTests con hash y commit antes de que el agente empiece: es lo que hace que el criterio sea nivel 3.
Tú cierrasEl evaluador juzga la conversación; tú ejecutas la verificación en la máquina.

Para ir más allá

Clase anteriorVolver al inicio del curso