ComunidadBóvedaLas 5 reglas del equipo de Claude Code

Claude Code · verificación · noviembre 2026

Las 5 reglas del equipo de Claude Code

El equipo que hace Claude Code deja que Claude escriba casi todo su código y no se les rompe. Estas son sus cinco reglas para que Claude pruebe lo que hizo antes de entregarlo, listas para copiar.

En corto

Claude no termina cuando dice “listo”. Termina cuando lo probó y te enseña cómo.

Una skill que abre tu app y la usa como persona, pruebas que te dicen en qué paso se rompió, un límite de tres intentos antes de llamarte, un examen que el cambio no puede editar y una nota en cada commit con cómo se comprobó. Cada regla trae la línea para tu CLAUDE.md o el prompt para que Claude lo configure, y al final van las cinco en un solo paquete para descargar.

verificaciónclaude codepruebasskillsclaude.md

Ficha

Las 5 reglas del equipo de Claude Code

Qué necesitas
Claude Code (2.1.286 o más nuevo para que la skill verify corra sola antes de cada commit) y un proyecto con git
Dónde se hace
En tu proyecto: una skill en .claude/skills/, unas líneas en tu CLAUDE.md y un permiso
Código
No escribes nada a mano. Cada regla es un prompt que Claude configura y te enseña antes de guardar
Cuánto cuesta
Nada extra. Probar gasta algo de plan, y te ahorra las vueltas de arreglar lo que salió roto
Cuánto toma
Unos 30 minutos para dejar las cinco puestas

01 · La idea

Explicado como a un niño de 5 años

Imagina un niño que hace su tarea y él mismo se pone la calificación. Si además puede borrar las preguntas del examen y escribir otras más fáciles, siempre saca diez. Y no aprendió nada: arregló el examen.

Con Claude pasa algo parecido. Si lo dejas decir “listo” sin probar nada, o si puede cambiar la prueba que lo juzga, te va a entregar cosas rotas con mucha seguridad. No lo hace con mala intención: hace lo que le pediste, y le pediste que terminara.

El equipo que hace Claude Code vive eso en grande. Alrededor del 90% de su código lo escribe y lo revisa Claude. Addy Osmani contó en el blog de Claude (16 de noviembre de 2026) cómo le hacen para que no se rompa. Sin verificación, dicen, solo puedes tener uno o dos Claudes trabajando, porque tienes que revisar todo tú. Con verificación, decenas o cientos al mismo tiempo.

Las cinco, en una frase cada una

La regla

1 · Una skill verify

En una frase

Claude abre tu app y la usa como persona antes de guardar el cambio.

La regla

2 · Pruebas de punta a punta

En una frase

Si solo vas a tener un tipo de prueba, que use la app completa y diga en qué paso falló.

La regla

3 · Tres intentos y para

En una frase

Si después de tres rondas sigue fallando, Claude se detiene y te llama.

La regla

4 · No tocar el examen

En una frase

Un cambio nunca puede editar la prueba que lo juzga.

La regla

5 · Sello en cada commit

En una frase

Cada cambio guardado dice cómo se comprobó, aunque diga “ninguna”.

Dos palabras que vas a ver mucho

Una prueba (test) es un pedacito de código que revisa que otro funcione, como un examen automático. Un commit es una foto guardada de tu proyecto en git, con una nota que dice qué cambió. Con eso ya entiendes toda la guía.

02 · Regla 1

Una skill que se llama verify

Una skill es un archivo de instrucciones que Claude lee cuando le toca hacer algo. La de verify le explica cómo arrancar tu app y cómo usarla como lo haría una persona: abrir la página, darle clic al botón, llenar el formulario y ver que salga lo que tiene que salir.

El equipo la guarda en la carpeta .claude/skills/ del repositorio, lo más cerca posible del código que prueba, y tiene tantas como haga falta. Así es como prueban casi todos los cambios dentro de Anthropic.

El detalle que casi nadie sabe

Si en tu proyecto hay una skill que se llama verify, tal cual,, Claude Code la corre solo justo antes de cada commit (menos cuando el cambio es nada más de documentación o de pruebas). Lo dice la documentación de skills y pide la versión 2.1.286 o más nueva. Tu skill reemplaza al /verify que ya trae Claude Code. Ojo: si le pones disable-model-invocation: true, Claude ya no la puede llamar y se pierde ese aviso.

