Dude Superpowers has to be on here and not for just the build portion. But its systematic debugging skill is impressive
Open the batch installer for this collection and generate commands only when you need them.
por obra
requesting-code-review es un flujo ligero para enviar el subagente `superpowers:code-reviewer` con un `git diff` limpio, requisitos y un resumen de cambios, de modo que las revisiones se hagan en el momento adecuado y generen comentarios accionables, priorizados por severidad, antes del merge.
por obra
subagent-driven-development es una skill para ejecutar planes de implementación con un subagente nuevo por tarea y revisar luego cada resultado en dos pasadas: primero el cumplimiento de la especificación y después la calidad del código. Incluye plantillas de prompt para el implementador, el revisor de especificación y el revisor de calidad de código.
por obra
systematic-debugging es una skill de depuración centrada primero en encontrar la causa raíz para abordar bugs, pruebas intermitentes, fallos de build y comportamientos inesperados. Conoce su flujo de trabajo de cuatro fases, los archivos complementarios y cuándo conviene usarla antes de proponer correcciones.
por obra
Instala y usa la skill test-driven-development para aplicar TDD estricto: primero escribe una prueba que falle, verifica el fallo, implementa el código mínimo y después refactoriza con seguridad.
por obra
using-git-worktrees ayuda a crear worktrees de Git aislados para trabajar en ramas nuevas, con selección de directorio, comprobaciones de ignore y flujos paralelos más seguros sin tocar tu checkout actual.
por obra
using-superpowers es una skill de inicio de sesión de obra/superpowers que obliga a consultar las skills antes de responder, para que los agentes encuentren y activen primero el flujo de trabajo adecuado.
por obra
verification-before-completion es una skill de verificación final que evita afirmaciones de cierre sin respaldo. Descubre cuándo usarla, cómo instalarla desde obra/superpowers y cómo vincular cada estado reportado con evidencia de verificación reciente.
por obra
writing-plans ayuda a convertir una especificación o documento de requisitos en un plan de implementación detallado, con orientación por archivo, secuencia de tareas, pasos de prueba y una pauta de revisión antes de empezar a programar.
por obra
writing-skills es una guía de Skill Authoring para crear, editar y validar skills de agentes con un flujo de trabajo guiado por pruebas. Explica los archivos clave, los requisitos previos y los pasos prácticos para escenarios de presión, pruebas base e iteración concisa de `SKILL.md`.
por obra
brainstorming es una skill de preimplementación que explora el contexto, plantea preguntas de aclaración de una en una y exige aprobar el diseño antes de escribir código. Incluye un acompañamiento visual opcional y un sólido soporte para la planificación de requisitos.
por obra
dispatching-parallel-agents es una skill de orquestación de agentes pensada para dividir tareas realmente independientes entre agentes separados, con contexto aislado y resultados coordinados.
por obra
executing-plans ayuda a los agentes a seguir un plan de implementación por escrito: lo revisan primero, ejecutan las tareas en orden, realizan las comprobaciones indicadas, se detienen ante bloqueos y derivan el cierre a un flujo final. Es especialmente útil para Project Management y otros entornos de entrega guiados por planes.
por obra
La skill finishing-a-development-branch ayuda a cerrar una rama de Git de forma segura una vez terminada la implementación. Verifica las pruebas, comprueba la rama base y luego presenta cuatro opciones claras: hacer merge en local, subir la rama para una Pull Request, conservar la rama o descartar el trabajo.
por obra
receiving-code-review te ayuda a verificar el feedback de PR antes de modificar el código. Úsalo para reformular comentarios de revisión, contrastarlos con el código, pedir aclaraciones sobre puntos poco claros y rebatir sugerencias cuando no encajan.
# How to Use Superpowers Skills Effectively Do not treat a task as “read the request and start coding.” Superpowers changes the default workflow: **check for relevant skills first, then let the skills determine how to work**. ## Core Rule Before responding, exploring files, asking clarifying questions, or implementing anything, first check whether a Superpowers skill applies. If a skill is relevant, use it first. User instructions define **what** to do. Skills define **how** to do it. --- ## Recommended Workflow ### 1. Start with `using-superpowers` Use this first for almost every task. Its job is to decide whether another skill should control the workflow. --- ### 2. Use `brainstorming` for new work or behavior changes Use it before: - building a feature - adding functionality - changing behavior - doing meaningful implementation work What to do: - understand the current context - ask clarifying questions one at a time - propose a few approaches with trade-offs - recommend one - get approval - write the design spec Do **not** code during brainstorming. --- ### 3. After approval, use `writing-plans` Turn the approved design into a concrete execution plan. The plan should include: - files to create or modify - small implementation steps - testing and verification steps A good plan should be clear enough for another agent to execute. --- ### 4. Use `using-git-worktrees` before implementation Prefer an isolated worktree instead of modifying the main workspace directly. This keeps feature work cleaner and safer. --- ### 5. Prefer `subagent-driven-development` for execution If subagents are available, use them to execute plan tasks one by one. Recommended pattern: - assign one focused task to one subagent - review for spec alignment - review for code quality - fix issues - mark the task complete --- ### 6. Use `executing-plans` if subagents are not available If you already have a written plan but are not using subagents, use `executing-plans`. Rules: - read the plan first - review it before starting - execute one task at a time - verify as you go - do not guess when blocked --- ## Supporting Skills ### `test-driven-development` Use when test-first implementation is appropriate: 1. write a failing test 2. confirm it fails 3. implement the minimum fix 4. run tests again --- ### `systematic-debugging` Use for bug fixing. Do not guess. Reproduce, narrow the problem, test hypotheses, find the root cause, then verify the fix. --- ### `requesting-code-review` / `receiving-code-review` Use review as a formal step, not an afterthought. --- ### `verification-before-completion` Before declaring work done, verify that: - tests pass - required commands succeed - the implementation matches the design and plan --- ### `finishing-a-development-branch` After implementation is complete: 1. verify tests 2. identify the base branch 3. present the completion options 4. clean up appropriately --- ## End-to-End Flow `using-superpowers` → `brainstorming` → `writing-plans` → `using-git-worktrees` → `subagent-driven-development` or `executing-plans` → supporting skills as needed → `verification-before-completion` → `finishing-a-development-branch` --- ## Operating Principle **User instructions define the goal. Skills define the method. Design before implementation. Plan before execution. Verify before completion.**
