Proyecto Final: Construye una Feature Completa

El Flujo Completo

🔄 Repaso rápido: En la lección anterior, exploramos flujos de trabajo avanzados como refinamiento progresivo, TDD, y debugging con patito de hule. Ahora vamos a juntar absolutamente todo en un proyecto final de inicio a fin.

Es momento de unir todo. Vamos a caminar por la construcción de una feature completa usando todas las técnicas del curso.

Esto no es un ejemplo de juguete. Es el flujo de trabajo real que usarías para código de producción.

La Feature: Rate Limiting de API

Estamos agregando rate limiting a una API de Express.js. Requerimientos:

Limitar requests por usuario (por API key)
Límites configurables (requests por minuto)
Devolver respuestas 429 apropiadas cuando se exceda
Bypass para usuarios admin
Respaldado por Redis para deployments distribuidos
Tests completos

Vamos a construirlo.

Fase 1: Planear

No toques código todavía. Primero planea.

> Necesito agregar rate limiting de API a una app Express.js.
> Requerimientos:
> - Limitación por usuario con API key
> - Límites configurables
> - Respuestas 429 apropiadas
> - Bypass para admins
> - Respaldado por Redis
> - Cobertura completa de tests
>
> Plantea la implementación:
> 1. ¿Qué archivos se necesitan crear?
> 2. ¿Qué archivos existentes necesitan modificación?
> 3. ¿Cuál es el orden de implementación?
> No escribas código todavía.

Claude produce un plan. Revísalo. Haz preguntas:

> ¿Por qué Redis en vez de en memoria? ¿Qué si queremos soportar ambos?

> ¿Cómo manejamos el bypass para admin — chequeo de header o lookup en DB?

Alinéate antes de implementar.

Fase 2: Setup de Contexto

Agrega archivos relevantes:

