convez.ai
SkillDevOps & InfraestruturaAvançado
dragon1404

DevPilot para Azure DevOps

dragon1404/superpowers-devpilot

Automatiza workflow Azure DevOps completo: design → implementação → PR

Ver no GitHub
InicialPluginScore · de 0 a 100

Automatiza o ciclo de vida completo de entrega de software no Azure DevOps, da fila de trabalho até pull request, usando dois comandos e dois pontos de aprovação. Orquestra design, implementação, testes e CI/CD com assistência do Claude Code, reduzindo trabalho manual e mantendo controle humano nas decisões críticas.

Instalação

$npx convez-ai dragon1404/superpowers-devpilot

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
1
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 4 meses
Versão
v0.9.6
Issues abertas
0
Contribuidores
2

Casos de uso

  • Automatizar pipeline de desenvolvimento end-to-end no Azure DevOps
  • Gerar design documents e planos de implementação com aprovação
  • Diagnosticar e corrigir falhas de CI/CD automaticamente
  • Reduzir overhead manual de code review e testes repetitivos

Veredito

Ferramenta poderosa para equipes Azure DevOps que buscam automação inteligente do ciclo de vida com controle humano preservado. Requer setup cuidadoso (superpowers + MCP) mas retorno de produtividade é significativo para workflows padronizados.

README

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

superpowers-devpilot

A Claude Code plugin that automates the software delivery lifecycle — from Azure DevOps backlog to pull request — using two commands and two approval checkpoints.


Overview

DevPilot orchestrates the full development workflow for a single Azure DevOps work item:

/dev-workitem <id>
  │
  ├─ Stage 1: Load work item from Azure DevOps
  ├─ Stage 2: Generate design document          ← you review & approve
  │
/dev-resume <id>  (design approved)
  │
  ├─ Stage 3: Generate implementation plan      ← you review & approve
  │
/dev-resume <id>  (plan approved)
  │
  ├─ Stage 4: Implement (automated)
  ├─ Stage 5: Code review (automated)
  ├─ Stage 6: Testing (automated)
  └─ Stage 7: Pull request (automated)

/dev-fix-pipeline <id>  (if pipeline fails on the PR)
  └─ Diagnose & fix CI failure, push fix, re-trigger pipeline

At each automated stage, DevPilot posts a [DevPilot] progress comment to your Azure DevOps work item, commits artifacts to a feature branch, and updates a local state file so the workflow can be resumed at any time.


Requirements

DependencyPurposeInstall
superpowersProvides the skills DevPilot orchestrates (brainstorming, TDD, code review, etc.)/plugin install superpowers@claude-plugins-official
Azure DevOps MCPConnects DevPilot to your Azure DevOps org (work items, repos, PRs)claude mcp add azure-devops --scope user -- npx -y @azure-devops/mcp <org>
Azure DevOps git remoteDevPilot parses your ADO org/project/repo from origin—

Installation

1. Install this plugin

Add the marketplace and install in two commands:

  • Register the marketplace:
/plugin marketplace add dragon1404/superpowers-devpilot
  • Install the plugin from this marketplace:
/plugin install superpowers-devpilot@dragon-marketplace

Then reload plugins:

/reload-plugins

2. Run the setup wizard

Once the plugin is installed, open Claude Code and run:

/dev-setup

/dev-setup checks whether superpowers and the Azure DevOps MCP server are installed and walks you through installing any that are missing — including exact configuration steps and PAT scope requirements.

Note: /dev-workitem also checks prerequisites at startup and will prompt you to run /dev-setup if anything is missing.

Manual setup (if you prefer)

superpowers plugin — install from the official Claude Code marketplace:

/plugin install superpowers@claude-plugins-official

Azure DevOps MCP — replace <org> with your ADO organization name:

claude mcp add azure-devops --scope user -- npx -y @azure-devops/mcp <org>

If authentication is required, set a Personal Access Token with these scopes: Work Items (Read & Write), Code (Read), Pull Requests (Read & Write).

Generate a PAT at: Azure DevOps → User Settings → Personal Access Tokens → New Token


Commands

/dev-setup

Checks whether all required dependencies are installed and guides you through installing any that are missing.

Run this once after installing the plugin. It will:

  1. Detect whether superpowers and the Azure DevOps MCP server are present
  2. Show a status table (FOUND / MISSING) for each
  3. For any missing dependency, provide exact installation steps including PAT configuration
/dev-setup

/dev-workitem <workItemId>

Starts a new DevPilot workflow for the given Azure DevOps work item.

