# Copia lo que funciona: ingeniería inversa de un sistema que te gustó, antes de construir el tuyo

Este archivo no es para que tú lo leas. Es para que se lo des a Claude Code.

Ten a la mano el sistema que quieres estudiar: la demo que te dieron o tu cuenta de prueba.
Arrastra este archivo al chat sosteniendo **Shift** y escribe:

```
estudia este sistema antes de que construyamos el mío
```

La primera vez, Claude instala solo lo que hace falta. Tú solo le das permiso cuando te lo pida.

---

## INSTRUCCIONES PARA CLAUDE CODE

Quien te habla es dueño de un negocio, no programador. Antes de construir una herramienta
interna (inventarios, recursos humanos, compras, un tablero) pide demos de sistemas que ya
funcionan y trata de copiar lo bueno. Tu trabajo es hacerle **ingeniería inversa** a esos
sistemas con él: recorrerlos, entender cómo funcionan por dentro (pantallas, pasos, qué
datos guardan, qué pasa cuando se aprieta un botón) y convertir eso en el plano de su
propia herramienta.

Para eso vas a usar **REA (Reverse Engineer Anything)**, un repositorio de código abierto
(`morluto/rea`): mientras el navegador recorre el sistema, REA observa lo que pasa por
dentro y te devuelve la evidencia.

Español de México, sin tecnicismos, frases cortas, una pregunta a la vez. No le expliques
cómo funciona REA por dentro. Basta con: *"es una herramienta que ve lo que pasa detrás de
cada pantalla mientras la recorremos"*.

### Las reglas, antes de todo

- **Solo sistemas a los que tiene acceso legítimo:** su demo, su cuenta de prueba, su cuenta.
  Nunca una cuenta ajena, nunca contraseñas de otros, nunca saltarte un pago.
- **Revisa los términos de la demo.** Si prohíben analizar el sistema o usarlo para construir
  algo parecido, díselo y trabaja solo con lo público (centro de ayuda, videos, página de
  precios).
- **Solo mirar.** Si la cuenta permite cambiar datos, no guardes nada, no borres nada, no
  mandes nada. Ante la duda, te detienes y le preguntas.
- **Se estudia cómo funciona, no se copia.** Lo que sale es un plano propio, en el idioma de
  su negocio. Las capturas son solo referencia.

### Paso 0 · La primera vez: instálalo tú

Hazlo tú, comando por comando, y repórtale con palomita o tache. Si algo falla, arréglalo
antes de seguir.

1. **Node.js 22 o más nuevo.** Corre `node --version`. REA necesita 22.19 o superior (o 24.11
   o superior). Si no lo tiene o es viejo: en Mac, `brew install node`; en Windows,
   `winget install OpenJS.NodeJS.LTS`.
2. **REA.** Este repositorio ya pasó la aduana del programa (REVISA-ANTES-DE-INSTALAR.md) el
   8 de octubre de 2026. Si el usuario tiene esa regla instalada, menciónalo y sigue. Instala:

   ```
   npx -y rea-agents@latest setup --client claude_code --yes
   ```

   Hace dos cosas, y saca respaldo antes: conecta REA a Claude Code e instala su guía de uso.
   No instales Hopper ni Ghidra: son para analizar programas de escritorio y aquí no hacen falta.
3. **Mueve su guía a donde Claude Code la lee.** El instalador la deja en
   `~/.agents/skills/reverse-engineer-anything`, y Claude Code solo lee `~/.claude/skills`.
   Cópiala a `~/.claude/skills/reverse-engineer-anything` (en Windows, dentro de
   `%USERPROFILE%`).
4. **Un Chrome aparte para estudiar.** REA observa un Chrome abierto con un modo especial. Usa
   **un perfil nuevo, nunca el de diario del usuario**, para no mezclar sus sesiones:
   - Mac:
     ```
     "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --remote-debugging-port=9222 --user-data-dir="$HOME/chrome-estudio"
     ```
   - Windows:
     ```
     "C:\Program Files\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9222 --user-data-dir="%USERPROFILE%\chrome-estudio"
     ```
   Guarda el comando en `referencias/abrir-chrome-estudio.md` para la próxima vez.
5. **Que el navegador de Claude use ese mismo Chrome.** En la carpeta del proyecto crea
   `.mcp.json` con:
   ```json
   {"mcpServers":{"navegador-estudio":{"command":"npx","args":["@playwright/mcp@latest","--cdp-endpoint","http://127.0.0.1:9222"]}}}
   ```
6. **Reinicio.** Pídele que cierre Visual Studio Code y lo vuelva a abrir en esta carpeta, y
   que apruebe las conexiones nuevas si se lo pregunta. Después, verifica que tengas las
   herramientas de REA y del navegador antes de seguir.

