convez.ai
SkillAutomaçãoAvançado
djenriquez

djenriquez Agent Plugins

djenriquez/claude-plugins

Orquestrador de workflows dev com revisão de specs e implementação automática

Ver no GitHub
InicialPluginScore · de 0 a 100

Coleção de skills e agents para orquestração de workflows de desenvolvimento em Claude Code. Implementa fluxos completos desde especificação até pull request com revisão automática em múltiplas camadas especializadas.

Instalação

$npx convez-ai djenriquez/claude-plugins

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
3
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 1 semana
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Automatizar ciclo completo de desenvolvimento (spec → implementação → PR)
  • Revisar especificações técnicas com múltiplos especialistas
  • Gerenciar fila de implementação e commits incrementais
  • Executar auto-review e feedback assistido em pull requests

Veredito

Ferramenta sofisticada para times que buscam elevar a qualidade de specs e automatizar o fluxo dev, mas requer experiência com agents e integração Claude Code/Codex. O design por reviewers especializados é bem pensado, porém a curva de adoção é íngreme.

README

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

djenriquez agent plugins

Agent workflow plugins by @djenriquez, packaged for Claude Code and Codex.

Installation

Claude Code

/plugin marketplace add djenriquez/claude-plugins
/plugin install djenriquez-core

Codex

Codex marketplace metadata lives at:

.agents/plugins/marketplace.json

The djenriquez-core entry points to:

./plugins/djenriquez-core

Install djenriquez-core from that Codex marketplace entry after this repository is available as a Codex plugin marketplace/source.

Skills

/full-dev-flow

Runs the complete development workflow from the current session context to a reviewed pull request. This is the high-level orchestrator for the recurring "spec, plan, implement, publish, review" loop.

/full-dev-flow
/full-dev-flow build the workflow we discussed

The skill:

  1. Writes a standalone spec from the conversation context
  2. Runs /spec-review and revises the spec, using judgment to skip nits or irrelevant findings
  3. Runs /bits-plan against the final spec
  4. Runs /bits-drain until the implementation queue is complete
  5. Commits remaining work and runs /pr-publish
  6. Chooses whether the PR should target the default branch or stack on an existing PR branch
  7. Runs /self-review-loop against the published PR
  8. Posts /assisted-review-heavy on the PR after self-review succeeds

It also persists a workflow checklist before long-running phases so an interrupted agent can resume without losing the intended order.

/spec-review

Risk-scaled spec review that catches ambiguity, missing edge cases, architectural infeasibility, API design gaps, operational blindspots, and scope risks before implementation starts.

/spec-review path/to/spec.md
/spec-review #42                   # GitHub issue or PR (auto-detected)
/spec-review https://docs.google.com/...
/spec-review staged
/spec-review                       # uses conversation context

The skill selects only the specialist reviewers needed for the spec:

SpecialistFocus
clarity-reviewerAmbiguity, contradictions, undefined terms, testable acceptance criteria
completeness-reviewerMissing edge cases, error behavior, NFRs, state transitions
product-reviewerGoal alignment, user value, success criteria, scope-to-value ratio
feasibility-reviewerTechnical feasibility, architectural fit, hidden complexity
api-reviewerAPI surface, backward compat, protobuf conventions, idempotency
operations-reviewerFailure modes, observability, rollback, SLO impact, on-call burden
scope-reviewerIncremental delivery, dependency risks, timeline, scope creep
complexity-reviewerPremature abstractions, over-engineering, speculative generality, accidental complexity
structure-reviewerPackage/module boundaries, cohesion, public surface, layering

Review rigor scales with risk:

  • L0 (Minor): typo fixes, small clarifications — clarity + completeness only
  • L1 (Significant): new features, API additions — selected specialists, self-critique, targeted cross-review
  • L2 (Strategic): architecture changes, new services — all relevant specialists, optional external debate only when high-impact judgment needs stress-testing

Large specs are referenced by path and targeted excerpts rather than pasted into every reviewer prompt. Output is a deduplicated review with a binary verdict (APPROVED / REVISIONS NEEDED).

/interview

Lean planning interview for turning an issue, rough plan, or implementation idea into spec-ready decisions.

/interview
/interview probe this implementation plan

The skill asks a small number of high-signal question rounds, probes assumptions and failure modes, then returns decisions, accepted assumptions, open risks, and acceptance-criteria seeds. issue-to-spec uses this local interview path by default.

/code-review

Lean, risk-scaled code review. It starts with one generalist pass, then adds specialists only when the diff shows concrete risk.

/code-review #42
/code-review staged
/code-review unstaged
/code-review feature/my-branch

Review shape:

  • L0 (Routine): one concise generalist review, no specialist fan-out, no debate
  • L1 (Significant): generalist first, then at most two evidence-triggered specialists such as security, performance, testing, architecture, or maintainability
  • L2 (High-risk): bounded specialist set, capped at four unless the user asks for a heavy review

External debate is optional and used only to falsify uncertain high-severity findings, resolve specialist disagreement, or stress-test an L2 verdict. Large diffs use changed-file inventories and targeted local diffs instead of duplicating the full diff into every sub-agent prompt.

/issue-to-spec

Orchestrates the full investigation-to-spec workflow starting from a GitHub issue — explores the issue and codebase, interviews the user, authors a spec, assesses complexity, and conditionally launches /spec-review to harden it.

/issue-to-spec #42
/issue-to-spec 42

/handle-pr-feedback

Reads unresolved review comments on a GitHub PR, triages each one, makes code changes, pushes a commit, replies to every comment with the action taken, and resolves each thread.

/handle-pr-feedback #42
/handle-pr-feedback 42
  1. Checks out the PR branch and fetches unresolved review threads via the GitHub GraphQL API
  2. For each thread, analyzes the comment and decides whether to address (make a code change) or skip (with explanation)
  3. Commits and pushes all changes in a single commit
  4. Replies to each comment thread with the action taken or reason for skipping
  5. Resolves every thread

/self-review-loop

Iterative self-improvement loop for PRs. Launches a fresh, context-free sub-agent each turn to review the PR, then evaluates and applies the feedback. It succeeds only when no unresolved Critical or High findings remain; turn limits and oscillation detection are blocked states, not successful exits.

/self-review-loop #42
/self-review-loop 42
  1. Prefers the local lean /code-review skill when available
  2. Uses fresh, context-free, read-only review against the local PR diff
  3. Parses the review output and triages each finding (address or skip)
  4. Runs tests/linters to verify changes, then commits and pushes only after a successful no-unresolved-Critical/High review state
  5. Uses file inventories and targeted local diffs for large PRs
  6. Runs optional external debate only for high-risk escalation, disputed blockers, or judgment-sensitive final states
  7. Reports the review path, changes, skipped findings, verification evidence, and push status

The loop does not rely on imported nested review-team workflows by default. If the local lean /code-review skill cannot be invoked, the direct fallback follows the same staged L0/L1/L2 policy.

Acknowledgments

The original spec-review architecture was adapted from @abatilo's abatilo-core code-review skill. This plugin now uses a leaner staged review model for code review and lazy-loaded references for detailed workflow mechanics.

License

MIT

Ver o original no GitHub

Bom para

Relacionados