What it does:

  1. Parses ADO org/project/repo from your git remote URL
  2. Fetches the work item (title, description, acceptance criteria, linked items)
  3. Creates a feature branch: feature/<workItemId>-<title-slug>
  4. Initialises a state file at .devpilot/state/<workItemId>.json
  5. Runs superpowers:brainstorming to produce a design document
  6. Reviews the design for unresolved questions — if any, posts them to the work item and pauses for your input (WAITING_FOR_DESIGN_CLARIFICATION)
  7. Saves the design to docs/design/<workItemId>-design.md and commits it
  8. Posts [DevPilot] Stage Completed: Design to the work item
  9. Pauses and prompts you to review the design

Example:

/dev-workitem 21238

/dev-resume <workItemId>

Resumes the workflow from the last completed stage.

At an approval gate (WAITING_FOR_DESIGN_APPROVAL or WAITING_FOR_PLAN_APPROVAL), running /dev-resume is the approval — it advances the workflow automatically.

At a clarification checkpoint (WAITING_FOR_DESIGN_CLARIFICATION or WAITING_FOR_PLAN_CLARIFICATION), update the work item description in Azure DevOps with your answers, then run /dev-resume to continue. DevPilot re-fetches the updated description before resuming.

After an interruption, it detects the current state and picks up exactly where it left off.

Example:

/dev-resume 21238

/dev-fix-pipeline <workItemId>

Investigates a failed CI pipeline on the PR for the given work item and automatically applies a fix.

What it does:

  1. Checks preconditions: state file exists, PR is open (prCreated: true), current branch matches
  2. Fetches the latest pipeline build for the feature branch (classic or YAML)
  3. If the build is not failed, stops with a status message — no action taken
  4. Retrieves the build log and classifies the failure as automatable or not
  5. If not automatable (infra/secrets/config): posts analysis to the work item and stops
  6. Invokes superpowers:systematic-debugging to diagnose and fix the error
  7. If no files were changed by debugging, posts findings to the work item and stops
  8. Runs affected tests locally; if sandbox-restricted, falls back to build-only verification
  9. If verification fails, posts details to the work item and stops without pushing
  10. Commits and pushes the fix; updates the state file (pipelineFixCount, lastPipelineFixAt)
  11. Posts [DevPilot] Pipeline fix applied to the work item with error summary and verification result

Example:

/dev-fix-pipeline 21238

If the pipeline fails again after the fix, run the same command to retry.


/pr-review <prUrl | workItemId>

Reviews an Azure DevOps pull request and posts findings as inline PR comments. Accepts either a PR URL directly or a work item ID (DevPilot resolves the linked active PR).

What it does:

  1. Resolves the target PR — from the URL, or by finding the active PR linked to the work item
  2. Fetches the PR diff (via the ADO API, or by checking out the source branch locally)
  3. Runs superpowers:requesting-code-review over the changes
  4. Posts each finding as an inline comment thread on the relevant file and line in the PR

Example:

/pr-review 42138
/pr-review https://dev.azure.com/org/project/_git/repo/pullrequest/123

/my-prs [project] [email]

Lists the active pull requests that involve you, so you don't miss reviews. Both arguments are optional and order-independent (the token containing @ is treated as the email).

PRs are grouped into three buckets:

  • Waiting for my review — you're a reviewer and haven't voted yet. Shows a [reviewed] tag if /pr-review has already posted a DevPilot review on the PR.
  • Already voted — you're a reviewer and have cast a vote (shows your vote: approved, approved with suggestions, waiting for author, or rejected)
  • PRs I created

Each PR line shows the target branch (e.g. → main) between the title and the author.

Project defaults to the current repo's ADO project (parsed from origin); email defaults to your session identity. Both can be remembered: DevPilot persists the resolved config and the last-run PR set to ./.devpilot/my-prs.json, and tags any PR that is new since your last check with [NEW].

Example:

/my-prs
/my-prs Payments
/my-prs Payments me@corp.com

Workflow Stages

#StageSkill invokedArtifact
1Load work item——
2Designsuperpowers:brainstormingdocs/design/<id>-design.md
3Implementation plansuperpowers:writing-plansdocs/plan/<id>-plan.md
4Implementationsuperpowers:subagent-driven-developmentsource code changes
5Code reviewsuperpowers:requesting-code-reviewdocs/review/<id>-review.md
6Testingsuperpowers:test-driven-developmentdocs/testing/<id>-testing.md
7Pull requestsuperpowers:finishing-a-development-branchPR in Azure DevOps

