# When to Use the Six-Pack Workflow in SwarmForge: A Complete Guide

> Master the SwarmForge six-pack workflow. Learn when to apply its rigorous engineering discipline for projects with complex UI, QA, architecture, or mutation hardening needs.

- Repository: [Robert C. Martin/swarm-forge](https://github.com/unclebob/swarm-forge)
- Tags: how-to-guide
- Published: 2026-08-28

---

**Use the SwarmForge six-pack workflow for projects requiring rigorous, end-to-end engineering discipline—specifically those with substantial UI components, dedicated QA requirements, deep architectural oversight, or mutation hardening needs.**

SwarmForge ships three canonical workflow "packs": **two-pack**, **four-pack**, and **six-pack**. The six-pack represents the *full* workflow and should be selected when your project demands maximum quality assurance through clearly separated, sequential roles. According to the SwarmForge source code, the six-pack "separates each major quality gate into its own role" as documented in [[`README.md`](https://github.com/unclebob/swarm-forge/blob/main/README.md)](https://github.com/unclebob/swarm-forge/blob/main/README.md#L41-L52).

## When to Choose Six-Pack Over Other Workflows

Select the six-pack workflow when your project exhibits any of these characteristics:

### Substantial UI Components

Projects with significant user-interface work benefit from the built-in **QA role** that validates UI behavior through executable scripts. The four-pack and two-pack workflows lack this dedicated verification stage.

### Upfront Quality Assurance Requirements

When you need explicit QA procedures written before implementation begins, the **specifier** role produces both Gherkin specifications *and* acceptance-test procedures. This front-to-back specification approach ensures testability from day one.

### Architectural Complexity

For multi-service systems, large refactors, or new product features, the **architect** role enforces module boundaries, validates dependency direction, and ensures property-test coverage. This oversight prevents technical debt accumulation in complex codebases.

### Mutation Testing Needs

The **hardender** role performs language-level mutation testing, mutation hardening, and soft Gherkin mutation—capabilities absent from lighter workflow packs.

## The Six Sequential Roles in Six-Pack Workflow

The six-pack defines a strict hand-off sequence codified in [`swarmforge/handoff-protocol.md#L172-L189`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md#L172-L189):

1. **specifier** – Writes Gherkin specifications and acceptance-test procedures.

2. **coder** – Implements specs with test-driven development (TDD) and generated acceptance tests.

3. **cleaner** – Performs local cleanup, coverage analysis, CRAP/DRY review, and mutation-site scans.

4. **architect** – Reviews module boundaries, dependency direction, and property-test coverage.

5. **hardender** – Executes mutation hardening, language-mutation checks, and soft Gherkin mutation.

6. **QA** – Converts the specifier's QA plan into executable scripts, validates the UI, and sends the final completion notification.

Each role runs in its own **tmux window**, with merge-only copies flowing backward through the pipeline.

## Setting Up a Six-Pack Project

Install all packs including six-pack, then launch the dashboard:

```bash

# 1️⃣ Install all packs (including six-pack) once:

get-swarm-forge          # pulls main + two-pack + four-pack + six-pack

# 2️⃣ Start the dashboard (the Lieutenant UI):

./swarm                  # prints a URL and opens it in the browser

```

From the dashboard, create a new project:

- **Project name**: `my-awesome-app`
- **Pack**: `six-pack`
- *(Optional)* GitHub repository integration

Once created, the card flow appears as:

```

specifier → coder → cleaner → architect → hardender → QA → Done

```

### Hand-Off Commands in the UI

The dashboard exposes three hand-off semantics:

- **(New Task)** → handoff to the next role (e.g., specifier → coder)
- **(Back-One)** → return to the immediate previous role (e.g., cleaner → coder)
- **(Back-All)** → return to all earlier roles simultaneously (e.g., from architect & QA → specifier/coder/cleaner)

## When to Avoid Six-Pack

Skip the six-pack workflow for simpler work where coordination overhead outweighs quality benefits:

- **Simple backend scripts** – Single-purpose utilities without UI or complex architecture
- **Quick prototypes** – Time-boxed experiments meant for rapid iteration
- **Tasks without QA requirements** – Internal tools or admin scripts not requiring UI validation
- **Work without architectural risk** – Small, isolated changes within established module boundaries

For these scenarios, the **two-pack** (specifier → coder) or **four-pack** (specifier → coder → cleaner → architect) workflows reduce overhead while maintaining core discipline.

## Key Source Files Defining Six-Pack Behavior

| File | Purpose |
|------|---------|
| [[`README.md`](https://github.com/unclebob/swarm-forge/blob/main/README.md)](https://github.com/unclebob/swarm-forge/blob/main/README.md) | High-level pack descriptions and selection guidance |
| [[`swarmforge/handoff-protocol.md`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md)](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md) | Formal role definitions and hand-off semantics |
| [`swarmforge/scripts/forge.bb`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/scripts/forge.bb) | Declares available packs: `["two-pack" "four-pack" "six-pack"]` |
| [`swarmforge/constitution/articles/workflow.prompt`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/constitution/articles/workflow.prompt) | Runtime workflow selection based on project configuration |
| [`get-swarm-forge`](https://github.com/unclebob/swarm-forge/blob/main/get-swarm-forge) | Installation helper that populates `packs/` directory with templates |

## Summary

- **Six-pack** is SwarmForge's most rigorous workflow, separating concerns across six distinct roles.
- Choose it for **UI-heavy work**, **dedicated QA needs**, **architectural complexity**, or **mutation testing requirements**.
- The role sequence—specifier → coder → cleaner → architect → hardender → QA—is enforced by the hand-off protocol in [[`swarmforge/handoff-protocol.md`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md)](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md).
- **Two-pack** and **four-pack** workflows reduce coordination overhead for simpler tasks.
- Project setup occurs through the Lieutenant UI (`./swarm`), with six tmux windows spawned automatically for six-pack projects.

## Frequently Asked Questions

### How do I switch from four-pack to six-pack mid-project?

You cannot migrate an existing project between packs. The pack selection in SwarmForge determines the runtime constitution and tmux window layout at project creation time. Start a new project with `six-pack` selected if your requirements have evolved to need the QA or hardender roles.

### Does six-pack slow down development velocity?

Yes, intentionally. The six-pack adds orchestration overhead that pays dividends for **major projects** by catching regressions early and distributing responsibility. For quick prototypes where speed matters more than rigor, use two-pack instead. As implemented in `unclebob/swarm-forge`, the workflow selection is a deliberate trade-off between velocity and verification depth.

### Can I customize the six roles in six-pack?

No. The six roles are fixed by the constitution in [`swarmforge/constitution/articles/workflow.prompt`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/constitution/articles/workflow.prompt). The hand-off protocol enforces this sequence strictly—arbitrary role modification would break the merge-back guarantees and quality-gate semantics that define the six-pack workflow.

### Is mutation testing (hardender role) required for all six-pack projects?

The hardender role is *defined* in every six-pack project, but its intensity depends on project configuration. The hardender performs language-mutation checks and soft Gherkin mutation regardless, though you can scope mutation-site density through project settings. For projects where mutation testing is explicitly unwanted, four-pack (which omits the hardender) may be more appropriate.