Crea tu skill verify

Claude te entrevista primero, para que la skill sepa cómo se arranca tu app.

Crea una skill de proyecto en .claude/skills/verify/SKILL.md. Su trabajo: arrancar esta app y probar el cambio actual como lo haría un usuario, antes de cada commit.

Primero entrevístame: cómo se arranca la app, qué pantallas o endpoints son los importantes y qué significa que algo funcione.

Luego escribe la skill con los comandos exactos para arrancar, los pasos de prueba y qué evidencia tiene que enseñar al final (captura, respuesta o salida). No uses disable-model-invocation. No la guardes hasta que yo apruebe el texto.

Con qué usa tu app como persona

Tu app

Web

Con qué la prueba Claude

La extensión Claude in Chrome, Playwright o el protocolo de Chrome DevTools.

Tu app

Móvil

Con qué la prueba Claude

El simulador de iOS o Android, con su MCP.

Tu app

Escritorio

Con qué la prueba Claude

Computer use: Claude ve la pantalla y mueve el mouse.

Tu app

Backend o API

Con qué la prueba Claude

Arrancando el servicio en tu compu y mandándole peticiones de verdad.

Hazla rápida y confiable

El equipo la trata como su prueba de humo: la revisión rápida que dice si algo se quemó. Si falla por culpa de la skill y no de tu código, Claude aprende a no creerle. Por eso piden que Claude la mejore y la ponga a prueba hasta que sea sólida.

Ponla a prueba

Tres corridas seguidas sin tocar el código tienen que dar lo mismo.

Corre la skill verify tres veces seguidas sin cambiar nada del código. Si algún paso sale distinto entre corridas, es lento o depende de la suerte, arréglalo en la skill. Al final dime cuánto tarda cada corrida y qué cambiaste.

¿Y el /verify que ya viene instalado?

Claude Code trae uno que construye, corre y observa tu app. Para empezar está bien. La tuya gana por dos cosas: sabe cómo se arranca tu app en particular, y es la que se corre sola antes de cada commit.

El /verify instalado, explicado

03 · Regla 2

Si vas a tener un solo tipo de prueba, que sea de punta a punta

Una prueba de punta a punta (end-to-end, o e2e) usa tu app completa, como una persona: entra, hace clic, compra y revisa que todo salió bien. Una prueba unitaria revisa una pieza suelta, como una sola función.

Las unitarias son más rápidas y fallan menos al azar, pero las puedes pasar con la función completa rota, porque ni la prueba ni el agente ven la tarea entera. Las de punta a punta son difíciles de engañar: el flujo funciona o no funciona. Y cuando fallan, te pueden decir qué se rompió.

Prueba normal que falla

Error: Timeout after 30s

  1. 1No dice en qué paso fue.
  2. 2No hay captura ni rastro.
  3. 3Claude tiene que adivinar qué arreglar.

Prueba de punta a punta que falla

Captura, rastro y el paso exacto

  1. 1Captura de la página de pago: el formulario de pago no cargó.
  2. 2El rastro de cada paso hasta ahí.
  3. 3El paso que falló: el botón “Hacer pedido” se quedó desactivado porque el formulario nunca cargó.

Con eso Claude sabe qué arreglar sin adivinar. Pídelo así:

Pruebas de punta a punta con evidencia

Para el flujo más importante de tu app.

Escribe pruebas de punta a punta para el flujo principal de esta app (por ejemplo: registrarse, entrar y hacer la acción más importante). Usa la herramienta que ya tenga el proyecto o propón una.

Cuando una prueba falle, quiero tres cosas: captura de la pantalla en ese momento, el rastro de los pasos y una línea que diga qué paso se rompió y por qué.

Córrelas y enséñame el resultado.

El mapa de tu app

El equipo usa un mapa de funciones como guía y como hoja de calificación: cada función con su ruta, sus atajos, los elementos que se tocan y lo que se espera que pase. Claude lo lee para saber qué probar y para calificarse.

Arma el mapa

Un archivo que tu skill verify puede usar como lista.

Recorre el proyecto y arma un archivo docs/mapa-de-funciones.md con cada función que ve el usuario: dónde está (ruta o pantalla), cómo se llega, qué elemento se toca y qué debe pasar. Después agrega a la skill verify que use ese mapa como lista de lo que tiene que revisar cuando un cambio toque esa parte.

