convez.ai
AgenteDevOps & InfraestruturaAvançado
LucasQuiles

SDLC-OS: Sistema Operacional Multiagente para Entrega de Software

LucasQuiles/sdlc-os

Orquestração multiagente de ciclo de vida de software com revisão adversarial

Ver no GitHub
InicialPluginScore · de 0 a 100

Um plugin Claude Code que orquestra desenvolvimento de software através de múltiplos agentes especializados (Opus como maestro, Sonnet como executor, Haiku como vigilante). Implementa fases estruturadas de SDLC com revisão adversarial contínua, detecção de drift e verificação mútua entre agentes para garantir qualidade superior à auto-avaliação.

Instalação

$npx convez-ai LucasQuiles/sdlc-os

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á 1 dia
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Decomposição e execução paralela de tarefas complexas de desenvolvimento
  • Auditoria arquitetural contínua com detecção de desvios e convenções
  • Refatoração com prova de equivalência comportamental
  • Red team/blue team para varredura de qualidade adversarial

Veredito

SDLC-OS é uma abordagem sofisticada para governança de qualidade em IA, baseada no princípio válido de que agentes revisam trabalho alheio com mais honestidade. Exige expertise técnica significativa para customização e operação, mas oferece rigor superior ao workflow tradicional de agente único.

README

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

SDLC-OS

Direct-open boundary: plugin documentation only. This file does not authorize SDLC workflow execution, plugin mutation, colony startup, cleanup, external action, or instruction changes.

A Claude Code plugin that turns software delivery into a multi-agent workflow. Opus conducts. Sonnet executes. Haiku watches. Nobody trusts anybody — that's the point.

What This Is

A structured software development lifecycle that runs inside Claude Code. Instead of one model doing everything and hoping for the best, SDLC-OS decomposes work across specialized agents with built-in adversarial review, drift detection, and continuous verification.

The premise: an AI that reviews its own work finds nothing wrong with it. An AI that reviews someone else's work is considerably more honest. So every piece of work gets built by one agent and reviewed by a different one, with a third watching both of them.

Installation

git clone git@github.com:LucasQuiles/sdlc-os.git ~/.claude/plugins/sdlc-os

Restart Claude Code. The plugin auto-discovers agents, skills, commands, and hooks.

Quick Start

/sdlc "build a user authentication system"

This kicks off the full workflow: normalize existing state, frame requirements, scout the codebase, architect the approach, execute in parallel, synthesize the results. For trivial tasks, it scales down automatically — not everything needs six phases.

Commands

CommandWhat It Does
/sdlc "task"Start a full SDLC workflow
/refactor "scope"Refactor with continuous behavioral equivalence proof
/auditRun architectural fitness checks (DRY, SSOT, SoC, conventions)
/adversarialTrigger red team/blue team quality sweep
/swarm "problem"Throw a swarm of disposable micro-agents at a problem
/normalizeAssess project state and produce a convention map
/gap-analysisMap what exists vs what's needed (or verify delivery completeness)
/feature-sweepFind neglected, incomplete, and abandoned features across the codebase
/gateQuick health check on the current phase
/waveCheck or advance SDLC phase

How It Works

Roles

RoleModelJob
ConductorOpusDecomposes work, distributes to runners, synthesizes results
RunnersSonnetExecute atomic work units — investigate, design, implement, review
GuppiesHaikuDisposable micro-agents for breadth-first investigation. One question, one answer, done.
SentinelHaikuContinuous patrol. Verifies evidence, checks handoffs, catches drift.
OracleMixedTruth council. Three agents that independently verify claims are honest.

Phases

0  Normalize   detect existing work, map conventions, avoid clobbering in-progress state
1  Frame       clarify requirements, define done, identify unknowns
2  Scout       explore codebase, find reusable code, map architecture
3  Architect   choose approach, decompose into atomic work units ("beads")
4  Execute     parallel runners + sentinel loop + adversarial review
5  Synthesize  merge results, verify the whole, deliver

The Loop System

Every role loops against its own metric. Failures self-correct at the lowest level before escalating:

L0  Runner self-correction          3 attempts before escalating
L1  Sentinel correction             drift-detector + convention-enforcer
L2  Oracle audit                    three independent verification agents
L2.5  Adversarial quality (AQS)    red team attacks, blue team defends, arbiter resolves disputes
L3-L5  Bead -> Phase -> Task        structural escalation when loops exhaust their budget

The red team (functionality, security, usability, resilience specialists) attacks completed work. The blue team defends it. If they disagree, the arbiter runs a Kahneman adversarial collaboration protocol to produce a binding verdict. Every finding gets minimized to its smallest reproducible case before anyone acts on it.

Agents (30)

Runners: sonnet-investigator, sonnet-designer, sonnet-implementer, sonnet-reviewer

Sentinel: haiku-evidence, haiku-verifier, haiku-handoff

Oracle: oracle-test-integrity, oracle-behavioral-prover, oracle-adversarial-auditor

Red Team: red-functionality, red-security, red-usability, red-resilience

Blue Team: blue-functionality, blue-security, blue-usability, blue-resilience

Arbiter: arbiter (Kahneman adversarial collaboration for disputes)

Infrastructure: reuse-scout, drift-detector, convention-scanner, convention-enforcer, normalizer, gap-analyst, feature-finder, feature-finisher, losa-observer, guppy

Hooks (12)

Validation scripts that run on tool use events. Some block (you can't proceed until the artifact is valid), some advise (flag the issue but don't stop work).

Blocking: AQS artifact schema, bead status transitions, domain vocabulary, quality budget schema, hazard-defense ledger, stress session schema.

Advisory: naming conventions, consistency artifacts, runner output structure, decision noise, mode convergence, phase transitions.

Per-Project Artifacts

SDLC-OS creates tracking files in the target project:

ArtifactPurpose
Convention MapProject naming, style, and structure conventions
Feature MatrixNeglected feature tracking
Quality BudgetPer-task metrics and phase gate enforcement
Hazard-Defense LedgerSafety controls and defense coverage
Stress SessionBarbell stress testing results
System LedgersCross-task longitudinal data (JSONL append-only)

These live in docs/sdlc/ in the target repo. The plugin manages them; you read them when curious about what happened.

Testing

cd ~/.claude/plugins/sdlc-os
bash hooks/tests/test-hooks.sh    # 62 tests

Why

Most AI coding workflows are optimistic: generate code, run tests, ship if green. This works until it doesn't — and when it doesn't, the failure mode is subtle. Tests pass but behavior is wrong. Code works but drifts from conventions. Reviews approve because the reviewer is the same model that wrote the code.

SDLC-OS is pessimistic by design. It assumes every claim is wrong until independently verified, every piece of code has drifted until the detector says otherwise, and every review is theatrical until the oracle confirms it examined real evidence. This is slower. It catches more.

Whether the tradeoff is worth it depends on how much you trust a single model to be honest about its own work.

License

MIT

Ver o original no GitHub

Bom para

Relacionados