🧪 Loops para copiar y ejecutar

Este es el bucle más limpio para empezar: corregir las pruebas que fallan. El "listo" no depende de opiniones: o las pruebas pasan o no. El prompt de abajo está completo: abre un proyecto pequeño con alguna prueba rota y pégalo.

Objetivo: dejar que Claude Code se ejecute solo, en bucle, hasta que pase toda la suite, haciendo una corrección a la vez y deteniéndose al alcanzar el límite de intentos.

# Cole no Claude Code dentro de um projeto com testes falhando

Objetivo: faça todo teste em /tests passar ao rodar `npm test`.

Loop:
  (1) rode `npm test` e leia as falhas;
  (2) abra o arquivo mais responsável pela 1ª falha e faça UMA correção;
  (3) rode `npm test` de novo pra verificar;
  (4) se ainda falhar, repita do passo 1.

Depois de cada correção que melhora, escreva 1 linha em PROGRESS.md e commite.
Pare quando todos passarem ou após 10 tentativas.
Não edite nada fora de /src e /tests, e não apague testes pra fazê-los passar.

Cómo verificar: mira la terminal: deberías ver el ciclo ejecutar pruebas → editar 1 archivo → volver a ejecutarlas repitiéndose, con el número de fallas en descenso. Al final, ejecuta npm test tú mismo y comprueba que esté en verde; abre el PROGRESS.md y el git log para ver el rastro de cada vuelta.

El loop no es cosa de programadores. La misma forma sirve para el texto. Solo cambiamos el trabajo y la forma de comprobarlo: el objetivo pasa a ser "reescribir este párrafo", y "listo" se convierte en dos reglas objetivas que se pueden contar.

Objetivo: acortar un párrafo hasta que cumpla dos reglas medibles, iterando por su cuenta hasta lograrlo (o detenerse en 5 intentos).

# Cole no Claude Code (ou em qualquer chat com ferramentas de contagem)

Objetivo: reescreva o parágrafo abaixo.

Pronto quando: o texto está abaixo de 50 palavras E menciona a palavra "preço".

Loop:
  (1) reescreva uma versão;
  (2) conte as palavras e procure "preço";
  (3) se quebrar alguma regra, reescreva de novo mirando o que faltou;
  (4) repita.

Pare quando as duas regras passarem, ou após 5 tentativas.

Parágrafo:
<parágrafo que você cola aqui>

Cómo verificar: pide el recuento final de palabras (debe ser < 50) y busca "precio" en el resultado. Fíjate: el check verifica las reglas, no si el texto quedó agradable de leer: eso es exactamente un check Functional. Si también quieres elegancia, agregarías un segundo evaluador (tema 6).

En vez de escribir el loop a mano cada vez, puedes declarar el objetivo y dejar que Claude Code arme el ciclo. /goal dice adónde llegar; /loop lo hace girar hasta llegar allí. Juntos forman un loop autodirigido que sabe cuándo detenerse.

Objetivo: generar y refinar conceptos de thumbnail hasta que uno alcance la nota objetivo en una rúbrica que tú mismo defines.

# Cole no Claude Code

/goal Gerar 10 conceitos de thumbnail para um vídeo sobre <seu tema>.
      Pontue cada conceito de 0 a 10 em três critérios:
        - clareza (dá pra entender o tema em 1 segundo)
        - contraste (cores e formas saltam num feed)
        - curiosidade (dá vontade de clicar)
      A nota do conceito é a média dos três.
      Pronto quando o melhor conceito atingir nota média >= <8>.

/loop A cada volta: pegue o conceito de maior nota, descreva 2 variações
      dele mirando o critério mais fraco, pontue as variações pela mesma
      rubrica e mantenha a melhor. Pare quando bater a nota-alvo ou após
      8 voltas. Mostre a tabela de notas no fim.

Cómo verificar: al final debe aparecer una tabla con cada concepto y sus tres calificaciones, y el ganador con promedio ≥ 8 (o un aviso de que se detuvo en el límite sin alcanzarlo). Verifica tú si la rúbrica se aplicó de manera consistente: si dos thumbnails parecidas obtuvieron calificaciones muy diferentes, precisa la descripción de los criterios.

