Proyecto: Construye Tu Kit de Herramientas para Desarrollador
El Desafío Final
A lo largo de trece lecciones has aprendido cada funcionalidad principal de Claude Code: memoria de proyecto, slash commands, skills, hooks, servidores MCP, subagentes, plugins, checkpoints, modo print, planificación y configuración de equipo. Ahora es momento de unirlo todo.
En este proyecto final, construirás un kit de herramientas completo para desarrollador -- un sistema totalmente integrado que hace que Claude Code funcione exactamente de la manera que necesitas para tu proyecto más utilizado. Al terminar, tendrás una configuración lista para producción que puedes usar diariamente y compartir con tu equipo.
Trabaja cada paso en orden. Cada paso se construye sobre el anterior.
Paso 1: Crea Tu CLAUDE.md
Comienza con la base. Abre tu proyecto más utilizado y crea un archivo CLAUDE.md que capture todo lo que Claude necesita saber:
# Proyecto: [Nombre de Tu Proyecto]
## Descripcion General
Breve descripcion de que hace este proyecto y su stack tecnologico.
## Arquitectura
- Estructura de directorios y que vive donde
- Frameworks y librerias clave
- Dependencias de base de datos y servicios externos
## Estandares de Codigo
- Preferencias de lenguaje y estilo
- Convenciones de nomenclatura (variables, archivos, componentes)
- Reglas de ordenamiento de imports
- Patrones de manejo de errores
## Flujo de Trabajo Git
- Convencion de nombrado de ramas
- Formato de mensajes de commit
- Proceso de PR y estrategia de merge
## Testing
- Framework de tests y convenciones
- Donde viven los archivos de test
- Como ejecutar tests (unitarios, integracion, e2e)
## Reglas Criticas
- Archivos y patrones que NUNCA deben modificarse sin revision
- Politica de secretos y credenciales
- Areas sensibles al despliegue
## Tareas Comunes
- Como iniciar el servidor de desarrollo
- Como ejecutar las migraciones de base de datos
- Como desplegar a staging y produccion
Llena cada sección con información real sobre tu proyecto. Cuanto más específico seas, mejor funcionará Claude. No escribas consejos genéricos -- escribe los comandos, rutas y convenciones reales que aplican a tu codebase.
Prueba esto: después de crear el archivo, inicia una nueva sesión de Claude Code y pídele que describa la arquitectura de tu proyecto. Verifica que use la información de tu CLAUDE.md con precisión.
Paso 2: Construye un Skill Personalizado
Identifica la tarea que realizas más frecuentemente y automatízala con un skill. Crea .claude/skills/[tu-tarea].md:
---
triggers:
- file_write
- file_edit
globs: ["src/**/*.ts"]
description: Imponer manejo de errores consistente en todos los archivos TypeScript
---
## Estandares de Manejo de Errores
Al escribir o editar archivos TypeScript en este proyecto:
1. **Nunca lanzar strings crudos.** Siempre usa la clase custom AppError:
```typescript
// Incorrecto
throw new Error("User not found");
// Correcto
throw new AppError("USER_NOT_FOUND", "User not found", 404);
-
Siempre capturar errores especificos. Nunca usar bloques catch vacios:
// Incorrecto try { ... } catch (e) { console.log(e); } // Correcto try { ... } catch (error) { if (error instanceof AppError) { logger.warn(error.code, error.message); } else { logger.error("UNEXPECTED_ERROR", error); throw error; } } -
Las funciones async deben tener limites de error. Cada handler async necesita un try/catch o debe usar el wrapper asyncHandler.
-
Registrar antes de relanzar. Si capturas y relanzas, registra el error primero para que aparezca en el monitoreo.
Adapta este ejemplo a los patrones reales de tu proyecto. El skill debe codificar un estándar que quieras que se imponga cada vez que Claude toque ciertos archivos.
## Paso 3: Configura un Hook PreToolUse
Crea barreras de protección que prevengan que Claude realice operaciones peligrosas. Agrega esto a tu `.claude/settings.json`:
```json
{
"hooks": {
"PreToolUse": [
{
"matcher": "bash",
"command": "bash -c 'BLOCKED_PATTERNS=\"rm -rf /|drop database|DROP TABLE|--force push|git push.*--force|truncate table\"; echo \"$CLAUDE_TOOL_INPUT\" | grep -qiE \"$BLOCKED_PATTERNS\" && echo \"BLOQUEADO: Este comando coincide con un patron peligroso. Por favor confirma con el usuario antes de proceder.\" && exit 1 || exit 0'"
},
{
"matcher": "write|edit",
"command": "bash -c 'echo \"$CLAUDE_TOOL_INPUT\" | grep -qiE \"(AKIA[0-9A-Z]{16}|sk-[a-zA-Z0-9]{48}|password\\s*=\\s*[\\x27\\\"][^\\x27\\\"]+[\\x27\\\"])\" && echo \"BLOQUEADO: Potencial secreto o credencial detectada en contenido del archivo\" && exit 1 || exit 0'"
}
],
"PostToolUse": [
{
"matcher": "write|edit",
"command": "bash -c 'FILE=$(echo \"$CLAUDE_TOOL_INPUT\" | grep -oP \"(?<=\\\"path\\\":\\s?\\\")[^\\\"]+\"); if [[ \"$FILE\" == *.ts || \"$FILE\" == *.tsx ]]; then npx tsc --noEmit 2>&1 | tail -5; fi; exit 0'"
}
]
}
}
Esta configuración:
- Bloquea comandos de shell destructivos antes de que se ejecuten
- Detecta potenciales secretos que se están escribiendo en archivos
- Ejecuta verificación de tipos de TypeScript después de cada edición de archivo
Paso 4: Configura un Servidor MCP
Conecta a Claude con un servicio externo que uses diariamente. Aquí tienes un ejemplo de integración con GitHub para .mcp.json:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
}
}
}
}
Configura tu token como variable de entorno:
# Agrega a tu perfil de shell (.bashrc, .zshrc, o perfil de PowerShell)
export GITHUB_TOKEN="ghp_tu_token_aqui"
Con esto configurado, Claude puede obtener PRs, leer issues, verificar estado de CI e interactuar con tus repositorios directamente.
Prueba esto: después de configurar el servidor MCP, pídele a Claude que "liste los pull requests abiertos en este repositorio" para verificar que la conexión funciona.
Paso 5: Crea un Subagente Personalizado
Construye un agente especializado para una tarea que se beneficie del aislamiento. Crea .claude/agents/test-analyzer.md:
# Agente Analizador de Tests
## Rol
Eres un agente especializado enfocado en analisis de calidad de tests. Examinas
suites de tests y proporcionas recomendaciones accionables.
## Capacidades
- Leer archivos de test y codigo fuente
- Ejecutar suites de test y analizar salida
- Identificar brechas de cobertura
- Encontrar patrones de tests fragiles o inestables
## Proceso
1. Lee todos los archivos de test en el directorio especificado
2. Ejecuta la suite de tests con cobertura: `npm test -- --coverage`
3. Analiza resultados buscando:
- Archivos con menos del 80% de cobertura
- Tests que carecen de assertions (falsos positivos)
- Tests con valores hardcodeados que deberian ser parametrizados
- Tests de casos borde faltantes (null, vacio, limites)
- Tests que dependen del orden de ejecucion
## Formato de Salida
Proporciona un reporte estructurado:
- **Resumen de Cobertura**: metricas generales y por archivo
- **Brechas Criticas**: funciones y ramas sin testear
- **Problemas de Calidad**: patrones fragiles, assertions faltantes
- **Recomendaciones**: tests especificos a agregar, priorizados por riesgo
Invoca este agente desde tu sesión principal:
Tu: Ejecuta el agente analizador de tests en el directorio src/services/.
Usa un worktree para aislamiento.
Paso 6: Empaqueta Todo en un Plugin
Toma todos los componentes que has construido y agrúpalos en un plugin. Crea la estructura:
my-toolkit/
plugin.json
commands/
analyze-tests.md
skills/
error-handling.md
hooks/
safety-checks.sh
agents/
test-analyzer.md
.mcp.json
Crea plugin.json:
{
"name": "my-dev-toolkit",
"description": "Personal developer toolkit with error handling standards, safety hooks, test analysis, and GitHub integration",
"version": "1.0.0",
"author": "tu-usuario",
"components": {
"commands": ["commands/analyze-tests.md"],
"skills": ["skills/error-handling.md"],
"hooks": ["hooks/safety-checks.sh"],
"agents": ["agents/test-analyzer.md"],
"mcp": [".mcp.json"]
},
"settings": {
"testCommand": "npm test",
"lintCommand": "npm run lint",
"buildCommand": "npm run build"
}
}
Instala y prueba:
# Instalar desde el directorio local
/plugin install ./my-toolkit
# Verificar que todos los componentes estan registrados
/plugin list
Paso 7: Configura la Integración CI/CD
Agrega Claude Code a tu flujo de GitHub Actions. Crea .github/workflows/ai-review.yml:
name: AI-Powered PR Review
on:
pull_request:
types: [opened, synchronize]
jobs:
ai-review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: actions/setup-node@v4
with:
node-version: '20'
- name: Install Claude Code
run: npm install -g @anthropic-ai/claude-code
- name: AI Code Review
env:
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
run: |
DIFF=$(git diff origin/main...HEAD)
echo "$DIFF" | claude -p \
"Revisa este diff de PR buscando bugs, problemas de seguridad y
problemas de estilo. Produce un resumen en markdown con secciones:
Critico, Advertencias, Sugerencias.
Se especifico — referencia nombres de archivo y numeros de linea." \
--max-turns 5 \
--output-format text > review.md
- name: Post Review
uses: actions/github-script@v7
with:
script: |
const fs = require('fs');
const review = fs.readFileSync('review.md', 'utf8');
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.issue.number,
body: `## AI Code Review\n\n${review}`
});
Almacena tu ANTHROPIC_API_KEY en la configuración de secrets del repositorio.
Paso 8: Prueba el Kit de Herramientas Completo
Recorre esta lista de verificación para confirmar que todo funciona junto:
# 1. Inicia una nueva sesion — CLAUDE.md deberia cargarse automaticamente
claude
# 2. Verifica el contexto del proyecto
Tu: Describe la arquitectura y las convenciones de testing de este proyecto.
# Claude deberia referenciar el contenido de tu CLAUDE.md
# 3. Prueba el skill — edita un archivo TypeScript
Tu: Agrega una nueva funcion a src/utils/validators.ts
# Claude deberia seguir tu skill de manejo de errores
# 4. Prueba el hook — intenta un comando peligroso
Tu: Ejecuta rm -rf /tmp/important-data
# El hook PreToolUse deberia bloquear esto
# 5. Prueba la integracion MCP
Tu: Lista los issues abiertos en este repositorio de GitHub
# Deberia retornar datos en vivo desde GitHub
# 6. Prueba el subagente
Tu: Ejecuta el agente analizador de tests en src/services/
# Deberia producir un reporte estructurado de calidad de tests
# 7. Prueba la integracion CI — crea un PR de prueba
# Haz push de una rama, abre un PR, verifica que el comentario de revision AI aparezca
Lista de Verificación para Producción
Antes de considerar tu kit de herramientas completo, verifica cada item:
- [ ] CLAUDE.md cubre arquitectura, estándares, testing y reglas críticas
- [ ] Al menos un skill automatiza tu patrón de codificación más frecuente
- [ ] Los hooks PreToolUse bloquean comandos destructivos y fugas de secretos
- [ ] El servidor MCP se conecta a tu servicio externo principal
- [ ] Al menos un subagente maneja una tarea de análisis especializada
- [ ] Todos los componentes están empaquetados en un plugin con plugin.json correcto
- [ ] El flujo CI/CD ejecuta revisión AI en pull requests
- [ ] Todos los componentes han sido probados individualmente y en conjunto
- [ ] No hay secretos ni credenciales hardcodeados en ningún lugar
- [ ] El plugin está bajo control de versiones y listo para distribución
Próximos Pasos
Tu kit de herramientas está construido. Aquí te indicamos hacia dónde ir desde aquí:
Itera y mejora. Usa tu kit de herramientas diariamente durante una semana, anota qué falta o dónde hay fricción, y agrega nuevos skills o hooks para abordar esas brechas.
Comparte con tu equipo. Sube tu plugin a un repositorio Git y ayuda a tus compañeros a instalarlo. Recopila feedback y lanza versiones mejoradas.
Explora el ecosistema MCP. Navega el registro de servidores MCP para integraciones con tus otras herramientas -- bases de datos, sistemas de monitoreo, plataformas de gestión de proyectos.
Contribuye de vuelta. Si construyes un skill o hook que resuelve un problema común, considera compartirlo con la comunidad de Claude Code. Los plugins open source ayudan a todos.
Mantente actualizado. Claude Code evoluciona rápidamente. Sigue las notas de release para descubrir nuevas funcionalidades que pueden mejorar tu kit de herramientas.
Comenzaste este curso instalando Claude Code y ejecutando tu primer comando. Lo terminas con un sistema de desarrollo completo, listo para producción, que automatiza tus flujos de trabajo, impone tus estándares, se conecta a tus herramientas y se extiende a través de CI/CD hacia todo tu pipeline de desarrollo. Cada funcionalidad que aprendiste -- desde CLAUDE.md hasta plugins y modo print -- ahora funciona en conjunto como un kit de herramientas unificado adaptado exactamente a cómo trabajas.