Dos trampas

Las pruebas que fallan a veces sí y a veces no le enseñan a Claude a correrlas otra vez en lugar de arreglar el código. Las pruebas lentas hacen que pruebe menos. Las pesadas, córrelas antes del commit, no después de cada cambio chiquito.

04 · Regla 3

Tres intentos y para

Nadie puede leer cada cambio, así que el equipo usa las fallas para decidir qué necesita a una persona. Claude corre las revisiones e intenta arreglar lo que falla. Si después de tres rondas sigue fallando, se detiene y llama a alguien.

¿Por qué parar? Porque si a la tercera no salió, lo más seguro es que Claude esté dando vueltas: cada intento nuevo gasta plan y puede ensuciar más el código. En ese punto tú, con dos minutos de contexto, le ahorras veinte de adivinar.

Pégalo en tu CLAUDE.md, el archivo que Claude lee al empezar cada sesión. Si no tienes uno, pídele a Claude que lo cree en la raíz del proyecto.

Para tu CLAUDE.md · cuando algo falla

Dos reglas: el tope de tres y qué hacer con las pruebas inestables.

## Cuando algo falla
- Si una prueba o revisión sigue fallando después de tres intentos de arreglo, detente. No sigas probando cosas distintas. Avísame con: qué falla, qué intentaste en cada ronda y qué crees que pasa.
- Si una prueba falla a veces sí y a veces no, no la saltes, no le agregues esperas (sleep) y no la corras hasta que pase. Busca la causa. Si no la encuentras, bórrala y escribe en el commit por qué.

La segunda línea es como tratan las pruebas inestables en el equipo: no se saltan, no se les ponen esperas y no se corren hasta que pasen. O se encuentra la causa, o se borra la prueba y queda escrito por qué.

Con /goal le pones meta y tope

Si trabajas con /goal, escribe el límite dentro de la meta: “todas las pruebas pasan, o detente si después de 3 intentos de arreglo siguen fallando”. El juez de /goal solo ve lo que Claude deja en la conversación, así que la meta tiene que pedir que corra las pruebas y enseñe el resultado.

Cómo escribir una meta de /goal

05 · Regla 4

Un cambio no puede tocar el examen

Esta es la que más cambia las cosas. Si Claude puede editar la prueba que juzga su cambio, siempre la va a pasar: borra la parte que falla o cambia lo que se espera. El examen deja de medir y tú te quedas con un verde que no significa nada.

En el equipo, las reglas que deciden si un cambio entra viven en un lugar que el cambio no puede modificar. Por ejemplo, su revisión de código lee sus reglas (el archivo REVIEW.md) de la rama principal, nunca de los cambios que está revisando.

Tú lo puedes armar en tres capas, de la más suave a la más dura:

  • Una regla en tu CLAUDE.md. Funciona casi siempre, pero es una petición.
  • La meta de /goal dice “sin modificar ningún archivo de pruebas”. El juez lo revisa antes de dar la meta por cumplida.
  • Un permiso que le prohíbe editar la carpeta de pruebas. Aquí ya no es petición: Claude Code no lo deja.

Para tu CLAUDE.md · las pruebas son el examen

Capa 1. Cópiala tal cual.

## Las pruebas son el examen
- Nunca modifiques, borres ni saltes una prueba para que pase. Si crees que una prueba está mal, detente y explícame por qué antes de tocarla.
- Un cambio de código y un cambio de pruebas van en commits separados, y el de pruebas lo apruebo yo.

Capa 2 · una meta con el examen intocable

/goal npm test sale sin errores, sin modificar ningún archivo de pruebas, o detente si después de 3 intentos sigue fallando

Capa 3 · bloquéalo con permisos

Claude busca tu carpeta de pruebas y te enseña la regla antes de guardarla.

Configura en .claude/settings.json de este proyecto una regla de permisos deny para que no puedas editar ni escribir archivos dentro de la carpeta de pruebas (búscala: tests, __tests__, e2e, spec o la que use el proyecto). Enséñame la regla antes de guardarla y explícame cómo la quito cuando yo quiera cambiar una prueba.

Lo que el permiso no tapa

