Primeros Pasos con Ralph Wiggum Parte 4: Patrones Avanzados y Solución de Problemas

Ya aprendiste los fundamentos y dominaste la metodología. Ahora vamos a sumergirnos en técnicas avanzadas que separan a los aficionados de los profesionales.

Este es tu manual avanzado—técnicas para escenarios complejos, solución integral de problemas y patrones de nivel empresarial que te convertirán en un experto en Ralph.

Ingeniería Avanzada de Prompts

El Patrón Sándwich de Restricciones

Uno de los patrones más efectivos para prompts de Ralph estructura las restricciones alrededor de la tarea:

# BUILDING MODE

## Pre-Constraints (What to consider first)
- Read IMPLEMENTATION_PLAN.md
- Check progress.txt for prior learnings
- Study existing patterns in the codebase
- Verify dependencies are installed

## Core Task
[Your main instruction here]

## Quality Gates (Must pass before proceeding)
- All tests pass: npm test
- Type check passes: npm run type-check
- Linter passes: npm run lint
- No console.logs or debugger statements remain

## Post-Task Actions
- Commit with semantic message
- Update IMPLEMENTATION_PLAN.md
- Append learning to progress.txt

Este patrón funciona porque guía el razonamiento de Ralph en el orden correcto, como se documenta en 11 Tips for AI Coding with Ralph Wiggum.

Mira ejemplos reales: Explora archivos de prompts de producción de la comunidad:

• snarktank/ralph — prompt.md completo con estructura de restricciones
• ClaytonFarr/ralph-playbook — Plantillas PROMPT_plan.md y PROMPT_build.md
• peteristhegreat's gist — Configuración del agente de código Ralph

La Técnica de Prompting Socrático

En lugar de decirle a Ralph exactamente qué hacer, hazle preguntas que lo lleven a mejores soluciones:

Prompt débil:

Implement caching for the API.

Prompt fuerte (Socrático):

We need to improve API performance. Before implementing:

1. What are the slowest endpoints currently? (Analyze with profiler)
2. Which data changes frequently vs rarely?
3. What caching strategy best fits this access pattern?
4. Where should the cache layer live (app, Redis, CDN)?

After analysis, implement the most appropriate solution with tests.

Esto obliga a Ralph a pensar el problema de forma sistemática, como se enfatiza en The Ralph Playbook.

El Patrón de Escape

Siempre dale a Ralph una salida si se queda atascado:

## If You Encounter a Blocker

1. Document the issue in progress.txt
2. Create a TODO.md file with:
   - What you tried
   - Why it didn't work
   - What needs human decision
3. Mark the current task as "blocked" in IMPLEMENTATION_PLAN.md
4. Move to the next independent task

DO NOT spin indefinitely on unsolvable problems.

El Patrón de Acumulación de Conocimiento

Estructura progress.txt para acumular conocimiento:

After completing each task, append:

## [TIMESTAMP] [TASK-ID]: [Task Title]

### What Was Built
- Feature/change summary

### Technical Decisions
- Why this approach over alternatives

### Challenges & Solutions
- What went wrong and how it was fixed

### Learnings for Next Tasks
- Patterns to reuse
- Pitfalls to avoid

### Dependencies/Prerequisites for Related Tasks
- What's now available for other tasks

Esto crea una base de conocimiento que Ralph consulta, evitando errores repetidos.

Organización Avanzada de Archivos

Estructura de Proyecto Multi-Modo

Para proyectos complejos que usan las tres fases:

project-root/
├── ralph/                    # Ralph-specific files
│   ├── phases/
│   │   ├── PROMPT_plan.md
│   │   ├── PROMPT_build.md
│   │   └── PROMPT_refactor.md  # Optional: separate refactor mode
│   ├── IMPLEMENTATION_PLAN.md
│   ├── progress.txt
│   ├── blockers.md             # Current blockers needing human input
│   └── loop.sh                 # Orchestrator script
├── specs/                    # Requirements
│   ├── architecture.md
│   ├── features/
│   │   ├── auth.md
│   │   └── api.md
│   └── non-functional.md     # Performance, security, etc.
├── docs/                     # Generated documentation
├── src/                      # Application code
└── tests/                    # Test suite