Approval Gates

There are exactly two human approval checkpoints, plus optional clarification checkpoints.

Gate 1 — Design

After Stage 2, DevPilot pauses with:

"Design complete. Review at docs/design/<id>-design.md. Run /dev-resume <id> to approve and continue."

Review the design document. When satisfied, run /dev-resume <id> to proceed to the implementation plan.

Gate 2 — Implementation Plan

After Stage 3, DevPilot pauses with:

"Implementation plan complete. Review at docs/plan/<id>-plan.md. Run /dev-resume <id> to approve and begin implementation."

Review the plan. When satisfied, run /dev-resume <id> to kick off automated implementation through to PR.

Clarification checkpoints (conditional)

During brainstorming, before asking any clarifying question in the session, DevPilot posts it to the work item as a [DevPilot] Design Question comment. After the developer answers, the answer is also posted as a [DevPilot] Design Answer comment. This ensures the full Q&A is preserved in Azure DevOps even if the session is lost.

After brainstorming or writing-plans, if unresolved questions remain in the output document, DevPilot posts them as a numbered ADO comment with suggested answers and pauses:

"Design clarifications needed. Questions posted to ADO work item. Update the description with your decisions, then run /dev-resume <id>."

Update the work item description in Azure DevOps with your answers, then run /dev-resume <id>. DevPilot re-fetches the updated description before continuing. If no questions arise, this checkpoint is skipped automatically.


State File

DevPilot persists workflow state at .devpilot/state/<workItemId>.json:

{
  "workItemId": 21238,
  "branch": "feature/21238-add-payment-gateway",
  "worktreePath": "../feature-21238-add-payment-gateway",
  "adoOrg": "https://dev.azure.com/myorg",
  "adoProject": "MyProject",
  "adoRepo": "MyRepo",
  "status": "WAITING_FOR_DESIGN_APPROVAL",
  "designCompleted": true,
  "designApproved": false,
  "planCompleted": false,
  "planApproved": false,
  "implementationCompleted": false,
  "reviewCompleted": false,
  "testingCompleted": false,
  "prCreated": false,
  "prUrl": null,
  "pipelineFixCount": 0,
  "lastPipelineFixAt": null,
  "lastUpdated": "2026-05-30T10:00:00Z"
}

Status values

StatusMeaning
DESIGNINGStage 2 in progress
WAITING_FOR_DESIGN_CLARIFICATIONPaused — questions posted to ADO, awaiting answers in work item description
WAITING_FOR_DESIGN_APPROVALPaused — awaiting /dev-resume to approve design
PLANNINGStage 3 in progress
WAITING_FOR_PLAN_CLARIFICATIONPaused — questions posted to ADO, awaiting answers in work item description
WAITING_FOR_PLAN_APPROVALPaused — awaiting /dev-resume to approve plan
IMPLEMENTINGStage 4 in progress
REVIEWINGStage 5 in progress
TESTINGStage 6 in progress
CREATING_PRStage 7 in progress
COMPLETEDWorkflow finished, PR created

Repository Structure (target project)

Files DevPilot writes into the project you are working on:

.devpilot/
└── state/
    └── <workItemId>.json       ← workflow state

docs/
├── design/
│   └── <workItemId>-design.md
├── plan/
│   └── <workItemId>-plan.md
├── review/
│   └── <workItemId>-review.md
└── testing/
    └── <workItemId>-testing.md

All artifacts are committed to the feature branch as they are produced.


Azure DevOps Integration

Remote URL formats supported

DevPilot automatically parses your ADO connection from git remote get-url origin:

FormatExample
HTTPShttps://dev.azure.com/{org}/{project}/_git/{repo}
SSHgit@ssh.dev.azure.com:v3/{org}/{project}/{repo}
Legacyhttps://{org}.visualstudio.com/{project}/_git/{repo}

ADO operations

OperationWhen
wit_get_work_itemStage 1 — fetch title, description, acceptance criteria
wit_get_work_items_batch_by_idsStage 1 — fetch linked work items
wit_add_work_item_commentAfter every stage — progress trail
repo_create_pull_requestStage 7 — create the PR
pipelines_get_builds/dev-fix-pipeline — find latest build for the branch
pipelines_list_runs/dev-fix-pipeline — fallback for YAML pipeline runs
pipelines_get_build_log/dev-fix-pipeline — fetch build log
pipelines_get_build_log_by_id/dev-fix-pipeline — drill into failed timeline records

Progress comments

Every stage posts a structured comment to your work item:

