convez.ai
SkillAutomaçãoAvançado
mhihasan

Coding Agent Skills

mhihasan/coding-agent-skills

Pipeline Jira-to-PR com revisão em camadas e juiz de IA antes do shipping

Ver no GitHub
BomPluginScore · de 0 a 100

Kit de skills para agentes de IA que implementam um pipeline Jira-to-PR com portais de revisão automática em cada etapa e um juiz de IA independente antes do merge. Integra planejamento, geração de tarefas, implementação e revisão de código com aprovações humanas obrigatórias em cada fase.

Instalação

$npx convez-ai mhihasan/coding-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
2
Forks
0
Acompanhando
0
Saúde
71%
Último commit
há 1 mês
Versão
v0.3.0
Issues abertas
1
Contribuidores
2

Casos de uso

  • Pipeline completo de ticket a código revisado pronto para merge
  • Revisão standalone de branches ou PRs com triagem por severidade
  • Geração de documentação arquitetural a partir de bases existentes

Veredito

Skill robusto que automatiza o workflow de desenvolvimento com gates rigorosos de revisão humana em cada etapa. Bem-pensado para evitar acúmulo de falhas, mas requer disciplina do time para não virar teatro de aprovações — o valor real está na revisão estruturada, não na automação cega.

README

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

coding-agent-skills

Skills for AI coding agents. A Jira-to-PR pipeline with self-review gates at every artifact boundary and an independent AI judge before you ship.

Review early, review often. A flaw surfaced before coding costs nothing. The same flaw after five tasks can invalidate all five.

Works with Claude Code, OpenCode, Cursor, and GitHub Copilot.

Agentic Coding Workflow

flowchart TD
    classDef pipe fill:#dbeafe,stroke:#3b82f6,color:#1e3a5f
    classDef judge fill:#fef3c7,stroke:#d97706,color:#78350f
    classDef sp fill:#dcfce7,stroke:#16a34a,color:#14532d
    classDef gate fill:#fed7aa,stroke:#ea580c,color:#7c2d12

    ST(["① pick up ticket\nset up a branch\n/picking-up-task"]):::sp
    PFT["② read the codebase\nwrite an implementation plan\n/planning-from-ticket"]:::pipe
    HG0{{"✋ you approve the plan\nor ask to revise it"}}:::gate
    GT["③ break the plan into\nsmall testable tasks\n/generating-tasks"]:::pipe
    HG1{{"✋ you approve the tasks\nor ask to revise them"}}:::gate
    RP{"④ AI reviews the plan\nbefore any code is written\n/reviewing-plan"}:::judge
    RPR["challenge or accept each finding\nupdate the plan\n/receiving-plan-review"]:::pipe
    HG2{{"✋ you approve the plan\nor ask to revise it"}}:::gate
    IT["⑤ write tests first, then code\ntask by task\n/implementing-tasks"]:::pipe
    RC{"⑥ AI reviews the code\nindependent of who wrote it\n/reviewing-code"}:::judge
    RCR["challenge or accept each finding\nfix the code"]:::sp
    HG3{{"✋ you approve the code\nor ask to fix it"}}:::gate
    CC(["⑦ clean up the commit history\nready to merge\n/crafting-commits"]):::sp

    ST --> PFT --> HG0 --> GT --> HG1 --> RP
    RP -->|PROCEED| HG2
    RP -->|DO NOT PROCEED| RPR
    RPR --> RP
    HG2 --> IT
    IT -->|all tasks done| RC
    RC -->|PASS| HG3
    RC -->|FAIL| RCR
    RCR --> RC
    HG3 --> CC

Design Principles

Review early, review often. A flaw before coding costs nothing. The same flaw after five tasks can invalidate all five.

Two review tiers, split by role. Self-review handles mechanical checks: cheap, always runs, catches placeholders and format issues. AI-as-judge handles subjective quality calls: fresh context, targeted, catches design and scope problems. Neither replaces the other.

Human gates are not optional. Every AI verdict requires your approval before the next step starts. REVIEW-LOG.md is the audit trail.

No self-preference bias. Judge subagents run in a fresh context with no access to the producing session's framing or justifications.