El Sistema de Checkpoints

Crea checkpoints para proyectos de larga duración:

# ralph/checkpoints/checkpoint-YYYY-MM-DD-description.md

## Project State
- Branch: feature/user-management
- Commit: abc123
- Tasks completed: 15/30
- Blockers: None

## Ralph Configuration
- Mode: Building
- Max iterations: 100
- Completion promise: "MILESTONE COMPLETE"

## Next Steps
1. Complete user role management (TASK-016 to TASK-020)
2. Then regenerate plan for Phase 2 features
3. Consider splitting into separate Ralph session

## Learnings So Far
- Database schema changes require migration strategy
- Test data setup takes 2-3 iterations
- Auth patterns now stable and reusable

Configurando PRDs para Ralph

Un PRD bien estructurado es crítico para el éxito de Ralph. Esta es una alternativa al enfoque de specs/*.md + IMPLEMENTATION_PLAN.md—algunos equipos prefieren JSON por su legibilidad para máquinas.

Herramientas útiles: Ralph TUI incluye /ralph-tui-prd para crear PRDs de forma interactiva y /ralph-tui-create-json para convertirlos a JSON. snarktank/ralph ofrece gestión de tareas basada en PRDs con ramificación automática y visualización de diagramas de flujo.

Plantilla prd.json

{
  "project": "Todo API",
  "schema_version": "2.0",
  "final_tests": ["npm test", "npm run type-check", "npm run lint"],
  "stories": [
    {
      "id": "S001",
      "priority": 1,
      "title": "User Authentication",
      "category": "backend",
      "description": "Implement JWT-based authentication with login/logout",
      "acceptance": [
        "User can register with email/password",
        "User can login and receive JWT token",
        "Protected routes require valid JWT",
        "User can logout and invalidate token"
      ],
      "steps_to_verify": [
        "Run: npm test -- auth.test.ts",
        "Verify all 12 auth tests pass",
        "Check JWT is stored in httpOnly cookie",
        "Verify token expiry works correctly"
      ],
      "tests": ["npm test -- auth.test.ts"],
      "estimated_complexity": "medium",
      "depends_on": [],
      "passes": false
    },
    {
      "id": "S002",
      "priority": 2,
      "title": "Todo CRUD Endpoints",
      "category": "backend",
      "description": "Create POST, GET, PUT, DELETE endpoints for todos",
      "acceptance": [
        "POST /api/todos creates a todo",
        "GET /api/todos returns user's todos only",
        "PUT /api/todos/:id updates a todo",
        "DELETE /api/todos/:id deletes a todo"
      ],
      "steps_to_verify": [
        "Run: npm test -- todos.test.ts",
        "Test with Postman or curl",
        "Verify authorization works"
      ],
      "tests": ["npm test -- todos.test.ts"],
      "estimated_complexity": "medium",
      "depends_on": ["S001"],
      "passes": false
    }
  ]
}

Principios Clave del PRD

Criterios Binarios de Aprobado/Reprobado: Cada tarea necesita verificación automatizada. Como enfatiza The Ralph Playbook: "Hazlo mejor" no es verificable—"Todas las pruebas pasan con 80%+ de cobertura" sí lo es.

Tareas Atómicas: Si una tarea requiere 500+ líneas de código, divídela. Cada historia debería completarse en 2-3 iteraciones.

El Campo passes: Ralph lo actualiza a true cuando termina. El bucle continúa hasta que todas las tareas pasen.

Requisitos de Pruebas: Cada historia debe especificar cómo verificar su completitud de forma automática. Nada de pasos de verificación manual.

Errores Comunes y Cómo Evitarlos

Empezar Demasiado Ambicioso

Error: Ejecutar 50 iteraciones en tu primer proyecto con Ralph.

Solución: Empieza con 10-20 iteraciones para entender los costos y el comportamiento. Como se documenta en los consejos de la comunidad, un bucle de 50 iteraciones puede costar $50-100+.

Criterios de Completitud Vagos

Error: "Haz la app más rápida" o "Mejora la UI"

Solución: Usa criterios específicos y verificables:

• ✅ "Reducir el tiempo de respuesta del API a menos de 200ms (verificado por pruebas de carga)"
• ✅ "Todas las puntuaciones de Lighthouse por encima de 90"
• ✅ "Cobertura de pruebas por encima del 80% en todos los módulos"

Sin Verificación Automatizada

Error: Tareas que requieren juicio humano como "haz que se vea bien"

Solución: Ralph necesita condiciones binarias de aprobado/reprobado. Si no puedes escribir una prueba automatizada para ello, Ralph no puede verificarlo. Como dice The Ralph Playbook: "La contrapresión supera a la dirección."

Tareas Demasiado Grandes

Error: "Construir todo el sistema de autenticación" como una sola tarea

Solución: Divide en historias más pequeñas:

• S001: Endpoint de registro de usuario
• S002: Endpoint de login con JWT
• S003: Mecanismo de refresco de token
• S004: Flujo de restablecimiento de contraseña
• S005: Verificación de email

Ignorar los Límites de Contexto

Error: Dejar que Ralph funcione indefinidamente sin contexto fresco

Solución: Usa el método de bucle Bash en lugar del plugin para proyectos de larga duración—cada iteración obtiene una ventana de contexto fresca. Esta es una idea clave de la guía de Geoffrey Huntley.

Cuándo usar cada método:

• < 20 iteraciones: El plugin (/ralph-loop) funciona bien—configuración más simple, el contexto se mantiene manejable
• 20-40 iteraciones: Ambos funcionan; el bucle bash es preferible por consistencia
• > 40 iteraciones: Bucle bash obligatorio—previene la degradación de contexto y las alucinaciones

El plugin ejecuta todo en una sola ventana de contexto, que se llena con el tiempo. El método de bucle bash lanza una instancia fresca de Claude por iteración, con solo el estado del código trasladándose.

Sin Monitoreo de Costos

Error: No rastrear el gasto en API durante el desarrollo

Solución: Configura alertas de facturación y empieza con conteos bajos de iteraciones. Monitorea los costos por iteración. Rastrea tu gasto en https://console.anthropic.com

Tipos de Tareas Incorrectos

Buenas tareas para Ralph:

• Migrar pruebas de Jest a Vitest
• Agregar endpoints CRUD con pruebas
• Implementar funcionalidades bien especificadas
• Refactorizar con cobertura de pruebas existente

Malas tareas para Ralph:

• "Descifra por qué la app es lenta" (exploración)
• "Haz la UI más bonita" (subjetivo)
• "Arregla este bug raro" (requiere contexto profundo de depuración)
• Decisiones de UX que requieren juicio estético

El Problema de Thrashing

Síntoma: Ralph se queda atrapado en un bucle—mismo error, mismo intento de solución, mismo fallo.

Soluciones:

• Configura --max-iterations para limitar el daño
• Revisa tus pruebas—¿son demasiado estrictas o poco claras?
• Divide la tarea en piezas más pequeñas y atómicas
• Agrega pasos explícitos de depuración a tu prompt
• Verifica que las dependencias estén correctamente instaladas

Guía Integral de Solución de Problemas

Problema: Ralph Sigue Cometiendo el Mismo Error

Síntomas:

• Mismo error en múltiples iteraciones
• Las pruebas fallan con mensaje idéntico
• Ralph intenta el mismo enfoque repetidamente

Causas Raíz:

1. La prueba es ambigua o está escrita incorrectamente
2. El prompt no incluye retroalimentación de errores
3. Ralph carece de contexto sobre por qué el enfoque falla

Soluciones:

Solución 1: Actualiza la prueba

// Bad: Vague assertion
expect(result).toBeTruthy();

// Good: Specific assertion
expect(result).toEqual({
  id: expect.any(String),
  email: 'test@example.com',
  createdAt: expect.any(Date)
});

Solución 2: Agrega retroalimentación de errores al prompt

If tests fail:
1. Read the test output carefully
2. Identify the specific assertion that failed
3. Check if you're testing the wrong behavior
4. Try a different approach if current one fails twice

Solución 3: Agrega pasos explícitos de depuración

Before implementing:
1. Add console.log to see actual vs expected values
2. Run test in isolation: npm test -- --testNamePattern="specific test"
3. Verify mock data matches what code expects

Solución 4: Usa el Patrón de Escape

Si Ralph sigue fallando después de múltiples intentos, usa el Patrón de Escape para documentar el bloqueo y pasar a la siguiente tarea en lugar de girar indefinidamente.

Problema: Ralph Genera Código Inseguro

Síntomas:

• Contraseñas almacenadas en texto plano
• Vulnerabilidades de inyección SQL
• Verificaciones de autenticación faltantes
• CORS configurado como "*"

Prevención:

Agrega una lista de verificación de seguridad al prompt:

## Security Checklist (MUST verify before committing)

Authentication:
- [ ] Passwords hashed with bcrypt (min 12 rounds)
- [ ] JWTs signed with secure secret (min 32 chars)
- [ ] httpOnly cookies for token storage
- [ ] No secrets in code (use env variables)

Authorization:
- [ ] All protected routes have auth middleware
- [ ] User can only access own resources
- [ ] Admin endpoints check role

Input Validation:
- [ ] All user input validated with Zod/Joi
- [ ] SQL/NoSQL injection prevented (use ORMs)
- [ ] XSS prevention (sanitize HTML)
- [ ] Rate limiting on sensitive endpoints

CORS:
- [ ] Specific origins only (not "*")
- [ ] Credentials: true only with specific origin

Problema: Agotamiento de la Ventana de Contexto

Síntomas:

• Ralph empieza a ignorar partes de los prompts
• La calidad se degrada después de la iteración 30-40
• Ralph deja de seguir las restricciones

Como explica la guía de JeredBlu, por eso el método de bucle bash con contexto fresco por iteración es "fundamentalmente mejor para tareas de larga duración."

Soluciones:

Solución 1: Usa el Método de Bucle Bash

# loop.sh - Fresh context each iteration
while true; do
  claude < PROMPT_build.md

  # Check if done
  if grep -q "ALL TASKS COMPLETE" progress.txt; then
    echo "Build complete!"
    break
  fi

  sleep 2
done

Solución 2: Prompt de Compresión de Contexto

Sobre /compact: El comando /compact comprime el contexto de tu conversación, permitiéndote seguir trabajando sin perder detalles importantes. Úsalo proactivamente antes de alcanzar los límites de contexto. Consulta Mastery Part 2 para saber cuándo usar /compact vs /clear.

Every 10 iterations, before continuing:

1. Run: /compact to compress context
2. Summarize current state:
   - Tasks completed
   - Current task in progress
   - Key patterns established
3. Continue with fresh focus

Solución 3: Divide las Sesiones Largas

# Session 1: Core features (Tasks 1-10)
/ralph-loop "$(cat PROMPT_build.md)" --max-iterations 30

# Review, commit, take a break

# Session 2: Advanced features (Tasks 11-20)
/ralph-loop "$(cat PROMPT_build.md)" --max-iterations 30

Problema: Ralph No Para (Thrashing)

Síntomas:

• Alcanza max-iterations sin completar
• Hace cambios, los revierte, repite
• Progress.txt muestra lógica circular

Para un análisis más profundo de la toma de decisiones de Ralph cuando hace thrashing, la guía de depuración de Braintrust muestra cómo usar herramientas de observabilidad de LLM para entender qué está pasando.

Diagnóstico:

Revisa progress.txt buscando patrones:

[14:30] Trying approach A...
[14:35] Approach A failed, trying approach B...
[14:40] Approach B failed, trying approach A again...

Soluciones:

Solución 1: Agrega seguimiento de intentos

Track attempts in progress.txt:

[Iteration X] TASK-005: Attempt #1 - Trying JWT with RSA
[Iteration Y] TASK-005: Attempt #2 - Trying JWT with HS256
[Iteration Z] TASK-005: Attempt #3 - Adding fallback

If task has 3 failed attempts:
1. Mark task as "blocked"
2. Document in blockers.md
3. Move to next task

Solución 2: Simplifica los criterios de aceptación

# Too complex (causes thrashing)
- API must be performant, secure, and scalable

# Specific (Ralph can verify)
- API responds in <200ms (verified by tests)
- All endpoints require authentication (verified by tests)
- Can handle 100 concurrent requests (load test passes)

Problema: La Cobertura de Pruebas Disminuye con el Tiempo

Síntomas:

• Las primeras tareas tienen excelentes pruebas
• Las tareas posteriores tienen pruebas mínimas
• Cobertura por debajo del objetivo

Causa Raíz: Ralph prioriza entregar sobre probar cuando no se le exige.

Solución: Agrega una puerta de cobertura de pruebas al prompt:

## Test Requirements (STRICT)

Every commit MUST include tests for:
1. Happy path (success case)
2. Error cases (4xx, 5xx)
3. Edge cases (empty input, missing fields)
4. Authorization (access control)

Before committing, run: npm test -- --coverage

MINIMUM COVERAGE REQUIRED:
- Statements: 80%
- Branches: 75%
- Functions: 80%
- Lines: 80%

If coverage drops below threshold:
- DO NOT commit
- Add missing tests
- Re-run coverage

Problema: Ralph Ignora los Patrones Existentes

Síntomas:

• El código nuevo usa patrones diferentes al código existente
• Estructura de archivos inconsistente
• Múltiples formas de hacer lo mismo

Solución: Agrega documentación de patrones a tu prompt. Incluye la estructura real de archivos y las convenciones de nomenclatura de tu proyecto para que Ralph las siga consistentemente:

## Codebase Patterns (MUST FOLLOW)

Before implementing any feature:
1. Study existing features as reference (e.g., the user module)
2. Follow the same directory structure and file organization
3. Reuse established naming conventions and code patterns
4. Only deviate if specs explicitly require it

If unsure about a pattern, check how similar features are implemented
in the codebase before writing new code.

Configuración Avanzada de Ralph-TUI

Ralph-TUI permite personalización a través de un archivo de configuración en ~/.ralph-tui/config.json.

Prioridades Personalizadas de Tareas

Anula el orden de prioridad predeterminado:

{
  "taskPriority": {
    "TASK-001": 10,
    "TASK-005": 9,
    "TASK-002": 8
  }
}

Ralph-TUI muestra las tareas en este orden, aunque IMPLEMENTATION_PLAN.md las liste diferente.

Filtrado de Salida

Filtra líneas de log por palabra clave o regex:

{
  "logFilters": {
    "exclude": ["Reading", "Skipping"],
    "include": ["✓", "✗", "completed", "failed"]
  }
}

Esto oculta líneas ruidosas (lecturas de archivos) y resalta eventos importantes (resultados de pruebas, completitud de tareas).

Formatos de Exportación

Elige el formato de exportación de logs:

{
  "exportFormat": "markdown"
}

Opciones: txt, markdown, json, html

La exportación en Markdown genera:

# Ralph-TUI Log Export
**Project:** my-saas-app
**Duration:** 2h 15m
**Tasks Completed:** 12 / 15

## Iteration 1
[10:05:12] Reading specs...
...

Integración con Otras Herramientas

Envía eventos de Ralph-TUI a sistemas externos:

{
  "webhooks": {
    "taskComplete": "https://myapp.com/api/ralph-task-complete",
    "testFailure": "https://myapp.com/api/ralph-test-failed"
  }
}

Cuando Ralph completa una tarea, Ralph-TUI hace un POST a tu webhook:

{
  "event": "taskComplete",
  "taskId": "TASK-003",
  "timestamp": "2026-01-16T10:30:45Z",
  "iteration": 12
}

Casos de uso:

• Actualizar herramientas de gestión de proyectos (Linear, Jira)
• Enviar notificaciones por Slack
• Disparar pipelines de CI/CD al completar tareas

Solución de Problemas de Ralph-TUI

Ralph-TUI No Detecta el Bucle de Ralph

Síntoma: ralph-tui run muestra "Waiting for Ralph loop..." indefinidamente.

Causa: Ralph-TUI busca un proceso ralph ejecutándose en el directorio actual. Si iniciaste Ralph en un directorio diferente, Ralph-TUI no lo encontrará.

Solución:

1. Ejecuta ps aux | grep ralph para encontrar el proceso de Ralph
2. Anota el directorio de trabajo con lsof -p <pid>
3. Navega con cd a ese directorio y ejecuta ralph-tui run de nuevo

Alternativa: Especifica explícitamente el ID del proceso de Ralph:

ralph-tui run --pid 12345

Sesión Perdida/Corrupta

Síntoma: Ralph-TUI muestra "Session data corrupted" al iniciar.

Causa: Ralph-TUI almacena el estado de la sesión en ~/.ralph-tui/sessions/<project-name>.json. Si Ralph se cuelga a mitad de iteración, el archivo de sesión puede quedar incompleto.

Solución:

1. Elimina la sesión corrupta: rm ~/.ralph-tui/sessions/my-project.json
2. Reinicia Ralph-TUI: ralph-tui run

Ralph-TUI crea una sesión nueva, pero pierdes el contexto histórico (las iteraciones anteriores no aparecerán en los logs).

Prevención: Habilita respaldos de sesión en la configuración:

{
  "sessionBackups": {
    "enabled": true,
    "interval": 300
  }
}

Esto crea respaldos cada 5 minutos en ~/.ralph-tui/sessions/backups/.

Problemas de Rendimiento con Logs Grandes

Síntoma: Ralph-TUI se vuelve lento o no responde después de varias horas de monitoreo.

Causa: El buffer de logs crece a 100,000+ líneas, ralentizando el renderizado.

Solución:

1. Exporta los logs periódicamente: presiona e cada hora
2. Habilita rotación de logs en la configuración:

{
  "logRotation": {
    "maxLines": 10000,
    "archiveOld": true
  }
}

Cuando los logs alcanzan 10,000 líneas, Ralph-TUI archiva los logs antiguos en ~/.ralph-tui/archives/ y limpia el buffer.

Alternativa: Aumenta el tamaño del buffer del terminal si tu terminal lo soporta (ej., iTerm2 → Preferences → Profiles → Terminal → Scrollback lines).

Conflictos de Puerto

Síntoma: ralph-tui run falla con "Port 9876 already in use".

Causa: Ralph-TUI usa el puerto 9876 para comunicación interna. Otro proceso lo está usando.

Solución:

1. Encuentra el proceso en conflicto: lsof -i :9876
2. Mátalo o usa un puerto diferente:

ralph-tui run --port 9999

Solución permanente: Establece el puerto predeterminado en la configuración:

{
  "port": 9999
}

Retroalimentación Visual Headless con Playwright MCP

Para ejecuciones de bucle bash sin un navegador visible, JeredBlu recomienda Playwright MCP para verificación visual.

¿Qué es MCP? Model Context Protocol (MCP) es un estándar abierto que permite a Claude conectarse a servicios externos—bases de datos, APIs, automatización de navegador y más. Los servidores MCP amplían las capacidades de Claude más allá del procesamiento de texto. Consulta Mastery Part 7: MCP Servers para configuración e instalación.

Crea .mcp.json en la raíz de tu proyecto:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest", "--headless", "--output-dir", "screenshots"]
    }
  }
}

Luego referéncialo en tu PROMPT_build.md:

After implementing, use Playwright to:
1. Navigate to the local server URL
2. Take a screenshot: screenshots/[task-name].png

Include the screenshot filename in your progress.txt entry.

Esto te da verificación visual del trabajo de Ralph sin necesitar Claude for Chrome o una ventana de navegador visible. Las capturas de pantalla se acumulan en la carpeta de tu proyecto, proporcionando un registro visual de auditoría de lo que Ralph construyó.

Cuándo usar Playwright MCP vs Ralph-TUI:

• Ralph-TUI: Monitoreo de logs en tiempo real, orquestación de tareas, controles por teclado
• Playwright MCP: Verificación visual headless, registros de auditoría con capturas, integración CI/CD

Ambas herramientas se complementan—usa Ralph-TUI para monitoreo en vivo y Playwright MCP para verificación visual.

Patrones Empresariales

Coordinación Multi-Desarrollador con Ralph

Cuando múltiples desarrolladores usan Ralph en el mismo proyecto, la coordinación se vuelve crítica. Existen varias herramientas para esto:

• ralph-orchestrator — Soporta 7+ backends de IA (Claude, Gemini, Copilot, etc.) con un sistema de personas/sombreros para tareas especializadas
• multi-agent-ralph-loop — Orquestación paralela de flujos de trabajo para ejecutar múltiples instancias de Ralph simultáneamente
• ralph-loop-agent — Wrapper SDK de TypeScript de Vercel para control programático

Patrón 1: Ralph por Feature Branch

# Developer A
git checkout -b feature/auth
# Run Ralph for auth tasks
./loop.sh build --tasks "TASK-001 to TASK-005"

# Developer B (different branch)
git checkout -b feature/payments
# Run Ralph for payment tasks
./loop.sh build --tasks "TASK-010 to TASK-015"

# Merge both when complete

Patrón 2: Seguimiento de Progreso Compartido

# team-progress.md

## Active Ralph Sessions

### Developer: Alice
- Branch: feature/auth
- Tasks: TASK-001 to TASK-005
- Status: In Progress (3/5 complete)
- ETA: 2 hours

### Developer: Bob
- Branch: feature/payments
- Tasks: TASK-010 to TASK-015
- Status: Complete
- Ready for: Code review

## Blocked Tasks Needing Team Discussion
- TASK-008: Payment provider API unclear
- TASK-014: Architecture decision needed

Integración Ralph + CI/CD

Automatiza ejecuciones de Ralph en tu pipeline:

# .github/workflows/ralph-build.yml
name: Ralph Autonomous Build

on:
  workflow_dispatch:
    inputs:
      tasks:
        description: 'Task range (e.g., TASK-001 to TASK-005)'
        required: true

jobs:
  ralph-build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Claude Code
        run: curl -fsSL https://claude.ai/install.sh | bash

      - name: Run Ralph Loop
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          ./loop.sh build \
            --tasks "${{ github.event.inputs.tasks }}" \
            --max-iterations 30

      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v5
        with:
          title: "Ralph Build: ${{ github.event.inputs.tasks }}"
          body: |
            Autonomous build completed by Ralph Wiggum

            Tasks completed:
            ${{ github.event.inputs.tasks }}

            See progress.txt for details.

Eligiendo un Plan de Claude para Ralph

Ralph funciona con suscripciones de Claude o acceso por API. Aquí tienes la guía rápida:

• Claude Pro ($20/mes) — 10-30 iteraciones/sesión, ideal para aprender y proyectos personales
• Claude Max 5x ($100/mes) — 50-150 iteraciones/sesión, ideal para desarrollo diario
• Claude Max 20x ($200/mes) — 200-600+ iteraciones/sesión, sesiones autónomas largas de nivel profesional

Recomendación: Empieza con Pro para aprender el flujo de trabajo. Actualiza a Max 5x una vez que uses Ralph a diario—es 5x la capacidad por 5x el precio, lo cual es justo. Pasa a Max 20x si haces trabajo para clientes o necesitas sesiones autónomas extendidas.

Las matemáticas del ROI: A $200/mes por Max 20x, si Ralph te ahorra solo 5 horas (a $40/hora de facturación), ya se pagó solo. La mayoría de los usuarios serios reportan 20-40+ horas ahorradas al mes.

Consejos de Gestión de Costos

• Siempre configura --max-iterations — Tu verdadera red de seguridad
• Empieza pequeño — 10-20 iteraciones hasta que entiendas los costos
• Prompts enfocados = menos iteraciones — Los prompts vagos queman tokens
• Rastrea tu uso — Revisa en https://claude.ai/settings

Conclusión

Ya cubriste las técnicas avanzadas que te ayudarán a sacar más provecho de Ralph. Estas técnicas te permiten abordar proyectos complejos de nivel producción con confianza. Sabes cómo prevenir problemas antes de que ocurran y solucionarlos rápidamente cuando aparecen.

Para recursos adicionales, explora The Ralph Playbook para documentación integral de la metodología, la guía original de Geoffrey Huntley para la filosofía detrás de la técnica, y la guía práctica de JeredBlu para configuraciones listas para copiar y pegar.