/add src/middleware/*.js
/add src/config/index.js
/add package.json
/add tests/middleware/*.test.js

Verifica el contexto:

/ls

Deberíamos ver los patrones de middleware y la estructura de config.

Fase 3: Implementación Core

Construye el rate limiter:

> Crea el middleware de rate limiting en src/middleware/rate-limiter.js
>
> Requerimientos de nuestro plan:
> - Algoritmo de token bucket
> - Storage en Redis (con fallback en memoria)
> - Límites configurables desde config
> - Devuelve 429 con header Retry-After
>
> Sigue los patrones de los archivos de middleware existentes.

Claude crea el middleware. Revísalo:

> Explícame cómo se rellena el token bucket.

> ¿Qué pasa si Redis no está disponible?

Arregla cualquier problema:

> La lógica de fallback no está del todo bien. Cuando Redis falla, debería:
> - Loggear el error
> - Hacer fallback a en memoria
> - Seguir verificando límites
> Arréglalo.

Fase 4: Tests (Casi) Primero

Antes de integrar, escribe tests:

> Crea tests para el rate limiter en tests/middleware/rate-limiter.test.js
>
> Casos de test:
> - Permite requests bajo el límite
> - Bloquea requests sobre el límite
> - Devuelve respuesta 429 correcta con Retry-After
> - El bypass de admin funciona
> - El fallback cuando Redis falla funciona
> - Los límites se resetean después de que la ventana expira

Corre los tests:

> Corre los tests. Todos deberían pasar.

Si fallan, itera:

> El test 3 está fallando. El header Retry-After no se está seteando.
> Arregla el middleware.

Fase 5: Integración

Ahora conéctalo todo:

/add src/app.js
> Integra el middleware de rate limiter.
> - Aplícalo globalmente pero después del middleware de autenticación
> - Usa config para los valores de límite
> - Agrégalo a la cadena de middleware en el orden correcto

Agrega configuración:

/add src/config/index.js
> Agrega configuración de rate limiting:
> - RATE_LIMIT_WINDOW_MS (default 60000)
> - RATE_LIMIT_MAX_REQUESTS (default 100)
> - RATE_LIMIT_ADMIN_BYPASS (default true)

✅ Revisión Rápida: ¿Por qué es importante integrar el rate limiter DESPUÉS del middleware de autenticación en la cadena?

Fase 6: Edge Cases

Ahora endurece:

> Revisa el rate limiter buscando edge cases:
> - ¿Qué si falta la API key?
> - ¿Qué si la API key tiene formato incorrecto?
> - ¿Qué hay de race conditions en un entorno distribuido?
> - ¿Qué si la config de límites es inválida?
>
> Agrega manejo para cualquier hueco.

Claude identifica problemas y los arregla.

Fase 7: Documentación

> Crea documentación para la feature de rate limiting:
> - Agrega sección al README sobre rate limiting
> - Agrega comentarios JSDoc inline al middleware
> - Documenta las opciones de configuración
> - Agrega ejemplo de cómo testear el rate limiting

Fase 8: Revisión Final

Revisión completa antes de commitear:

> Revisa todo lo que construimos:
> - src/middleware/rate-limiter.js
> - tests/middleware/rate-limiter.test.js
> - Cambios a src/app.js y config
>
> ¿Algún problema? ¿Test cases faltantes? ¿Bugs potenciales?

Corre tests finales:

> Corre todos los tests. Confirma que todo pasa.

Revisa el estado de git:

git status
git diff

Fase 9: Commit

Historial de git limpio:

git add src/middleware/rate-limiter.js
git commit -m "feat: add rate limiting middleware with Redis storage"

git add tests/middleware/rate-limiter.test.js
git commit -m "test: add rate limiter test coverage"

git add src/app.js src/config/index.js
git commit -m "feat: integrate rate limiter globally"

git add README.md
git commit -m "docs: document rate limiting configuration"

Commits lógicos que cada uno podría revertirse independientemente.

Tu Reto del Proyecto Final

Construye esta feature tú mismo usando Claude Code:

Feature: Logging de Requests de API

Requerimientos:

Loggear todos los requests entrantes de API
Incluir: timestamp, método, path, ID de usuario, tiempo de respuesta, status code
Almacenar en base de datos (o archivo para simplificar)
Niveles de log configurables
Capacidad de consultar/buscar logs
Tests

Tu flujo de trabajo debería incluir:

Sesión de planeación (no codees todavía)
Setup de contexto (agrega archivos relevantes)
Implementación core
Tests
Integración
Manejo de edge cases
Documentación
Revisión final
Commits limpios

Usa todo lo que aprendiste.

Repaso del Curso

A lo largo de 8 lecciones, aprendiste:

Lección	Qué Aprendiste
1. Introducción	El modelo mental: dirige a Claude, no solo preguntes
2. Comandos Esenciales	Comandos slash esenciales para uso diario
3. Manejo de Contexto	Carga estratégica de archivos para mejores respuestas
4. Orquestación de Tareas	Descomponer y secuenciar trabajo complejo
5. Operaciones de Archivos	Manipulación segura y eficiente de archivos
6. Integración con Bash	Automatización inteligente con comandos de shell
7. Flujos Avanzados	Patrones profesionales para desarrollo serio
8. Proyecto Final	Juntando todo

Principios Clave

El contexto lo es todo. Calidad sobre cantidad.
Planea antes de implementar. Especialmente para cualquier cosa no trivial.
Itera, no reinicies. Construye sobre lo que funciona.
Verifica continuamente. Testea temprano y seguido.
Git es tu red de seguridad. Haz commit seguido, revierte fácilmente.
Usa el nivel correcto de dirección. Ajusta el esfuerzo a la complejidad de la tarea.

Felicidades

Completaste el curso Domina Claude Code. Ahora tienes las herramientas y los patrones para:

Manejar contexto como un profesional para obtener las mejores respuestas posibles
Orquestar tareas complejas de múltiples pasos con confianza
Trabajar con archivos de forma segura usando git como red de seguridad
Automatizar flujos de trabajo combinando IA con el poder del shell
Abordar proyectos de cualquier complejidad con un enfoque sistemático

Estas habilidades no son teóricas — son multiplicadores de productividad reales. Developers que dominan estos patrones consistentemente entregan más rápido y con mayor calidad.

Tu siguiente paso: elige un proyecto real y aplica el flujo completo de 9 fases. Empieza con algo moderado — una feature nueva, un refactor, o un sistema de tests. El hábito se construye practicando.

Ahora sí, ve a construir algo.