convez.ai
SkillDesenvolvimento WebAvançado
iamsdas

Agent Skills

iamsdas/agent-skills

Skills encadeadas para ciclo completo de dev: escopo, plan, build, review, ship

Ver no GitHub
InicialPluginScore · de 0 a 100

Coleção de skills e subagents para Claude Code que cobrem todo o ciclo de vida de desenvolvimento: escopo, planejamento, construção, testes, revisão e deploy. Organiza fluxos encadeados para features, bugfixes e refatorações com checkpoints automatizados.

Instalação

$npx convez-ai iamsdas/agent-skills

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 3 dias
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Planejar e executar features com verificações de qualidade automáticas
  • Investigar e corrigir bugs com prevenção de recorrência
  • Revisar código profundamente antes de merge com análise de impacto
  • Coordenar tarefas paralelas via subagents especializados
  • Automatizar decisões arquiteturais e simplificação de código

Veredito

Arquitetura sólida e opinada para fluxos de dev estruturados. Ideal para quem quer padronizar ciclos feature→review→deploy com Claude, mas exige entender bem cada skill e quando encadeá-las. Não é plug-and-play casual.

README

A tradução para o português deste README ainda está na fila.

Agent Skills

A marketplace of Claude Code skills and subagents, organized into two plugins:

  • development/ — skills and subagents for the full feature/bugfix lifecycle: scoping, planning, building, testing, reviewing, and shipping.
  • utilities/ — general-purpose helpers: meta-skills for authoring skills/agents, conversation tooling, and integrations.

This README explains which skill to reach for, what order they chain in, and which are used passively (auto-invoked by Claude rather than chosen by you).


The development lifecycle

Skills are designed to chain. Two canonical flows:

Building a feature / change

scope-requirements      →  agree on WHAT and WHY (product intent, no implementation)
        ↓
writing-plans           →  turn the agreed scope into a step-by-step implementation plan
        ↓
using-git-worktrees     →  carve out an isolated workspace for the work
        ↓
executing-plans         →  execute the plan with review checkpoints (separate session)
   or
subagent-driven-development →  execute independent tasks via subagents in the current session
        ↓
requesting-code-review  →  verify the work meets requirements
        ↓
deep-review             →  deep pre-merge review (breaking changes, migrations, coverage)
        ↓
finishing-a-development-branch → decide how to integrate: merge, PR, or cleanup

Fixing a bug

investigate             →  diagnose: end-user impact, exact root cause, missing test
        ↓
(scope-requirements)    →  ONLY if the correct behavior needs product decisions
        ↓
writing-plans / test-driven-development → plan and fix
        ↓
requesting-code-review → deep-review → finishing-a-development-branch

scope-requirements vs. investigate — investigate looks backward (why is it broken?) and is the right entry point for a bug or error. scope-requirements looks forward (what should change?) and assumes you already know the desired behavior. For a bug, start with investigate; only reach for scope-requirements afterward if the fix involves real product decisions.

preventing-recurrence (cross-cutting) — not a phase but an event handler. Whenever a real defect or missing-logic gap is caught — during writing-plans refinement, deep-review, receiving-code-review, or investigate — those skills invoke preventing-recurrence to route the lesson into a durable mechanism (hook, skill/reviewer edit, project instruction, or memory) so the same class is caught automatically next time. It biases the fix toward the earliest point that could have caught the defect.


Subagents (always passive)

Subagents in development/agents/ are never invoked directly by you — skills and Claude dispatch them in the background (often in parallel) to do focused, context-isolated work. You'll see them referenced from within skills like investigate, deep-review, writing-plans, and scope-requirements.

AgentDispatched to…
code-explorerTrace execution paths and map architecture to understand existing behavior.
code-architectDesign a feature's architecture and produce an implementation blueprint.
focused-builderImplement a single well-scoped task (writes code, TDD, commits, self-reviews).
code-reviewerReview code for bugs, logic errors, security, and convention adherence.
code-simplifierSimplify recently written code for clarity without changing behavior.
tests-analyzerAssess test coverage quality and identify gaps / missing tests.
silent-failure-hunterFind swallowed errors, bad fallbacks, and inadequate error handling.
comment-analyzerCheck comments for accuracy, staleness, and missing rationale.
type-design-analyzerRate type design for invariant strength, encapsulation, and usefulness.

Ver o original no GitHub

Bom para

Relacionados