When to Use the SwarmForge Six-Pack Workflow

Use the SwarmForge six-pack workflow for large-scale, high-complexity projects requiring rigorous specification, dedicated QA, architectural oversight, and mutation hardening, while reserving lighter two-pack or four-pack configurations for smaller initiatives.

The unclebob/swarm-forge repository implements a multi-agent orchestration system where specialized AI roles collaborate through structured handoffs. The SwarmForge six-pack workflow represents the most comprehensive configuration, designed specifically for codebases that demand the highest standards of verification and architectural integrity.

What Is the SwarmForge Six-Pack Workflow?

The six-pack workflow distributes development across six isolated agents, each owning a distinct quality gate. According to the README.md in the unclebob/swarm-forge repository, this configuration dedicates separate processes to specification, implementation, refactoring, architecture, hardening, and quality assurance.

The workflow assigns specific responsibilities to each role:

• specifier: Converts user intent into Gherkin acceptance tests and comprehensive QA plans
• coder: Writes production code guided by TDD and unit tests
• cleaner: Performs behavior-preserving refactoring, coverage improvement, and mutation-site scans
• architect: Evaluates module boundaries, dependency direction, and property-test coverage
• hardender: Applies language-level mutation, CRAP/DRY verification, and soft Gherkin mutation
• QA: Transforms QA procedures into executable scripts, runs UI checks, and validates handoff consistency

The Six-Pack Handoff Chain

In swarmforge/handoff-protocol.md, the repository defines a strict handoff sequence that prevents overlapping concerns and ensures traceability. The normal chain flows unidirectionally:

specifier → coder → cleaner → architect → hardender → QA → completion

Each arrow represents a formal handoff where the upstream agent delivers artifacts to a dedicated worktree, and the downstream agent validates inputs before proceeding. This isolation ensures that architectural decisions survive implementation details and that QA remains independent of development bias.

When to Choose the SwarmForge Six-Pack Workflow

Select the six-pack configuration when project complexity justifies the coordination overhead. The workflow excels in four specific scenarios:

Complex Business Rules and Compliance Requirements

Projects governed by intricate business logic or regulatory frameworks benefit from the specifier role's upfront Gherkin specifications. When acceptance criteria must be frozen before implementation begins, the rigorous specification phase ensures all stakeholders agree on measurable outcomes before the coder writes the first line of production code.

Independent Quality Assurance

Use six-pack when QA must remain organizationally or logically separate from implementation. The dedicated QA agent executes the specifier's test plans independently, preventing the cognitive bias that occurs when developers test their own code. This separation is critical for UI/acceptance testing and compliance audits where objectivity is mandatory.

Strict Architectural Constraints

Systems requiring strict layering, dependency direction enforcement, or long-term maintainability goals need the architect role's oversight. As implemented in swarmforge/roles/architect.prompt, this agent validates module boundaries after implementation but before hardening, catching structural drift that simpler workflows miss.

Mutation Testing and Security Hardening

Codebases that must survive aggressive mutation testing or security audits require the hardender role. This agent applies language-level mutations and verifies CRAP/DRY metrics, ensuring the code base maintains integrity under adversarial testing conditions that would destabilize less rigorous workflows.

Configuring the Six-Pack Environment

Unlike the default branch, the six-pack workflow requires a specific branch checkout and configuration. The swarmforge.conf file defines six tmux windows, each running isolated worktrees:

# Pull the six-pack configuration (do not use the main branch)

BRANCH=six-pack
curl -L "https://github.com/unclebob/swarm-forge/archive/refs/heads/${BRANCH}.tar.gz" \
  | tar -xz --strip-components=1

# Start the swarm – this launches a tmux session with all six roles

./swarm

The configuration automatically generates window entries such as:

window specifier codex wt-specifier
window coder    codex wt-coder
window cleaner  codex wt-cleaner
window architect codex wt-architect
window hardender codex wt-hardender
window QA        codex wt-qa

Each window executes its own backend (typically codex) within a dedicated Git worktree, enabling isolated handoffs and independent progress tracking through the pipeline.

Critical Source Files in the Six-Pack Pipeline

Understanding the following files clarifies how the workflow enforces quality gates:

• swarmforge/handoff-protocol.md: Defines message formats and the daemon routing drafts between roles
• swarmforge/swarmforge.conf: Lists the six roles with their backends and worktree assignments
• swarmforge/roles/specifier.prompt: Drives the specifier to generate Gherkin specs and QA plans
• swarmforge/roles/coder.prompt: Guides TDD-based implementation
• swarmforge/roles/cleaner.prompt: Directs local cleanup and mutation-site scanning
• swarmforge/roles/architect.prompt: Validates module structure and dependencies
• swarmforge/roles/hardender.prompt: Commands mutation hardening and CRAP/DRY checks
• swarmforge/roles/QA.prompt: Drives final acceptance testing and verification
• swarmforge/scripts/swarmforge.sh: Core launcher that creates worktrees and initializes tmux sessions

Summary

• The SwarmForge six-pack workflow dedicates six isolated agents to specification, coding, cleanup, architecture, hardening, and QA
• Use this workflow for large-scale projects requiring rigorous upfront specifications, independent QA validation, deep architectural control, or mutation hardening
• The handoff chain specifier → coder → cleaner → architect → hardender → QA ensures traceability and prevents quality gate bypass
• Configure the workflow using the six-pack branch, which provides swarmforge.conf entries for six dedicated tmux windows
• For small or fast-moving projects, prefer the lighter two-pack or four-pack configurations to avoid unnecessary coordination overhead

Frequently Asked Questions

What is the difference between the six-pack and four-pack workflows?

The six-pack workflow adds dedicated architect and hardender roles to the four-pack configuration, enabling formal architectural review and mutation testing. While the four-pack handles specification, coding, cleanup, and QA, the six-pack separates structural validation and security hardening into distinct phases, making it suitable for systems with strict compliance or safety requirements.

Can I skip the hardender role in a six-pack project?

Skipping the hardender defeats the purpose of the six-pack configuration. The hardender applies language-level mutations and verifies CRAP/DRY metrics that the cleaner does not address. If your project does not require mutation testing, use the four-pack workflow instead to reduce coordination overhead.

How does the specifier role differ from the QA role?

The specifier translates user requirements into Gherkin acceptance tests and QA plans during the initial phase, while the QA role executes those plans and validates handoff consistency at the end. The specifier designs the verification strategy; the QA agent implements it as executable scripts and performs final UI checks, ensuring independence between test design and test execution.

Is the six-pack workflow suitable for startup MVPs?

No. The coordination overhead of six sequential handoffs slows iteration velocity. According to the unclebob/swarm-forge source code, startup MVPs and fast-moving prototypes should use the two-pack (specifier/coder) or four-pack workflows, reserving the six-pack for production systems where architectural rigor and comprehensive verification outweigh speed requirements.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}