Skip to content
Back to search

comite

MarketplaceWorks with Claude CodeGitHub

Comité de agentes para Claude Code: revisa planes antes de construir y cambios antes de entregar, como un estudio de primer nivel.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/grupovimo--comite/badge.svg)](/listings/grupovimo--comite)

HTML

<a href="/listings/grupovimo--comite"><img src="/api/listings/grupovimo--comite/badge.svg" alt="findsafeskills safety rating" /></a>

Install

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 14 lines
  1. {
  2. "name": "comite",
  3. "owner": { "name": "Grupo Vimo", "url": "https://github.com/grupovimo" },
  4. "metadata": { "description": "Comité de agentes para Claude Code" },
  5. "plugins": [
  6. {
  7. "name": "comite",
  8. "source": "./",
  9. "description": "Comité de agentes que revisa planes antes de construir y cambios antes de entregar, como un estudio de primer nivel.",
  10. "version": "0.2.0",
  11. "license": "MIT"
  12. }
  13. ]
  14. }
README.md · README · 140 lines · 1 finding marked
  1. # comite
  2. **Un comité de agentes para Claude Code que revisa tu trabajo como lo haría un estudio de primer nivel**, antes de construir y antes de entregar.
  3. *English summary below.*
  4. Cuando trabajás rápido con agentes, lo caro no es escribir el código: es iterar diez veces sobre algo que no hacía falta, o que llegó roto a las personas. `comite` pone un filtro en cada punta.
  5. - **Antes de construir (`plan`).** Ocho miradas discuten el plan contra tu repo:
  6. - producto: ¿hace falta?
  7. - dos usuarios escépticos
  8. - un abogado del diablo, que busca la versión más simple
  9. - diseño
  10. - seguridad y privacidad
  11. - negocio y costos
  12. - arquitectura
  13. Un juez decide si se construye, se ajusta o no se construye, y te devuelve el plan corregido.
  14. - **Después de construir (`revision`).** Corre sobre una copia limpia del repo:
  15. - Un mapa detecta qué tiene el producto: web, apps, pagos, IA, datos personales…
  16. - Se levanta una sola instancia con datos realistas y se capturan las pantallas a 375 px, en claro y en oscuro.
  17. - Corren en paralelo los ángulos que aplican, de un catálogo de 21.
  18. - Escépticos intentan refutar cada hallazgo.
  19. - Un desarrollador por área arregla lo confirmado, con commits chicos.
  20. - Las vueltas de control revisan esos arreglos y corren todas las pruebas.
  21. - Al final queda un informe con veredicto: *aprobar*, *aprobar con reservas* o *bloquear*.
  22. Nada se recorta en silencio: lo que no se miró figura en el informe como «no cubierto», y el costo de cada corrida queda medido.
  23. ## Requisitos
  24. - **[Claude Code](https://claude.com/claude-code) con la herramienta Workflow**, que orquesta varios agentes. Para saber si la tenés, preguntale a Claude «¿tenés la herramienta Workflow?». Sin ella, la skill corre un **modo reducido**: pocos ángulos con subagentes comunes y sin arreglos.
  25. - Para el modo revisión, un repo de git: el comité trabaja sobre un worktree.
  26. ## Instalar
  27. Como plugin de Claude Code (recomendado):
  28. ```
  29. /plugin marketplace add grupovimo/comite
  30. /plugin install comite@comite
  31. ```
  32. O con el instalador, que baja la última versión publicada:
  33. ```sh
  34. curl -fsSL https://raw.githubusercontent.com/grupovimo/comite/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 45 on GitHub
  35. ```
  36. - Queda en `~/.claude/skills/comite`.
  37. - `… | sh -s -- --proyecto` lo instala sólo en el repo actual.
  38. - `COMITE_REF=v0.2.0` fija una versión.
  39. - Si ya había una instalación, se guarda como `comite.bak`.
  40. También está el `comite.zip` de [Releases](https://github.com/grupovimo/comite/releases), para descomprimir en `~/.claude/skills/`.
  41. ## Usar
  42. En Claude Code, con tus palabras:
  43. > Pasá este plan por el comité antes de empezar.
  44. > Revisá con el comité los cambios de hoy antes de mergear.
  45. > Auditá la app entera con el comité, escala completa.
  46. Claude arma la copia limpia con `scripts/preparar.sh`, corre el flujo, lee el informe y te trae el veredicto, lo que tenés que decidir y las lecciones propuestas. Integrar y desplegar queda en tus manos.
  47. ## Hacelo tuyo: el perfil
  48. El comité rinde de verdad cuando conoce a tu equipo. Escribí un `.comite/perfil.md` en el repo, o `~/.claude/comite/perfil.md` para todos tus proyectos, a partir de [la plantilla](skills/comite/referencias/perfil.md). Ahí van:
  49. - **Estándar y diseño:** qué es «terminado», dónde están los diseños de referencia.
  50. - **Usuarios:** de ahí salen las personas que prueban el producto.
  51. - **Cómo levantar y probar**, y el **entorno de prueba**.
  52. - **Ángulos obligatorios:** los que corren siempre, como el modo oscuro.
  53. - **Decisiones protegidas:** el comité nunca las cambia; vuelven como pregunta.
  54. - **Reglas por ángulo:** las trampas de tu stack.
  55. Hay ejemplos completos para un [SaaS web](skills/comite/ejemplos/perfil-saas-web.md) y para [apps nativas](skills/comite/ejemplos/perfil-apps-nativas.md).
  56. Al lado del perfil va `.comite/lecciones.md`. Cada informe propone lecciones («esto se nos escapó, revisarlo siempre»); las que aprobás se inyectan en todas las corridas siguientes, y si nombran un ángulo, ese ángulo pasa a correr siempre. Así el comité aprende de sus errores.
  57. ## Escalas y costo
  58. | Escala | Plan | Revisión | Agentes en la revisión (típico · máximo) |
  59. |---|---|---|---|
  60. | `rapida` | 4 ángulos + juez | 3 ángulos, sin arreglos | 8–14 · 25 |
  61. | `media` | 8 ángulos + juez | 7 ángulos, arreglos, 1 vuelta de control | 18–35 · 55 |
  62. | `completa` | + contrajuez | todos los que aplican, hasta 2 vueltas | 40–70 · 105 |
  63. - **El máximo es un techo duro**, y lo comprueba la simulación del repo en cada cambio. Cada ángulo obligatorio suma 1 agente.
  64. - **Topes:** cada ángulo tiene un máximo de hallazgos (5, 8 o 12) y la verificación individual tiene el suyo; el resto se verifica en lotes por área.
  65. - **Presupuesto:** si fijaste uno de tokens y queda poco, toda la verificación pasa a lotes.
  66. - **Costo real:** el informe dice cuántos agentes usó cada fase.
  67. Una revisión `completa` de un producto mediano puede llevar una hora y varios millones de tokens. Empezá por `rapida`.
  68. ## Datos, seguridad y límites
  69. - **Qué sale de tu máquina:** el código, las capturas y las salidas de comandos que leen los agentes van al proveedor del modelo que use tu sesión de Claude Code. Usá datos de prueba, nunca dumps de producción.
  70. - **Las reglas son instrucciones, no un aislamiento.** A los agentes se les indica no hacer push ni deploy, no tocar producción, no salirse de la carpeta, bajar lo que levantan y no usar datos reales. Para que sea una garantía:
  71. - bloqueá push y deploy con `permissions.deny` en Claude Code
  72. - no dejes credenciales de producción en el entorno
  73. - para código de terceros, corré dentro de un contenedor o una VM, o con `soloInforme: true, levantar: false`
  74. - **Las reglas del repo no se pueden reescribir desde el cambio.** El perfil y las lecciones se leen de la rama base, y un cambio que los toca vuelve como pregunta bloqueante.
  75. - Reportá vulnerabilidades de la skill según [SECURITY.md](SECURITY.md).
  76. ## Estructura
  77. ```
  78. skills/comite/
  79. SKILL.md lo que lee Claude
  80. flujos/plan.js comité previo
  81. flujos/revision.js comité posterior
  82. referencias/ ángulos, severidad y veredicto, plantilla de perfil, forma del informe
  83. ejemplos/ perfiles de ejemplo
  84. scripts/ preparar.sh (copia limpia + flujo) y limpiar.sh
  85. pruebas/simular.mjs recorre los flujos con agentes simulados, peor caso incluido
  86. pruebas/scripts.sh prueba preparar.sh y limpiar.sh en un repo desechable
  87. ```
  88. Las contribuciones son bienvenidas. Antes de abrir un PR, corré `node pruebas/simular.mjs && sh pruebas/scripts.sh`. Es un proyecto que se mantiene en lo que da el tiempo, sin soporte garantizado.
  89. ## English summary
  90. `comite` is a Claude Code skill that runs a **committee of agents** over your work, twice:
  91. - **`plan`, before building.** Product, two skeptical users, a devil's advocate, design, security and privacy, business and cost, and architecture each review your plan against the repo. A judge rules *build*, *adjust* or *don't build*, and returns the corrected plan.
  92. - **`revision`, after building**, on a clean git worktree:
  93. - a map step detects what the product has
  94. - one shared local instance is started and screenshotted at 375 px, in light and dark
  95. - up to 21 review angles run in parallel
  96. - skeptics try to refute every finding
  97. - one developer per area fixes what survives, in small commits
  98. - control rounds re-check the fixes and run the full test suite
  99. - a report ends with a verdict: *approve*, *approve with reservations* or *block*
  100. Make it yours with a team profile (`.comite/perfil.md`): your standard, your users, how to run and test the product, mandatory angles, protected decisions and stack-specific rules. Lessons approved after each run are injected into every later run. Prompts and reports are in Spanish; the report follows your profile's language.
  101. Install with `/plugin marketplace add grupovimo/comite`, then `/plugin install comite@comite`. MIT licensed.
  102. ## Licencia
  103. MIT. Hecho por [Grupo Vimo](https://github.com/grupovimo).
install.sh · Bundled script · 38 lines · 1 finding marked
  1. #!/bin/sh
  2. # Instala la skill «comite» para Claude Code.
  3. # curl -fsSL https://raw.githubusercontent.com/grupovimo/comite/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 3 on GitHub
  4. # … | sh -s -- --proyecto sólo en el repo actual (.claude/skills)
  5. # COMITE_REF=v0.2.0 … | sh una versión fija (por defecto, la última publicada)
  6. set -eu
  7. REPO="${COMITE_REPO:-grupovimo/comite}"
  8. DESTINO="$HOME/.claude/skills"
  9. [ "${1:-}" = "--proyecto" ] && DESTINO="$(pwd)/.claude/skills"
  10. TMP="$(mktemp -d)"
  11. trap 'rm -rf "$TMP"' EXIT
  12. case "$0" in *install.sh) LOCAL="$(cd "$(dirname "$0")" && pwd)/skills/comite" ;; *) LOCAL="" ;; esac
  13. if [ -n "$LOCAL" ] && [ -f "$LOCAL/SKILL.md" ] && [ -z "${COMITE_REF:-}" ]; then
  14. ORIGEN="$LOCAL" # corrido desde un clon del repo
  15. else
  16. REF="${COMITE_REF:-}"
  17. if [ -z "$REF" ]; then
  18. REF="$(curl -fsSL "https://api.github.com/repos/$REPO/releases/latest" 2>/dev/null | sed -n 's/.*"tag_name": *"\([^"]*\)".*/\1/p' | head -1)"
  19. [ -n "$REF" ] || REF=main
  20. fi
  21. echo "Bajando comite ${REF}…"
  22. curl -fsSL "https://github.com/$REPO/archive/$REF.tar.gz" | tar -xz -C "$TMP"
  23. ORIGEN="$(find "$TMP" -maxdepth 3 -type d -path '*/skills/comite' | head -1)"
  24. fi
  25. [ -n "$ORIGEN" ] && [ -f "$ORIGEN/SKILL.md" ] || { echo "comite: no encontré la skill" >&2; exit 1; }
  26. mkdir -p "$DESTINO"
  27. if [ -e "$DESTINO/comite" ] || [ -L "$DESTINO/comite" ]; then
  28. rm -rf "$DESTINO/comite.bak"
  29. mv "$DESTINO/comite" "$DESTINO/comite.bak"
  30. echo "La instalación anterior quedó en $DESTINO/comite.bak"
  31. fi
  32. cp -R "$ORIGEN" "$DESTINO/comite"
  33. echo "Listo: skill instalada en $DESTINO/comite"
  34. echo "Siguiente paso: armá tu perfil a partir de $DESTINO/comite/referencias/perfil.md"
  35. echo "y guardalo en .comite/perfil.md (por repo) o en ~/.claude/comite/perfil.md (para todos)."

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.