Auto mode removes pauses, not safeguards. Git boundaries and judge halts hold in both modes. auto is a speed setting, not a bypass.

Enter at any step. Every skill is independently usable. Start wherever the upstream artifact already exists.

Use cases

Full pipeline — ticket in, reviewed code out. Enter at any step if the upstream artifact already exists.

Standalone review — review any branch or PR without a plan file. Domain-filtered diff, triage-first report with BLOCKER / SHOULD-FIX / NIT severity.

Architecture docs — generate a design document from an existing codebase.

Installation

git clone git@github.com:mhihasan/coding-agent-skills.git
cd coding-agent-skills

# User scope — available in all projects
./install.sh --scope=user --tool=claude     # → ~/.claude/skills/   (Claude Code, OpenCode, Cursor)
./install.sh --scope=user --tool=copilot    # → ~/.copilot/skills/  (GitHub Copilot)
./install.sh --scope=user --tool=all        # → both

# Project scope — current project only
./install.sh --scope=project --tool=claude  /path/to/project   # → .claude/skills/
./install.sh --scope=project --tool=copilot /path/to/project   # → .github/skills/
./install.sh --scope=project --tool=all     /path/to/project   # → both

Safe to re-run: existing symlinks are updated, real directories are never overwritten.

Quickstart

Option A: full pipeline from a Jira ticket

/picking-up-task https://yoursite.atlassian.net/browse/PROJ-123

# Each skill tells you what to run next. The full sequence:
# /planning-from-ticket → /generating-tasks → /reviewing-plan
# → /implementing-tasks → /reviewing-code → /crafting-commits

Each skill is independently usable — enter at any point if the upstream artifact already exists.


Option B: review any branch right now

/reviewing-code

Reviews your staged diff by default, or pass branch, a PR number, or a diff file. Dispatches parallel AI judges, filters the diff by domain, and produces a triage-first report. No plan file needed.

Skills Reference

Per-skill input/output tables, flags, usage examples, and flow details: SKILLS.md.

Collaborative vs auto mode

Every pipeline skill accepts an optional auto argument. Collaborative is the default.

CollaborativeAuto
Forward-progress pauses (approve plan, confirm test plan, triage scope)Pause for humanProceed on own judgment
Git writes (commit / push / merge / PR)Human-initiatedNever self-initiated
Destructive overwrite of existing PLAN fileAskAsk
Judge halt (DO NOT PROCEED / FAIL verdict)HaltHalt
Unresolvable ambiguityAskAsk

auto removes conversational pauses but does not remove safeguards. Git boundaries and judge halts are invariants in both modes.

auto does not chain skills. Even in auto mode, each skill is a discrete command. /picking-up-task PROJ-123 fetches the ticket, sets up the branch, and stops. You decide when to invoke the next step.

Review tiers

TierWhoScopeWhen
Self-reviewThe producing skill checks its own outputObjective, mechanical checks only (placeholders, file coverage, format): verifiable yes/noEvery artifact boundary; runs in both modes
AI-as-judgeIndependent fresh-context subagent on a strong modelSubjective quality calls (scope, over-engineering, breaking changes, design) with BLOCKER/SHOULD-FIX/NIT severity gatereviewing-plan (before code) · reviewing-code (after code)

Self-review is cheap and always runs. AI-as-judge is targeted. The split exists because a producer evaluating its own subjective quality is the primary failure mode in AI evaluation.

Model selection

In Claude Code, each skill pins its own model — you don't need to switch manually. Other tools (OpenCode, Cursor, Copilot) ignore the model field and use their session model.

SkillModelWhy
picking-up-taskHaikuMechanical: fetch ticket, create file
generating-tasksSonnetTask decomposition, no deep design judgment needed
implementing-tasksSonnetTDD cycle needs solid reasoning, not Opus-level
crafting-commitsHaikuMechanical: read history, format commits
planning-from-ticketOpusHighest-stakes reasoning: codebase exploration + design decisions
reviewing-planOpusSubjective judgment before any code is written
reviewing-codeOpusWhere self-preference bias gets caught — model quality matters most here
Ver o original no GitHub

Bom para

Relacionados