djenriquez Agent Plugins
djenriquez/claude-plugins
Orquestrador de workflows dev com revisão de specs e implementação automática
Ver no GitHubColeçã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-plugins1 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
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:
- Writes a standalone spec from the conversation context
- Runs
/spec-reviewand revises the spec, using judgment to skip nits or irrelevant findings - Runs
/bits-planagainst the final spec - Runs
/bits-drainuntil the implementation queue is complete - Commits remaining work and runs
/pr-publish - Chooses whether the PR should target the default branch or stack on an existing PR branch
- Runs
/self-review-loopagainst the published PR - Posts
/assisted-review-heavyon 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:
| Specialist | Focus |
|---|---|
| clarity-reviewer | Ambiguity, contradictions, undefined terms, testable acceptance criteria |
| completeness-reviewer | Missing edge cases, error behavior, NFRs, state transitions |
| product-reviewer | Goal alignment, user value, success criteria, scope-to-value ratio |
| feasibility-reviewer | Technical feasibility, architectural fit, hidden complexity |
| api-reviewer | API surface, backward compat, protobuf conventions, idempotency |
| operations-reviewer | Failure modes, observability, rollback, SLO impact, on-call burden |
| scope-reviewer | Incremental delivery, dependency risks, timeline, scope creep |
| complexity-reviewer | Premature abstractions, over-engineering, speculative generality, accidental complexity |
| structure-reviewer | Package/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
- Checks out the PR branch and fetches unresolved review threads via the GitHub GraphQL API
- For each thread, analyzes the comment and decides whether to address (make a code change) or skip (with explanation)
- Commits and pushes all changes in a single commit
- Replies to each comment thread with the action taken or reason for skipping
- 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
- Prefers the local lean
/code-reviewskill when available - Uses fresh, context-free, read-only review against the local PR diff
- Parses the review output and triages each finding (address or skip)
- Runs tests/linters to verify changes, then commits and pushes only after a successful no-unresolved-Critical/High review state
- Uses file inventories and targeted local diffs for large PRs
- Runs optional external debate only for high-risk escalation, disputed blockers, or judgment-sensitive final states
- 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