[DevPilot] Stage Completed: Design
Document: docs/design/21238-design.md
[DevPilot] Stage Completed: Pull Request
PR: https://dev.azure.com/myorg/MyProject/_git/MyRepo/pullrequest/42
[DevPilot] Design Clarifications Needed

The following questions need answers before the design can be finalised.
Suggested answers are provided — update the work item description with your
decisions, then run `/dev-resume 21238`.

1. Should the API be REST or GraphQL? (Suggested: REST — aligns with existing services)
2. ...
[DevPilot] Pipeline fix applied

Build: 1042 (20260605.3)
Error: Test assertion failure in PaymentServiceTests.ProcessRefund
Fix: Updated mock to return correct status code on partial refund
Files changed: src/PaymentService.cs, tests/PaymentServiceTests.cs
Verification: tests passed

The fix has been pushed to `feature/21238-add-payment-gateway`. The pipeline should re-run automatically.

Document uploads

The full content of each stage document is also posted to the work item as a comment, so the entire delivery trail lives in Azure DevOps even when docs/ is not committed to git:

[DevPilot] Design Document

<full markdown content of docs/21238-design.md>

The same happens for the implementation plan ([DevPilot] Implementation Plan), code review ([DevPilot] Code Review), and testing report ([DevPilot] Testing Report). These uploads are non-blocking — a failed post logs a warning and the workflow continues.


Local-Only Artifacts (gitignore)

By default, DevPilot commits its artifacts (docs/ and .devpilot/) to the feature branch. If you would rather keep them out of git history, add them to .gitignore:

docs/
.devpilot/

At startup, DevPilot checks .gitignore via git check-ignore. When a directory is ignored, DevPilot still writes the files locally (and still uploads doc content to the work item) but skips committing them:

  • docs/ ignored → design, plan, review, and testing docs are not committed
  • .devpilot/ ignored → the state file is not committed

This check runs once per /dev-workitem and /dev-resume invocation.


Resume Examples

Scenario A — Resume after design approval

# Workflow paused at WAITING_FOR_DESIGN_APPROVAL
# You reviewed docs/design/21238-design.md and it looks good

/dev-resume 21238
# → Marks design approved, generates implementation plan, pauses again

Scenario B — Resume after interruption mid-implementation

# Session ended while status was IMPLEMENTING

/dev-resume 21238
# → Detects IMPLEMENTING status, re-invokes subagent-driven-development with the plan

Scenario C — Workflow already complete

/dev-resume 21238
# → "Work item 21238 workflow is already completed. PR: https://..."

Scenario D — Resume after clarification checkpoint

# DevPilot posted questions to the ADO work item (WAITING_FOR_DESIGN_CLARIFICATION)
# You updated the work item description with your answers

/dev-resume 21238
# → Re-fetches updated work item, re-runs brainstorming with answers, continues

Scenario E — Fix a failed pipeline

# PR is open, CI pipeline failed on the feature branch

/dev-fix-pipeline 21238
# → Fetches latest build, reads log, classifies failure, applies fix, verifies, pushes

Git Branching

DevPilot creates and manages one branch per work item:

  • Branch name: feature/<workItemId>-<title-slug>
    • Slug = first 5 words of the work item title, lowercased, hyphenated
    • Example: feature/21238-add-payment-gateway-integration
  • All artifact docs are committed to this branch throughout the workflow
  • The PR is raised from this branch to the repository's default branch

Supported superpowers Skills

DevPilot requires the superpowers plugin and uses these skills:

SkillStage
superpowers:brainstormingStage 2 — Design
superpowers:writing-plansStage 3 — Implementation plan
superpowers:subagent-driven-developmentStage 4 — Implementation
superpowers:requesting-code-reviewStage 5 — Code review
superpowers:test-driven-developmentStage 6 — Testing
superpowers:finishing-a-development-branchStage 7 — Pull request
superpowers:systematic-debugging/dev-fix-pipeline — Pipeline failure fix

Non-Goals

  • Does not replace Azure DevOps sprint/board management
  • Does not auto-merge pull requests
  • Does not replace human review of design and plan documents

Future Enhancements

Phase 2

  • Sprint-aware planning
  • Multi-work-item orchestration
  • Automatic dependency detection between work items
  • Release note generation

Phase 3

  • Deployment automation
  • Environment validation
  • Post-deployment verification
  • Rollback recommendation generation

Author

Dragon — tangphamtunglong1404@gmail.com

License

MIT

Ver o original no GitHub

Bom para

Relacionados