El bloqueo es para las herramientas de editar y escribir. Con un comando de terminal, Claude todavía podría cambiar un archivo de pruebas. Por eso el equipo pone las reglas en una rama que el cambio no toca: la última palabra la tiene algo de afuera. En tu caso, eso eres tú revisando el commit de pruebas, o tu CI corriendo las pruebas de la rama principal.

06 · Regla 5

Cada commit dice cómo se verificó

El equipo le pone a cada commit un sello con cómo se comprobó ese cambio. Y si no se comprobó, el sello lo dice: “ninguna”. Así, cuando algo se rompe, pueden buscar en segundos todos los cambios que entraron sin probar.

Su post no enseña el formato. Este es el que te proponemos: una línea al final del mensaje del commit que empieza con Verificado:. Se ve así:

Ejemplo de mensaje de commit

Arregla el botón de pago en móvil Verificado: skill verify (captura del pago a 375 px) + pruebas e2e del checkout

Para tu CLAUDE.md · el sello

Con esto Claude lo escribe solo en cada commit.

## Commits
- Cada mensaje de commit termina con una línea que empieza con Verificado: y dice cómo comprobaste el cambio (qué corriste y qué viste).
- Si no lo comprobaste, escribe Verificado: ninguna y una frase de por qué. Nunca dejes fuera la línea.

Para encontrar los que entraron sin probar:

Buscar commits sin verificar

git log --oneline --grep="Verificado: ninguna"

Lo que el equipo tiene encima

Una compuerta que bloquea el commit si en la sesión no se corrió /code-review ni /verify, con tres modos: apagada, observar (solo anota lo que habría bloqueado, para ver falsos positivos) y aplicar. Si ya bloqueó dos veces en la sesión, deja pasar la tercera para que Claude no se atore. Es una herramienta interna suya, no una opción de Claude Code. Si armas algo parecido, empieza en modo observar.

07 · Las cinco de un jalón

Descarga las cinco reglas listas para usar

Armamos una skill verify de plantilla con las cinco reglas adentro, y el bloque de CLAUDE.md con las reglas 3, 4 y 5. La del equipo de Claude Code no es pública, así que esta la escribimos nosotros para que arranques. Las partes que dependen de tu app están marcadas con ADAPTA, y Claude las llena por ti.

Skill verify · el .zip

Una carpeta verify con su SKILL.md adentro. Se descomprime en .claude/skills/ de tu proyecto, y como se llama verify, Claude Code la corre sola antes de cada commit.

Descargar verify-skill.zip

Skill verify · el texto suelto

El mismo SKILL.md sin comprimir, para leerlo antes de instalarlo.

Descargar verify-SKILL.md

Bloque para tu CLAUDE.md

Las reglas 3, 4 y 5 juntas: tres intentos, no tocar el examen y el sello en cada commit.

Descargar reglas-claude-md.md

Instálalo todo

Con los archivos ya en la carpeta de tu proyecto.

Descomprime verify-skill.zip dentro de .claude/skills/ de este proyecto, para que quede .claude/skills/verify/SKILL.md. Lee el SKILL.md y llena las partes marcadas con ADAPTA usando lo que veas en el proyecto (cómo se arranca la app y qué se prueba); lo que no puedas saber, pregúntamelo.

Después agrega al final de mi CLAUDE.md el contenido de reglas-claude-md.md, sin borrar nada de lo que ya tenga.

Enséñame los dos archivos antes de guardar y, al terminar, corre la skill verify una vez para ver que funciona.

08 · Más herramientas

Lo que ya tienes en la bóveda para mejorar tu código

Tu trabajo cambia de lugar

Con estas cinco reglas puestas ya no lees cada línea que escribe Claude. Decides qué significa terminado, lo escribes donde Claude lo lea y revisas la evidencia que te trae. Eso es lo que deja al equipo correr decenas de Claudes a la vez, y lo que te deja a ti soltar la tarea sin quedarte vigilando.

Guía de la bóveda

Esta guía es una de las gratuitas de la bóveda.

Lo nuevo sale primero en Instagram

Ahí publico lo que voy probando antes de que se vuelva guía.

@soyenriquerocha

Guía gratis

Únete a la comunidad

Crea tu cuenta gratis con tu correo y la guía se abre aquí mismo. Te sirve para todas las guías. Si el código no te llega, revisa spam o Promociones.