guild-agents 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 guild-agents
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,149 @@
+# Guild
+
+[![npm version](https://img.shields.io/npm/v/guild-agents)](https://www.npmjs.com/package/guild-agents)
+[![CI](https://github.com/guild-agents/guild/actions/workflows/ci.yml/badge.svg)](https://github.com/guild-agents/guild/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Node.js >= 18](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+
+A multi-agent framework for Claude Code.
+
+Sets up 8 specialized agents and 10 skill-based workflows as `.claude/` files in any project.
+
+## Installation
+
+```bash
+npm install -g guild-agents
+```
+
+Or run directly without installing:
+
+```bash
+npx guild-agents init
+```
+
+## Quick Start
+
+```bash
+npx guild-agents init
+```
+
+Interactive onboarding asks for project name, type, stack, and repo details, then generates the full agent and skill structure.
+
+Open Claude Code in your project and run:
+
+```
+/guild-specialize
+```
+
+This explores your actual codebase and enriches CLAUDE.md with real conventions, patterns, and stack details.
+
+Then start building:
+
+```
+/build-feature Add user authentication with JWT
+```
+
+This runs the full pipeline: evaluation, spec, implementation, review, and QA.
+
+`guild init` generates: CLAUDE.md, PROJECT.md, SESSION.md, `.claude/agents/` (8 agents), `.claude/skills/` (10 skills).
+
+## How It Works
+
+**Agents** are the WHO. Each agent is a flat `.md` file in `.claude/agents/` that defines identity, responsibilities, and process. Skills invoke agents via the Task tool when their expertise is needed.
+
+**Skills** are the HOW. Each skill is a workflow defined in `.claude/skills/*/SKILL.md` and invoked as a slash command. Skills orchestrate one or more agents through a structured process.
+
+**State** is maintained across sessions through three files:
+- `CLAUDE.md` — central enriched context (stack, conventions, rules)
+- `PROJECT.md` — project metadata (name, type, architecture)
+- `SESSION.md` — session continuity (current task, progress, next steps)
+
+After init, agents are generic. Running `/guild-specialize` reads the real codebase and tailors each agent to the project's specific stack and patterns.
+
+## Agents
+
+| Agent | Role |
+|---|---|
+| advisor | Evaluates ideas and provides strategic direction |
+| product-owner | Turns approved ideas into concrete tasks |
+| tech-lead | Defines technical approach and architecture |
+| developer | Implements features following project conventions |
+| code-reviewer | Reviews quality, patterns, and technical debt |
+| qa | Testing, edge cases, regression validation |
+| bugfix | Bug diagnosis and resolution |
+| db-migration | Schema changes and safe migrations |
+
+## Skills
+
+| Skill | Description |
+|---|---|
+| `/guild-specialize` | Explores codebase, enriches CLAUDE.md with real stack and conventions |
+| `/build-feature` | Full pipeline: evaluation, spec, implementation, review, QA |
+| `/new-feature` | Creates branch and scaffold for a new feature |
+| `/council` | Convenes multiple agents to debate a decision |
+| `/qa-cycle` | QA and bugfix loop until clean |
+| `/review` | Code review on the current diff |
+| `/dev-flow` | Shows current pipeline phase and next step |
+| `/status` | Project and session state overview |
+| `/session-start` | Loads context and resumes work |
+| `/session-end` | Saves state to SESSION.md |
+
+## CLI Commands
+
+```bash
+guild init                  # Interactive project onboarding
+guild new-agent <name>      # Create a custom agent
+guild status                # Show project status
+```
+
+## Generated Structure
+
+Running `guild init` creates the following in your project root:
+
+```
+CLAUDE.md
+PROJECT.md
+SESSION.md
+.claude/
+  agents/
+    advisor.md
+    product-owner.md
+    tech-lead.md
+    developer.md
+    code-reviewer.md
+    qa.md
+    bugfix.md
+    db-migration.md
+  skills/
+    guild-specialize/SKILL.md
+    build-feature/SKILL.md
+    new-feature/SKILL.md
+    council/SKILL.md
+    qa-cycle/SKILL.md
+    review/SKILL.md
+    dev-flow/SKILL.md
+    status/SKILL.md
+    session-start/SKILL.md
+    session-end/SKILL.md
+```
+
+All files are markdown, tracked by git, and work fully offline.
+
+## Requirements
+
+- Node.js >= 18
+- Claude Code
+- `gh` CLI (optional, for GitHub integration)
+
+## Contributing
+
+Two types of contributions:
+
+- **Agent and skill templates** (`src/templates/`) — improve agent definitions or skill workflows.
+- **CLI code** (`src/`, `bin/`) — bug fixes, new commands, onboarding improvements.
+
+See [CONTRIBUTING.md](.github/CONTRIBUTING.md) for details.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/bin/guild.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+/**
+ * Guild v1 — CLI entry point
+ * Usage:
+ *   guild init           — onboarding interactivo v1
+ *   guild new-agent      — crear un nuevo agente
+ *   guild status         — ver estado del proyecto
+ */
+
+import { program } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+
+program
+  .name('guild')
+  .description('Multi-agent framework for Claude Code')
+  .version(pkg.version);
+
+// guild init
+program
+  .command('init')
+  .description('Inicializar Guild v1 en el proyecto actual')
+  .action(async () => {
+    const { runInit } = await import('../src/commands/init.js');
+    await runInit();
+  });
+
+// guild new-agent
+program
+  .command('new-agent')
+  .description('Crear un nuevo agente')
+  .argument('<name>', 'Nombre del agente (lowercase, guiones)')
+  .action(async (name) => {
+    const { runNewAgent } = await import('../src/commands/new-agent.js');
+    await runNewAgent(name);
+  });
+
+// guild status
+program
+  .command('status')
+  .description('Ver estado del proyecto Guild')
+  .action(async () => {
+    const { runStatus } = await import('../src/commands/status.js');
+    await runStatus();
+  });
+
+program.parse();

package/package.json

@@ -1,13 +1,65 @@
 {
   "name": "guild-agents",
-  "version": "0.0.1",
-  "description": "A multi-agent framework for Claude Code",
-  "main": "index.js",
-  "keywords": ["claude", "claude-code", "agents", "ai", "workflow"],
-  "author": "tu-nombre",
+  "version": "0.1.0",
+  "description": "A multi-agent framework for Claude Code — specialized AI teams for every project",
+  "type": "module",
+  "files": [
+    "bin/",
+    "src/commands/",
+    "src/templates/",
+    "src/utils/",
+    "!src/utils/__tests__/"
+  ],
+  "bin": {
+    "guild": "./bin/guild.js"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src/",
+    "dev": "node bin/guild.js",
+    "prepublishOnly": "npm test && npm run lint"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "agents",
+    "ai",
+    "workflow",
+    "multi-agent",
+    "developer-tools",
+    "cli",
+    "framework",
+    "anthropic",
+    "ai-agents",
+    "automation",
+    "code-review",
+    "nodejs"
+  ],
+  "author": "",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/guild-ai/guild"
+    "url": "git+https://github.com/guild-agents/guild.git"
+  },
+  "homepage": "https://github.com/guild-agents/guild",
+  "bugs": {
+    "url": "https://github.com/guild-agents/guild/issues"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0",
+    "picocolors": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.1",
+    "vitest": "^4.0.18"
   }
-}
+}

package/src/commands/init.js

@@ -0,0 +1,141 @@
+/**
+ * guild init — Onboarding interactivo v1
+ *
+ * Flujo:
+ * 1. Verificar que no existe ya una instalacion de Guild
+ * 2. Recopilar: nombre, tipo, stack, GitHub, codigo existente
+ * 3. Generar PROJECT.md, CLAUDE.md, SESSION.md
+ * 4. Copiar agentes y skills
+ * 5. Instrucciones para /guild-specialize
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { generateProjectMd, generateSessionMd, generateClaudeMd } from '../utils/generators.js';
+import { copyTemplates } from '../utils/files.js';
+
+export async function runInit() {
+  console.log('');
+  p.intro(chalk.bold.cyan('Guild v1 — Nuevo proyecto'));
+
+  // Verificar instalacion existente
+  if (existsSync('.claude/agents')) {
+    const overwrite = await p.confirm({
+      message: 'Guild ya esta instalado en este proyecto. Reinicializar?',
+      initialValue: false,
+    });
+
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.cancel('Cancelado.');
+      process.exit(0);
+    }
+  }
+
+  // ─── Nombre ─────────────────────────────────────────────────────────────────
+  const name = await p.text({
+    message: 'Nombre del proyecto:',
+    placeholder: 'mi-proyecto',
+    validate: (val) => {
+      if (!val) return 'El nombre es requerido';
+    },
+  });
+  if (p.isCancel(name)) { p.cancel('Cancelado.'); process.exit(0); }
+
+  // ─── Tipo ───────────────────────────────────────────────────────────────────
+  const type = await p.select({
+    message: 'Tipo de proyecto:',
+    options: [
+      { value: 'webapp', label: 'Web app (React/Vue/Angular)' },
+      { value: 'api', label: 'API / Backend service' },
+      { value: 'cli', label: 'CLI tool' },
+      { value: 'mobile', label: 'Mobile (React Native)' },
+      { value: 'fullstack', label: 'Otro / Fullstack' },
+    ],
+  });
+  if (p.isCancel(type)) { p.cancel('Cancelado.'); process.exit(0); }
+
+  // ─── Stack ──────────────────────────────────────────────────────────────────
+  const stack = await p.text({
+    message: 'Stack principal:',
+    placeholder: 'ej: Next.js, Supabase, Vercel',
+    validate: (val) => {
+      if (!val) return 'El stack es requerido';
+    },
+  });
+  if (p.isCancel(stack)) { p.cancel('Cancelado.'); process.exit(0); }
+
+  // ─── GitHub ─────────────────────────────────────────────────────────────────
+  let github = null;
+  const hasRepo = await p.confirm({
+    message: 'Tiene repositorio GitHub?',
+    initialValue: true,
+  });
+
+  if (!p.isCancel(hasRepo) && hasRepo) {
+    const repoUrl = await p.text({
+      message: 'URL del repositorio:',
+      placeholder: 'https://github.com/org/repo',
+      validate: (val) => {
+        if (!val) return 'La URL es requerida';
+        if (!val.includes('github.com')) return 'Debe ser una URL de GitHub';
+      },
+    });
+    if (!p.isCancel(repoUrl)) {
+      github = { repoUrl };
+    }
+  }
+
+  // ─── Codigo existente ───────────────────────────────────────────────────────
+  const hasExistingCode = await p.confirm({
+    message: 'Tiene codigo existente?',
+    initialValue: true,
+  });
+
+  // ─── Generacion ─────────────────────────────────────────────────────────────
+  const spinner = p.spinner();
+  spinner.start('Generando estructura Guild v1...');
+
+  const projectData = {
+    name,
+    type,
+    stack,
+    github,
+    hasExistingCode: !p.isCancel(hasExistingCode) && hasExistingCode,
+  };
+
+  try {
+    await copyTemplates();
+    spinner.message('Generando CLAUDE.md...');
+    await generateClaudeMd(projectData);
+
+    spinner.message('Generando PROJECT.md...');
+    await generateProjectMd(projectData);
+
+    spinner.message('Generando SESSION.md...');
+    await generateSessionMd();
+
+    spinner.stop('Estructura creada.');
+  } catch (error) {
+    spinner.stop('Error durante la inicializacion.');
+    p.log.error(error.message);
+    process.exit(1);
+  }
+
+  // ─── Resumen ────────────────────────────────────────────────────────────────
+  p.log.success('CLAUDE.md');
+  p.log.success('PROJECT.md');
+  p.log.success('SESSION.md');
+  p.log.success('.claude/agents/    (8 agentes base)');
+  p.log.success('.claude/skills/    (10 skills)');
+
+  p.note(
+    'Abre Claude Code en este directorio y ejecuta:\n\n' +
+    '  /guild-specialize\n\n' +
+    'Este skill explorara tu codigo y enriquecera CLAUDE.md\n' +
+    'con la informacion real del proyecto.',
+    'Siguiente paso'
+  );
+
+  p.outro(chalk.bold.cyan('Guild v1 listo.'));
+}

package/src/commands/new-agent.js

@@ -0,0 +1,97 @@
+/**
+ * new-agent.js — Crea un nuevo agente v1 (archivo plano)
+ *
+ * Flujo:
+ * 1. Validar nombre (lowercase, guiones, sin espacios)
+ * 2. Verificar que Guild esta instalado
+ * 3. Verificar que el agente NO existe
+ * 4. Pedir descripcion del agente
+ * 5. Crear .claude/agents/[nombre].md con placeholder
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const AGENTS_DIR = join('.claude', 'agents');
+
+export async function runNewAgent(agentName) {
+  p.intro(chalk.bold.cyan('Guild — Nuevo agente'));
+
+  // Validar nombre
+  if (!isValidAgentName(agentName)) {
+    p.log.error(`Nombre invalido: "${agentName}". Solo lowercase, numeros y guiones.`);
+    p.log.info('Ejemplo: guild new-agent security-auditor');
+    process.exit(1);
+  }
+
+  // Verificar Guild instalado
+  if (!existsSync(AGENTS_DIR)) {
+    p.log.error('Guild no esta instalado. Ejecuta: guild init');
+    process.exit(1);
+  }
+
+  // Verificar que el agente NO existe
+  const agentPath = join(AGENTS_DIR, `${agentName}.md`);
+  if (existsSync(agentPath)) {
+    p.log.error(`El agente "${agentName}" ya existe.`);
+    process.exit(1);
+  }
+
+  // Pedir descripcion
+  const description = await p.text({
+    message: `Que hace "${agentName}"? (descripcion corta):`,
+    placeholder: 'ej: Evalua oportunidades de trading basado en analisis tecnico',
+    validate: (val) => !val ? 'La descripcion es requerida' : undefined,
+  });
+  if (p.isCancel(description)) { p.cancel('Cancelado.'); process.exit(0); }
+
+  // Crear agente
+  const spinner = p.spinner();
+  spinner.start(`Creando agente "${agentName}"...`);
+
+  try {
+    const content = `---
+name: ${agentName}
+description: "${description}"
+---
+
+# ${agentName}
+
+Eres ${agentName} de [PROYECTO].
+
+## Responsabilidades
+[Definir con /guild-specialize]
+
+## Lo que NO haces
+[Definir con /guild-specialize]
+
+## Proceso
+[Definir con /guild-specialize]
+
+## Reglas de comportamiento
+- Siempre lee CLAUDE.md y SESSION.md al inicio de la sesion
+`;
+
+    writeFileSync(agentPath, content, 'utf8');
+
+    spinner.stop(`Agente "${agentName}" creado.`);
+
+    p.log.success(`Archivo: ${agentPath}`);
+    p.note(
+      `Ejecuta /guild-specialize para que Claude\n` +
+      `genere las instrucciones completas de "${agentName}".`,
+      'Especializacion pendiente'
+    );
+    p.outro(chalk.bold.cyan(`Agente ${agentName} listo.`));
+  } catch (error) {
+    spinner.stop('Error al crear agente.');
+    p.log.error(error.message);
+    process.exit(1);
+  }
+}
+
+function isValidAgentName(name) {
+  return /^[a-z][a-z0-9-]*$/.test(name);
+}

package/src/commands/status.js

@@ -0,0 +1,58 @@
+/**
+ * status.js — Muestra el estado actual del proyecto v1
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export async function runStatus() {
+  if (!existsSync('PROJECT.md')) {
+    p.log.error('Guild no esta instalado. Ejecuta: guild init');
+    process.exit(1);
+  }
+
+  const projectMd = readFileSync('PROJECT.md', 'utf8');
+  const nameMatch = projectMd.match(/\*\*Nombre:\*\*\s*(.+)/);
+  const stackMatch = projectMd.match(/\*\*Stack:\*\*\s*(.+)/);
+  const projectName = nameMatch ? nameMatch[1].trim() : 'Proyecto';
+
+  p.intro(chalk.bold.cyan(`Guild — ${projectName}`));
+
+  if (stackMatch) {
+    p.log.info(chalk.gray(`Stack: ${stackMatch[1].trim()}`));
+  }
+
+  // Sesion activa
+  if (existsSync('SESSION.md')) {
+    p.log.step('Sesion activa');
+    const sessionMd = readFileSync('SESSION.md', 'utf8');
+    const taskMatch = sessionMd.match(/\*\*Tarea en curso:\*\*\s*(.+)/);
+    const stateMatch = sessionMd.match(/\*\*Estado:\*\*\s*(.+)/);
+    if (taskMatch && taskMatch[1].trim() !== '—') p.log.info(`  Tarea: ${taskMatch[1].trim()}`);
+    if (stateMatch) p.log.info(chalk.gray(`  ${stateMatch[1].trim()}`));
+  }
+
+  // Agentes
+  const agentsDir = join('.claude', 'agents');
+  if (existsSync(agentsDir)) {
+    p.log.step('Agentes');
+    const agents = readdirSync(agentsDir)
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''));
+    p.log.info(chalk.gray(`  ${agents.join(', ')}`));
+  }
+
+  // Skills
+  const skillsDir = join('.claude', 'skills');
+  if (existsSync(skillsDir)) {
+    p.log.step('Skills');
+    const skills = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    p.log.info(chalk.gray(`  ${skills.join(', ')}`));
+  }
+
+  p.outro('');
+}

package/src/templates/agents/advisor.md

@@ -0,0 +1,45 @@
+---
+name: advisor
+description: "Evalua ideas y da direccion estrategica antes de comprometer trabajo"
+---
+
+# Advisor
+
+Eres el guardian de dominio de [PROYECTO]. Tu trabajo es evaluar ideas y propuestas antes de que el equipo comprometa esfuerzo, asegurando coherencia con la vision y viabilidad del producto.
+
+## Responsabilidades
+
+- Evaluar propuestas de features y cambios contra la vision del proyecto
+- Identificar riesgos de negocio, dependencias ocultas y conflictos con funcionalidad existente
+- Aprobar, rechazar o ajustar ideas antes de que pasen a planificacion
+- Detectar scope creep y mantener el foco del proyecto
+- Validar que las prioridades propuestas tienen sentido estrategico
+
+## Lo que NO haces
+
+- No defines arquitectura ni approach tecnico — eso es del Tech Lead
+- No priorizas backlog ni escribes criterios de aceptacion — eso es del Product Owner
+- No revisas codigo — eso es del Code Reviewer
+- No implementas nada — eso es del Developer
+
+## Proceso
+
+1. Lee CLAUDE.md y SESSION.md para entender el estado actual del proyecto
+2. Analiza la propuesta en contexto del dominio y la vision de [PROYECTO]
+3. Identifica riesgos, dependencias y conflictos
+4. Emite tu evaluacion con el formato de salida
+
+## Formato de salida
+
+- **Evaluacion**: Aprobado / Rechazado / Requiere ajustes
+- **Razonamiento**: Por que esta decision (2-3 oraciones)
+- **Ajustes sugeridos**: Cambios concretos si aplica
+- **Riesgos identificados**: Lista priorizada de riesgos
+
+## Reglas de comportamiento
+
+- Siempre lee CLAUDE.md y SESSION.md antes de evaluar
+- Se conciso — el equipo necesita decisiones, no ensayos
+- Fundamenta cada evaluacion con razones concretas, no opiniones vagas
+- Si no tienes suficiente contexto, pide clarificacion antes de evaluar
+- Distingue entre riesgos reales y preferencias personales

package/src/templates/agents/bugfix.md

@@ -0,0 +1,48 @@
+---
+name: bugfix
+description: "Diagnostico y resolucion de bugs"
+---
+
+# Bugfix
+
+Eres el especialista en diagnostico y resolucion de bugs de [PROYECTO]. Llegas a cada bug sin el sesgo cognitivo del Developer original, lo que te da perspectiva fresca para encontrar la causa raiz.
+
+## Responsabilidades
+
+- Reproducir el bug de forma consistente antes de investigar
+- Identificar la causa raiz, no solo el sintoma
+- Proponer el fix minimo que resuelve el problema sin efectos secundarios
+- Implementar la correccion y verificar que no introduce regresiones
+- Documentar la causa raiz para prevenir bugs similares
+
+## Lo que NO haces
+
+- No implementas features nuevas — eso es del Developer
+- No validas comportamiento general — eso es de QA
+- No investigas errores triviales de compilacion o sintaxis
+- No defines approach tecnico — eso es del Tech Lead
+
+## Proceso
+
+1. Lee CLAUDE.md y SESSION.md para entender el contexto del proyecto
+2. Reproduce el bug con los pasos exactos del reporte
+3. Investiga la causa raiz: traza el flujo desde el sintoma hasta el origen
+4. Propone el fix minimo que resuelve el problema
+5. Implementa la correccion
+6. Verifica que el bug esta resuelto y no hay regresiones
+
+## Formato de resolucion
+
+- **Bug**: Descripcion del problema
+- **Causa raiz**: Que lo provoca y por que
+- **Fix aplicado**: Que se cambio y por que ese approach
+- **Verificacion**: Como se verifico que esta resuelto
+- **Prevencion**: Que se puede hacer para evitar bugs similares
+
+## Reglas de comportamiento
+
+- Siempre lee CLAUDE.md y SESSION.md antes de investigar
+- Nunca asumas la causa — reproduce primero, investiga despues
+- El fix debe ser minimo: resuelve el bug, no refactoriza el modulo
+- Si el fix requiere cambios grandes, escala al Tech Lead
+- Documenta la causa raiz aunque sea obvia — el equipo aprende de los bugs