Earl's Skill Pipeline Starter
earlduque/Earls-Skill-Pipeline-Starter
Pipeline issue-driven para desenvolvimento assistido por IA com skills reutilizáveis
Ver no GitHubTemplate de skills reutilizáveis para Claude Code que implementa um pipeline de desenvolvimento orientado por issues. Automatiza o fluxo completo: descoberta de issues, especificação colaborativa, implementação paralela e merge com rastreabilidade. Adapta-se a qualquer stack via arquivo CLAUDE.md no projeto.
Instalação
npx convez-ai earlduque/Earls-Skill-Pipeline-Starter1 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 triagem e especificação de issues antes da implementação
- Executar múltiplas issues em paralelo com agents isolados
- Manter contexto durável de requisitos no corpo das issues
- Reduzir loops de comunicação entre humanos e agentes de IA
Veredito

Solução bem estruturada para quem quer integrar IA no fluxo de desenvolvimento sem reinventar o processo. O modelo issue-driven é sólido, mas requer disciplina na especificação inicial para render frutos.
README
A tradução para o português deste README ainda está na fila.
Earl's Skill Pipeline Starter
A template repository of reusable Claude Code skills that form an issue-driven development pipeline. Pull them into any project to get an AI-assisted workflow out of the box.
Project-specific behavior — build commands, conventions, directory structure — is read from each project's CLAUDE.md. The skills adapt to whatever stack you're using.
Usage
Copy the .claude/skills/ folder into your project. You can use this Claude Code prompt to do it:
Use
gh repo cloneandgit sparse-checkoutto pull only the.claude/skills/folder from the public repoearlduque/Earls-Skill-Pipeline-Starterinto this project. Skip any files we already have in.claude/skills/. Do not copy READMEs.
Skills
Skills are slash-command workflows you invoke in Claude Code (e.g., /git-issues-start). They work together to form an issue-driven development cycle.
Issue Workflow
These skills form a pipeline: surface candidate issues, interview each one, work them, then wrap up.
(file issues manually) or
/find-issues→/issue-interview→/git-issues-start→/git-issues-end
| Skill | What it does |
|---|---|
| (manual) | File issues directly on GitHub as single-sentence titles as things come up, or paste a bug-report message into Claude and ask it to convert each item into its own issue. This is the usual entry point (/find-issues below is only for surfacing unreported problems). |
/find-issues | (Optional) Launches 5 parallel audit agents (bugs, inconsistencies, incomplete work, performance, UI/a11y) to scan the codebase, dedupes their findings, and lets you pick which ones to file as GitHub issues. Use intermittently to surface things no one has reported yet. |
/issue-interview | Walks through a collaborative Q&A on a GitHub issue to flesh out requirements, writes a spec into the issue body, and labels it ready for implementation. Supports single-issue, auto (batch non-interactive), and chain (batch interactive) modes. Also checks the existing ready queue for overlapping scope. |
/git-issues-start | Fetches all ready-labeled issues (or specific issue numbers), analyzes them, builds a parallelized execution plan, and launches isolated worktree agents to implement each one. Gathers each agent's changes into the main working tree as uncommitted changes for your review. |
/git-issues-end | Surveys the uncommitted changes, picks a commit strategy (per-issue / grouped / single) based on file overlap, creates commits that reference their issues via Closes #N, pushes, comments on each issue, and cleans up agent worktrees. |
Why this workflow works
The issue-driven structure reshapes how humans and agents split the work.
- You orchestrate, agents implement. Your attention goes to triage, spec, and review. Agents do the keystrokes. Higher leverage per minute of your time than sitting in the loop for every line.
- Intent is captured before code is touched.
/issue-interviewis a forcing function: the Q&A codifies the "why" and concrete acceptance criteria into the issue body before an agent runs. Implementing agents read a spec, not a vague request, so there are fewer wrong turns and less mid-work clarification. - The issue body becomes durable context. Research notes from Step 2.5, related-issue references from Step 2.6, acceptance criteria, and edge cases all live in the body. Comments are ephemeral; the body is what the implementing agent actually reads, and what future-you will grep six months later to trace a fix back to the decision that produced it.
- You can keep many things in flight without losing any. The
readyqueue is your backlog. File issues as they occur to you (or paste in a bug report), interview them when you have time, and they sit ready until you're ready to execute, with no context lost between steps. - Overlap and conflicts are caught early. Step 2.6 checks every new interview against the
readyqueue before the spec is written./git-issues-startdetects file-level collisions across the whole batch and serializes the ones that would conflict. You can keep filing issues without them silently tripping over each other. - Parallel execution without collisions. Worktree isolation runs independent issues concurrently; overlapping ones are serialized automatically. A batch of 8 issues completes in the wall-time of the longest one, not the sum of all eight.
- A real pre-commit review gate. All agent output lands in your working tree uncommitted. If something's off, you fix it with
git checkout -- <file>, notgit revert./git-issues-endthen commits, pushes, and auto-closes viaCloses #Nin one pass, so the safety net costs you nothing when everything's fine. - Batching beats one-at-a-time. Spec several issues, execute them as a batch, review once. Fewer context switches, cleaner mental model, more shipped per session than running issues end-to-end serially.
- Full audit trail, for free. Audit finding (optional) → spec in the issue body → commit message referencing the issue → push. Every shipped change is traceable from motivation to implementation.
Utility
| Skill | What it does |
|---|---|
/push | Stages all changes, commits, and pushes to remote with --follow-tags. |
/issue-summary | Generates a copy-paste-ready markdown table summarizing a range of GitHub issues (includes description, who requested it, and the result). Paste into Teams, Slack, GitHub, or anywhere. |