Las siguientes veces solo hace falta el punto 4 (abrir el Chrome de estudio).

### Paso 1 · Qué vamos a estudiar

Pregúntale, de una en una:

1. ¿Qué herramienta quiere construir y qué problema le resuelve hoy?
2. ¿Qué sistemas vio que le gustaron? Para cada uno: ¿demo, cuenta de prueba o solo la página?
3. **¿Qué pedazo exacto?** No "todo el ERP": "el conteo cíclico, desde que se programa hasta
   que se ajusta la diferencia". Si no lo sabe acotar, propónle el flujo principal.
4. ¿Qué le gustó de cada uno y qué le estorbó? Anótalo literal: vale oro.

### Paso 2 · Una carpeta por sistema

```
referencias/
  <sistema-1>/
    estudio.md       lo que encontraste (paso 3)
    capturas/        una por pantalla y por estado
  <sistema-2>/
plano-propio.md      la síntesis (paso 4)
```

Agrega `.playwright-mcp/` y `chrome-estudio/` al `.gitignore` del proyecto.

### Paso 3 · El recorrido, sistema por sistema

Pídele que entre a la demo en el Chrome de estudio con su usuario (o entra tú si te da el
acceso de la demo). Luego recorre el pedazo acordado con el navegador mientras REA observa
cada pantalla. Además lee lo público: centro de ayuda, documentación y, si el sistema lo
publica, su documentación técnica.

Escribe `estudio.md` en español sencillo. **Cada dato lleva cómo lo supiste:**
**[Visto]** lo viste funcionar, **[Documentado]** lo leíste en su documentación,
**[Deducido]** es tu interpretación. Nunca presentes una deducción como hecho.

1. **La idea central en una frase.** Cómo piensa el sistema ese problema.
2. **Pantallas.** Número fijo (P01, P02...), para qué sirve, qué tiene y qué estados viste
   (vacía, llena, con error, sin permiso, en celular). Captura de cada una.
3. **Recorridos.** Cada meta del usuario, las pantallas por las que pasa y los clics del
   camino feliz. Ese número es el que su herramienta tiene que mejorar.
4. **Qué datos guarda.** Las "cosas" que maneja (productos, ubicaciones, conteos,
   movimientos), sus campos importantes y cómo se relacionan. Esto es lo que REA da mejor:
   aprovéchalo.
5. **Qué pasa por dentro cuando se aprieta el botón importante.** Por ejemplo, al guardar
   un conteo: qué se guarda, qué se anota en el historial y qué no se guarda.
6. **Qué no pudiste ver**, y por qué (permisos de la cuenta, pantallas de pago).

### Paso 4 · El plano propio

Con los estudios de todos los sistemas, escribe `plano-propio.md`:

1. **Lo que se queda de cada uno**, con su referencia (P04 del sistema A, el historial de B).
2. **Lo que se mejora:** lo que le estorbaba y lo que ningún sistema resuelve bien.
3. **Sus reglas de negocio:** las que solo existen en su operación (quién cuenta, quién
   aprueba, qué pasa con la diferencia). Pregúntaselas; no las adivines.
4. **Pantallas, recorridos y datos de su herramienta.** Si un dato se puede capturar por dos
   caminos, márcalo: hay que dejar uno solo.
5. **Tamaño honesto:** cuántas pantallas, las tres partes más difíciles y si es de semanas o
   de meses.

Enséñaselo y ajústalo con él **antes** de escribir una línea de código.

### Paso 5 · Que el plano mande en la construcción

Agrega al `CLAUDE.md` del proyecto:

> Antes de construir cualquier pantalla o módulo, lee `plano-propio.md` y respeta sus
> números de pantalla y de recorrido. Si lo que pide el usuario lo contradice, díselo antes
> de construir. Al terminar una pantalla, compárala contra el plano y contra las capturas
> de referencia, y dile qué quedó igual, qué quedó mejor y qué falta.

Si no tiene CONSTRUYE-CON-CALIDAD.md en este proyecto, recomiéndaselo: el plano dice
**qué** construir y ese recurso cuida **cómo**.

Al terminar cada sesión de estudio, recuérdale cerrar el Chrome de estudio.

### Cómo cierras

Adaptado: *"Estudiamos [n] sistemas por dentro. Tu herramienta va a tener [n] pantallas y
[n] recorridos. Lo mejor de cada uno ya está en el plano, y lo que te estorbaba ya tiene
solución. Lo más difícil va a ser [x]. ¿Arrancamos por [el recorrido principal]?"*
