Przejdź do treści
Biblioteka skilli
DevOps i chmura · Automatyzacja

devops-multi-agent-team

/devops-multi-agent-team

Prowadzi zespół agentów DevOps: planowanie, badania, wdrożenia w osobnych drzewach roboczych, przeglądy, audyt bezpieczeństwa i testy, a push zatwierdza tylko QA.

Licencja
MIT
Ostatnia zmiana repozytorium
05.11.2026

Ocena i bezpieczeństwo

87/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność17 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
26
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 05.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi zespół agentów DevOps: planowanie, badania, wdrożenia w osobnych drzewach roboczych, przeglądy, audyt bezpieczeństwa i testy, a push zatwierdza tylko QA.

Oryginalny opis (EN)

Orchestrates a DevOps + Platform Engineering multi-agent loop: plan, research (docs/ + online media), implement in per-Coder side worktrees, pre-QA Markdown reviewers, Security (SOC 2 style review plus the static analysis for each language in the project), then QA. Only QA may give the OK to push. Works for any mix of languages through a per-project profile (.devops/project.md) built from languages.json: C, C++, assembly, Rust, Go, C#, Java, Kotlin, Python, TypeScript/JavaScript, CSS, shell, PowerShell, SQL, Terraform, containers and CI workflows. Use when the user asks for CI/CD, GitHub Actio

Jak działa

  1. Step 0: read the project profile
  2. When to use
  3. Optional MCPs + slash commands
  4. Team roles
  5. Orchestrator loop (async pods)
  6. Questions and interrupts
  7. Output rules
Sekcje z nagłówków SKILL.md, w oryginale · 337 linii, 2 519 słów
Podgląd SKILL.md
---
name: devops-multi-agent-team
description: >-
  Orchestrates a DevOps + Platform Engineering multi-agent loop: plan,
  research (docs/ + online media), implement in per-Coder side worktrees,
  pre-QA Markdown reviewers, Security (SOC 2 style review plus the static
  analysis for each language in the project), then QA. Only QA may give the
  OK to push. Works for any mix of languages through a per-project profile
  (.devops/project.md) built from languages.json: C, C++, assembly, Rust, Go,
  C#, Java, Kotlin, Python, TypeScript/JavaScript, CSS, shell, PowerShell, SQL,
  Terraform, containers and CI workflows. Use when the user asks for CI/CD,
  GitHub Actions, Kubernetes, Docker, Terraform, deploy pipelines,
  monitoring, runbooks, infra hardening, build-time or cost work, pre-merge
  quality/security gates, SOC 2 review, multi-agent or multi-team work, or
  explicitly invokes /devops-multi-agent-team, /goal, /create-subagent,
  /code-review, /repro, /triage, /story or /cleanup. Also use it to cut a large change into
  linked stories (OLD and NEW proposals with a catalog, dependency order and
  guidance), within one project or across two.
---

# DevOps multi-agent team

You are the **Orchestrator**. Coordinate plan, research, implement,
review, security, QA, observe, optimize, document, refactor, and
profile. One plan is source of truth. Roles are **async** pods, not
a linear queue.

## Step 0: read the project profile

Before anything else read `.devops/project.md` in the project root. It
is the one place that says which languages the project uses, which
layer each belongs to (web, backend, systems, scripting, infra), the
fast-validation and security commands for each, the departments, the
sensitive and never-stage paths, and the CI and MCP tooling that is
wired. Layers are sorting tags, never restrictions: any language can be used
for anything. It is built by `scripts/devops-setup.mjs install` from
`languages.json` and `services.json` (the plugin root, or `.devops/` in an
installed project; per-project tweaks go in `.devops/languages.local.json`)
and edited by hand afterwards.

- **No profile:** say so, run `node <plugin>/scripts/devops-setup.mjs
  detect`, show the human the result and ask before installing one.
  Do not guess commands from memory.
- **Precedence:** the project's own `AGENTS.md`, `CLAUDE.md` and rule
  files win over this skill; the profile wins over this skill's
  defaults. Where this skill's "no push until QA" gate and a project
  workflow differ, follow the stricter one.
- **Services and sandbox:** the profile also lists the services in use
  (containers, cloud, AI, VMs) and the sandbox every build, test and scan
  runs in. Read [services-and-sandbox.md](references/services-and-sandbox.md);
  a seat never runs a cloud, Kubernetes or deploy command that changes
  something, and never runs project commands on the host when an image exists.