Cuando el loop puede tocar algo difícil de deshacer — borrar archivos, enviar un correo electrónico, hacer un pago — no quieres que decida por sí solo. Agrega un gate humano: una línea que obliga al agente a detenerse y pedir tu confirmación antes de cualquier acción irreversible.

Objetivo: ejecutar un loop normalmente, pero con un freno que impida cualquier acción destructiva o externa sin tu aprobación explícita.

# Acrescente esta linha a QUALQUER prompt de loop deste módulo

Pause e me pergunte antes de deletar, enviar ou pagar qualquer coisa.

# (opcional, deixa o gate mais explícito)
Trate como irreversível: apagar/sobrescrever arquivos fora de /src,
fazer git push, enviar e-mail/mensagem, ou qualquer pagamento.
Nesses casos, descreva o que faria e espere meu "ok" antes de agir.

Cómo verificar: ejecuta el loop sobre una tarea que naturalmente llegue a una acción arriesgada (ej.: limpiar una carpeta). El agente debe detente y pregunta en vez de ejecutar: si borra algo sin consultarte, el gate no funcionó; especifica mejor la lista de acciones irreversibles y vuelve a probar en un directorio de prueba.

Las tareas grandes no caben en una sola pasada. La solución es darle al bucle un lugar para guardar el estado: un archivo de progreso que lee al comienzo y actualiza al final de cada vuelta, más un commit por cambio. Así, si la sesión termina, la siguiente retoma desde donde quedó.

Objetivo: ejecutar un loop largo que avance una funcionalidad a la vez, guardando el estado en cada vuelta para poder interrumpirlo y retomarlo sin perder trabajo.

# Cole no Claude Code num repositório git

Objetivo: implementar <a feature/lista de tarefas> até estar completa e testada.

No início de cada volta:
  - leia PROGRESS.md para saber o que já foi feito e o que vem a seguir.

Durante a volta:
  - escolha a PRÓXIMA tarefa não-feita e trabalhe SÓ nela (uma de cada vez);
  - rode os testes para verificar a mudança (self-verify);
  - se passou: atualize PROGRESS.md (marque a tarefa, anote 1 linha do que fez)
    e faça um commit com uma mensagem curta e clara;
  - deixe a árvore de trabalho limpa (sem arquivos soltos) para a próxima volta.

Pare quando PROGRESS.md não tiver mais tarefas, ou após 15 voltas.

Cómo verificar: abre el PROGRESS.md y mira cómo crece el historial línea a línea; ejecuta git log --oneline y revisa un commit por cambio. La prueba de fuego: interrumpe el bucle a la mitad, inicia una sesión nueva con el mismo prompt y comprueba si retoma desde la tarea correcta en vez de empezar de cero.

Todos los prompts de este módulo son el mismo esqueleto con piezas intercambiadas. Para TU tarea, mantén la forma del loop y cambia solo dos cosas: el dominio (qué trabajo) y el checker (cómo medir "listo").

Qué ver: el flujo siempre es copiar → pegar → ejecutar → observar. Lo que cambia de una tarea a otra no es la mecánica, sino los campos <entre setas>: el objetivo, qué cuenta como listo y el límite.

Los tres tipos de checker que vas a cambiar según la tarea:

Objetivo: tener una plantilla en blanco para completar con tu tarea — solo cambia los campos marcados <assim> y pega.

# Template em branco — preencha os campos <entre setas> e cole no Claude Code

Objetivo: <o que produzir, numa frase>.
Pronto quando: <o critério checável de "pronto">.

Loop:
  (1) faça UMA mudança em direção ao objetivo;
  (2) rode o check: <como medir — testes / contar / screenshot / 2º agente>;
  (3) se não passou, ajuste mirando o que faltou;
  (4) repita.

Salve o progresso: <ex.: 1 linha em PROGRESS.md + commit a cada melhora>.
Pare quando passar, ou após <N> tentativas.
Não toque em <o que está fora de escopo>; pause e me pergunte antes de
qualquer ação irreversível.

Cómo verificar: si lograste completar los cuatro campos sin dudar — objetivo, criterio de finalización, qué checker y el límite — tu tarea está lista para convertirse en un loop. Si te atascaste en «Está listo cuando», el problema no es el prompt: es que la tarea todavía no tiene un «listo» verificable (vuelve al módulo 3.1, paso 2).