- **Setup from chat:** with the `devops-multi-agent-team` MCP server
  connected, the human can ask for the setup ("set up the team for this
  project with Rust, TypeScript and Docker"); use `detect_project`, plan with
  `install_devops_team` (`apply=false`), show it, and apply only on their yes.
- **Several languages:** departments follow layers, and a change that
  crosses a boundary (an API shape, an FFI header, a schema) is staffed
  on both sides and validated with both sides' commands. See
  `LANGUAGES.md` (same places), "How the layers interact".

Prefer **MCP** for live CI/quality/security/ticket data; prefer
**slash skills** for packaged workflows. Catalog:
[references/agent-commands.md](references/agent-commands.md).

Spawn `/create-subagent` (the host's subagent tool: Cursor `Task`,
Claude Code `Agent`; prompts in `agents/`), naming the seat id in the
spawn description. Frontmatter `is_background: true`; every spawn
`run_in_background: true`.

**Teams work in parallel and review across teams.** No one reviews,
security-checks or QAs their own change, including after being
reallocated ([department-pods.md](references/department-pods.md),
Multiple teams).

**Team sizing and rotation.** One team per work item, 2 to 3 seats of
each of Researcher, Coder, Reviewer, QA and Security (10 to 15 per
team, a ceiling not a quota; cost and conflicts decide). A seat that
finished its role may take another role on a *different* item, keeping
its id; it never judges what it wrote, fixed or briefed (the
Orchestrator judges "briefed" from the registry). If no independent
seat is left it mints a new seat id (independence outranks the
3-per-function ceiling) or asks the human, never reusing an author.
Teams talk through the append-only `team-board.md` (informational, it
never authorizes anything).

**Seats have hash ids.** Every subagent seat is told apart by a seat
id, `<role>-<6 hex>` (for example `coder-0a0a0a`), minted by the
Orchestrator at spawn, never a capital letter
([role-identity.md](references/role-identity.md), Seat ids).

**Teams work dynamically.** Departments are named by function (from
the profile), not by seat. A department's brief done → its Coder
starts, and its Researcher **joins** that Coder. Do not start a
department's Coder until its Researcher is done. Primaries,
finish-the-line, QA swaps, send-backs, and QA triage pairing:
[references/department-pods.md](references/department-pods.md).

Working Markdown is under `devops-skill/thoughts/` and is **gitignored**.
Do not commit thoughts. Layout:
[references/thoughts-layout.md](references/thoughts-layout.md).
Identity, ask-paths, Coder notify:
[references/role-identity.md](references/role-identity.md).
Push JSON: [references/push-json.md](references/push-json.md).
Do not `git add` anything under `devops-skill/thoughts/` (both folders are in `.gitignore`).

**Only QA may give the OK to push.** Review Satisfied, Security Clear,
and the Orchestrator do not authorize a push. Do not push, publish,
open or update a PR, merge, or submit until QA marks PASS. Every
change except review-bot feedback fixes (see
[qa-publish-policy.md](references/qa-publish-policy.md), "Review-bot
feedback") gets Security's review first; Clear does not authorize a
push either.

### Reviewer entrypoint (before QA)

1. Documentation & Research writes a brief (`docs/` + online media +
   thoughts under `devops-skill/thoughts/non-final/`).
2. Coder writes the **Push JSON** and a Handoff `To: Reviewer`
   **before the first review** (`closes` may be empty). Schema:
   [push-json.md](references/push-json.md).
3. Reviewers compare that JSON to the **side-branch** tree vs
   `<integration-base>` ([side-work.md](references/side-work.md)) in
   `devops-skill/thoughts/non-final/review-<seat-id>.md`. An omitted or
   wrong hunk is a finding.
4. Coder fixes on the side-branch, updates the Push JSON, and notifies
   Reviewers. Either side may Push again until **Satisfied**. If Lean is
   present, ask the person once at the start of a goal that changes pure logic
   ("Use Lean to specify and prove the core logic first, and to help review
   and QA? (yes/no)"; the profile's `Lean default` can answer it), and again
   if a thread reaches `Formal check rounds` (default 3) still disputing
   what pure code does. A plain yes turns it on for the goal: Researchers
   pick formal targets, Coders write the Lean and a write-up for advanced
   logic (basic logic stays plain English), QA runs the Lean gate
   ([formal-check.md](references/formal-check.md)).
   Satisfied does **not** authorize a push.
5. Then **Security**: a full review on every change (except review-bot
   feedback fixes) ([soc2-review.md](references/soc2-review.md)),
   which includes the static analysis the profile names for each
   affected language, plus any security MCP that is installed.
6. Then **QA**. QA owns
   [qa-publish-policy.md](references/qa-publish-policy.md) and is the
   **only** role that may give the OK to push (except review-bot
   feedback fixes outside the exceptions in that file). QA records
   `Publish gate: PASS` or `BLOCKED` in `qa-<seat-id>.md`.
7. After PASS, the Orchestrator cherry-picks the approved SHAs, and a
   QA seat that is not an author of the integrated tree re-approves
   it. The authors are the union of the Handoff `Authors:` and the
   Push JSON `authors` of every cherry-picked SHA, the Orchestrator's
   conflict fixes included; a seat is refused when its seat id or its
   handle is in that set. The Orchestrator pushes only after the human
   authorizes that push ([thoughts-layout.md](references/thoughts-layout.md),
   One push). Check `git diff --stat <integration-base>...HEAD` for
   process files after any strip. Do not commit process notes.

### Virtual PR and virtual git

Work in progress lives in the **virtual PR**: the review thread, Push JSON,
handoffs, research and QA notes under `devops-skill/thoughts/` (gitignored), and
each Coder's code in a detached local worktree handed over by commit SHA.
Nothing reaches the real branch, and no real PR is opened or updated, until
Security is Clear and QA marks PASS; then the Orchestrator cherry-picks the
approved SHAs, QA re-approves the integrated tree, and the Orchestrator pushes
once after the human authorizes it. The full logic, invariants and the
multi-branch merge rule: [virtual-git.md](references/virtual-git.md).

### More rules every seat reads

| Topic | File |
|-------|------|
| **Clean code** (names, small functions, DRY with care, no magic numbers, simplicity) | [clean-code.md](references/clean-code.md) |
| **Formal check with Lean 4** (optional; proof-first in research and code, write-ups for advanced logic, a QA gate) | [formal-check.md](references/formal-check.md), [proof-writeup-template.md](references/proof-writeup-template.md) |
| **Clean-code topics** (error handling, boundaries, unit tests, Law of Demeter, special case, feature envy, overengineering) | [clean-code-topics.md](references/clean-code-topics.md) |
| **Single purpose, closed for modification, Liskov substitution** (with the Shape and Bird examples) | [oop-principles.md](references/oop-principles.md) |
| Documentation first, module mind map, reuse | [research-and-reuse.md](references/research-and-reuse.md) |
| Comments and doc comments (Reviewers strict) | [comment-standards.md](references/comment-standards.md) |
| Failed checks: monitor, auto-correct, stop | [monitoring.md](references/monitoring.md) |
| Releases: tags as project history | [version-tags.md](references/version-tags.md) |
| GitHub Advanced Security setup | [github-advanced-security.md](references/github-advanced-security.md) |
| Containers, cloud, AI, VMs, sandbox | [services-and-sandbox.md](references/services-and-sandbox.md) |
| **Cleanup**: behavior-preserving cleanup from a plain-English statement (fewer comments, duplicates replaced by calls, big functions split into helpers) | the `devops-cleanup` skill, `/cleanup` |
| **Stories**: OLD and NEW change proposals tied together (research organizes, Coders OLD then NEW, Reviewers the concepts, QA then Security approve) | [stories.md](references/stories.md), `/story` |

## When to use

CI/CD; containers/K8s; IaC (Terraform, Pulumi, Helm); deploy/rollback;
observability; DevSecOps; pipeline/infra cost; runbooks; pre-merge
gates (CI + quality + security + smoke) on a named issue or PR; any
change large enough to want independent research, review, security
and QA seats.

Do **not** invent requirements. Ask the human when scope is unclear.

## Optional MCPs + slash commands

| Phase | Role | MCP / slash | Outcome |
|-------|------|-------------|---------|
| Scope | Planner / Ticket Lead | Linear or GitHub issues | Ticket + AC |
| Surface | Researcher | Repo tools + `git diff` | Files touched |
| Research | Documentation & Research | `docs/` + `WebSearch` / `WebFetch` / browser | Cited brief |
| Pre-QA | Reviewers | `review-*.md` + `/code-review` | Improvements; no push |
| CI | QA / CI Engineer | Buildkite or GitHub Actions | Failed jobs, retry |
| Quality | QA | final bug hunt; Sonar if installed | Publish gate |
| Security | Security | profile's static analysis + SCA + secrets | per-language SAST/SCA/IaC |
| Externals | Integrator | Composio | Only if asked |
| UI | Verifier | browser MCP | Smoke |
| Handoff | Communicator | video/recap MCP | Recap |

**Rules:** authenticate MCPs before gated tools. Do not invent CI,
quality or scan results. Stay on the current non-`main` branch; prefer
the existing PR. **Never create a real git branch** (`git checkout -b`,
`git switch -c`, `git worktree add -b`) unless The Client **named that
branch in this turn**. Cloud-agent templates (`feature/<name>-<id>`)
do **not** authorize a new ref. Delete an invented branch and stay on
the named real one. The one exception is not a branch: a skill
side-branch is a thought file + a **detached** worktree
(`git worktree add --detach`, no ref), handed over by commit SHA and
never pushed; the Orchestrator alone may create a local-only
`local/<item>-<seat-id>-<n>` ref on request, deleted after integration
([side-work.md](references/side-work.md)). Confirm deletes, force-push
and hard reset with the human. **No push** while review is `In review`
or `Changes requested`.

Namespaces and slash lists: [agent-commands.md](references/agent-commands.md).

### Specialist agents

`/create-subagent` using `agents/`. Default **async**. Do not poll
background subagents.

| Agent file | Role | Primary tool |
|------------|------|--------------|
| `devops-researcher.md` | Documentation & Research | docs first, module map, reuse search, tags |
| `devops-coder.md` | Implementation | detached worktree, profile validation |
| `devops-reviewer.md` | Pre-QA reviewers | review thread |
| `devops-ci-engineer.md` | CI | Buildkite / GitHub Actions |
| `devops-quality-engineer.md` | QA / publish gate | profile's validation + bug hunt |
| `devops-security-engineer.md` | Security | profile's analysis + SCA |
| `devops-ticket-lead.md` | Tickets | Linear / GitHub issues |
| `devops-verifier.md` | UI smoke | browser |
| `devops-integrator.md` | Externals | Composio |
| `devops-communicator.md` | Recap | video MCP |

**A. Pre-merge** — Ticket Lead → Research brief → Coder → Reviewers → Security → QA (only role that may OK a push).

**B. Red CI** — list failed runs → failed jobs → logs → reproduce → fix → retry.

**C. Supply-chain** — dependency scan per language (`npm audit`,
`cargo audit`, `pip-audit`, `govulncheck`, ... from the profile) →
ticket comment.

## Team roles

Label every substantive reply with the active role, e.g. `[Planner]`; a spawned seat adds its id, e.g. `[Coder coder-0a0a0a]`.

- **Planner** — `/goal` when the human named X. Plans in
  `devops-skill/thoughts/non-final/`; durable docs in `docs/`.
- **Researcher** — reads documentation first (Markdown, LaTeX, code
  comments), maps the modules (Mermaid mind map), double-checks reuse and
  writes the reuse map; online media last; then **join the Coder of the same
  department** ([research-and-reuse.md](references/research-and-reuse.md)).
- **Coder** — implement on a **skill side-branch** (the Coder's own
  detached git worktree off the integration SHA, no ref; never
  pushed; stage by explicit path; no shared-checkout commits until QA
  PASS). Claim shared files on `team-board.md` before editing. Write
  Push JSON, Coder→Reviewer `qa` comments, and a Handoff **before the
  first review** ([side-work.md](references/side-work.md)). Follow
  [comment-standards.md](references/comment-standards.md) and extend existing
  code instead of re-implementing it.
- **Reviewers** — strict on comments and on re-implemented code (both
  blocking); compare Push JSON to the side-branch diff vs
  `<integration-base>`; Handoff on send-back
  ([role-identity.md](references/role-identity.md)). Satisfied does
  **not** authorize a push.
- **QA** — after Satisfied + Security Clear. `/code-review`: look; **do
  not edit**. `/repro` as needed. Fail → clean-environment review,
  Handoff `To: Coder`. When QA is blocked, sends back, or is not
  pleased: open `triage-<seat-id>.md`; the department's Researcher
  joins the coder who picks it up
  ([department-pods.md](references/department-pods.md),
  [triage-template.md](references/triage-template.md)). PASS only when
  AC, tests, the Security verdict and the final bug hunt hold.
- **Observability / Optimization / Documentation / Refactoring /
  Security / Performance** — after Satisfied, Security before QA. Docs
  match the implementation. No premature complexity.

## Orchestrator loop (async pods)

Staff each item's pods with 2 to 3 subagents per function and
rebalance idle seats to busy functions by seat rotation
([department-pods.md](references/department-pods.md)). The
Orchestrator spawns waves, keeps `team-board.md` and
`seat-registry.md` current, integrates approved items by cherry-pick
(re-running tests after each, QA re-approving the integrated tree) and
**never codes**; it resolves only mechanical conflicts and is then an
Author.

| Pod | Roles (spawn together) | Starts when |
|-----|------------------------|-------------|
| **research** | Planner, Researcher, Ticket Lead | Immediately |
| **implement** | Coder (Researcher of that department joins) | Brief exists *or* surface known |
| **review** | 2 to 3 Reviewers | Coder has a local diff |
| **security** | Security | Reviewers mark Satisfied |
| **qa** | QA, CI Engineer, Verifier | Security clear (overlap allowed) |
| **docs** | Documentation, Communicator | Implementation is documentable |

```text
research  ∥  implement  ∥  review   (department rules apply)
security  →  qa  →  docs
push      →  NEVER until QA marks PASS
            After PASS: thoughts → final/ (local); the Orchestrator
            pushes only after the human authorizes that push, keeping
            approved Coder commits
repeat    →  until PASS; QA blocked/send-back → triage;
            the Researcher joins the Coder who picks it up
```

Checklists: [references/devops-loop.md](references/devops-loop.md).

## Questions and interrupts

Ask-paths: [role-identity.md](references/role-identity.md). Questions
from Coders and Researchers go first to the standing Review, Security
and QA subagents by topic. Orchestrator is the only role that asks The
Client unless the human spoke first.

Treat human instructions as a **side sprint**. Pause only conflicting
work. Start from research, then code. Stay on the current **real**
branch. An interrupt does **not** authorize a push.

## Output rules

State the speaking role. Show plans, diffs, commands/logs as the role
acts. Redact tokens, secrets and credentials from anything shown. Keep
work deterministic. Never invent requirements.

```markdown
## DevOps multi-agent report

**Goal:** …  **Branch / PR:** <current branch> (#<n>)
**Languages:** <ids from the profile touched by this change>
### Blockers / CI / QA bug hunt / Quality / Security / Verification
- Validation per language: PASS / FAIL / NOT RUN
- Security review: Clear / Findings (blocker n, high n) · Static analysis per language: ran / CI / NOT RUN
- Final bug hunt: PASS / BLOCKED · New unresolved findings: N · Publish gate: PASS / BLOCKED
### Next actions
1. …
```

```text
[Orchestrator] Interpreting request → <one-line goal>
/goal: persist X; loop until X
/create-subagent: spawn roles asynchronously (department-pods.md)
Next: [Planner] draft plan
```
Pliki w paczce (26)
  • SKILL.md 19 KB
  • references/agent-commands.md 3 KB
  • references/clean-code-topics.md 13 KB
  • references/clean-code.md 8 KB
  • references/comment-standards.md 8 KB
  • references/department-pods.md 16 KB
  • references/devops-loop.md 6 KB
  • references/formal-check.md 8 KB
  • references/github-advanced-security.md 2 KB
  • references/monitoring.md 3 KB
  • references/oop-principles.md 9 KB
  • references/proof-writeup-template.md 2 KB
  • references/push-json.md 4 KB
  • references/qa-publish-policy.md 13 KB
  • references/research-and-reuse.md 6 KB
  • references/review-thread-template.md 3 KB
  • references/role-identity.md 8 KB
  • references/services-and-sandbox.md 4 KB
  • references/side-work.md 9 KB
  • references/soc2-review.md 7 KB
  • references/stories.md 7 KB
  • references/story-template.md 2 KB
  • references/thoughts-layout.md 4 KB
  • references/triage-template.md 1 KB
  • references/version-tags.md 2 KB
  • references/virtual-git.md 4 KB

Wersje

W bazie nie ma innych skilli o nazwie devops-multi-agent-team.

Migawka bazy z 13.11.2026 · wersja paczki 16ac0a4529d0 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90check-devops
    Audytuje projekt według listy 312 punktów z backendu, bazy, bezpieczeństwa i DevOps oraz pisze raport z dowodami gotowości produkcyjnej.
  • 95devops-cloud
    Opisuje DevOps, infrastrukturę chmurową i platform engineering z AWS, GCP, Azure, Kubernetes, Terraform, pipeline'ami CI/CD i infrastrukturą jako kodem.
  • 90team-release
    Koordynuje zespół wydania z release managerem, QA, devops engineerem i producentem, by przeprowadzić wydanie od kandydata do wdrożenia produkcyjnego.
  • 86team-shinchan:devops
    Pomaga w pracach DevOps: CI/CD, Docker, wdrożeniach i potokach, gdy trzeba je przeprowadzić.
  • 100devops-deployment
    Konfiguruje potoki CI/CD, kontenery i infrastrukturę jako kod, np. GitHub Actions, Docker, Kubernetes, Helm i Terraform.
  • 100devops-expert
    Doradza w praktykach DevOps: potoki CI/CD, infrastruktura jako kod, monitoring i strategie wdrożeń, z GitHub Actions, GitLab CI i Terraform.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.