# SwarmForge Six-Pack Roles: What Two Additional Roles Complete the Workflow?

> Discover the two extra roles in the SwarmForge six-pack: hardender and QA. Learn how they enhance mutation hardening and ensure final quality assurance for your workflow.

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

---

**The SwarmForge six-pack adds hardender and QA as the two additional roles beyond the four-pack workflow, providing comprehensive mutation hardening and final quality assurance.**

SwarmForge is an AI-powered development framework that orchestrates autonomous agents through structured role-based workflows. The **six-pack** represents the most granular of its three workflow templates, introducing specialized quality gates that the lighter two-pack and four-pack variants lack. This article examines the complete six-pack role structure, identifies which roles are unique to it, and shows how to inspect and work with these roles in practice.

## Complete Six-Pack Role Structure

The six-pack consists of six sequential roles, each with distinct responsibilities in the development pipeline. According to the `six-pack-roles` vector defined in `test/swarmforge/pack_ui_test.clj` (line 9), the ordered role list is:

```clojure
(def six-pack-roles ["specifier" "coder" "cleaner" "architect" "hardender" "QA"])

```

| Role | Responsibility |
|:--|:--|
| **specifier** | Translates user intent into precise Gherkin acceptance specifications and prepares upstream QA procedures. |
| **coder** | Implements approved specifications using TDD, unit tests, and generated acceptance tests. |
| **cleaner** | Performs local cleanup, coverage improvement, CRAP/DRY analysis, and mutation-site scans. |
| **architect** | Reviews module boundaries, enforces correct dependency direction, and verifies property-test coverage. |
| **hardender** | Executes mutation hardening, language-mutation checks, and soft-Gherkin mutation testing. |
| **QA** | Converts specifier QA procedures into executable scripts, runs final UI verification, and sends completion notifications. |

## The Two Additional Roles: Hardender and QA

The **hardender** and **QA** roles are the exclusive additions that elevate the four-pack to a six-pack. The four-pack workflow terminates after the architect role, leaving a gap in final quality validation.

### Hardender Role

The **hardender** performs **mutation hardening**—a systematic process of introducing small code mutations and verifying that the test suite catches them. This includes:

- **Language-mutation checks**: Verifying that syntactic variations are properly detected.
- **Soft-Gherkin mutation**: Testing whether acceptance criteria remain valid when specification language is subtly altered.

As documented in [`swarmforge/handoff-protocol.md`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md) (lines 61-62), the hardender receives work from the architect and passes to QA, creating explicit quality gates before final delivery.

### QA Role

The **QA** role serves as the **final quality checkpoint** and automation bridge. Unlike traditional manual QA, this role focuses on:

- Converting abstract QA procedures into **executable verification scripts**.
- Performing **final UI verification** against the original specifications.
- Triggering **completion notifications** to close the workflow loop.

This automation-first approach ensures reproducible quality validation without human bottlenecks.

## Working with Six-Pack Roles in Practice

### Inspecting the Canonical Role Definition

The authoritative role list resides in the test suite at `test/swarmforge/pack_ui_test.clj`. You can access this programmatically in a Clojure environment:

```clojure
;; In a SwarmForge project REPL
(require '[clojure.java.io :as io])

;; Extract the six-pack role vector from source
(def six-pack-roles
  (-> (io/resource "test/swarmforge/pack_ui_test.clj")
      slurp
      (re-find #"\[\"[^\"]+\"\]")
      read-string))

;; Result: ["specifier" "coder" "cleaner" "architect" "hardender" "QA"]

```

### Initializing a Six-Pack Project

To create a project using the full six-pack workflow:

```bash

# One-time setup of the SwarmForge helper

mkdir -p ~/cmds && cp get-swarm-forge ~/cmds/
chmod +x ~/cmds/get-swarm-forge
export PATH=~/cmds:$PATH

# Initialize project with all packs including six-pack

get-swarm-forge

# Launch the orchestration dashboard

./swarm

```

In the web interface, select **"New Project"**, choose the **"six-pack"** radio button, and provide a project name to activate all six roles.

### Examining Role-Specific Prompts

Each role's behavior is controlled by a dedicated prompt file. For the additional **hardender** role:

```bash
cat projects/my-app/swarmforge/roles/hardender.prompt

```

This file contains the precise hardening instructions that guide the agent's mutation testing strategy. The **QA** role has an equivalent file at `projects/<name>/swarmforge/roles/QA.prompt`.

## Key Source References

| File | Significance | Location |
|:---|:---|:---|
| [`README.md`](https://github.com/unclebob/swarm-forge/blob/main/README.md) | Canonical description of six-pack roles and hand-off order | [L41-L50](https://github.com/unclebob/swarm-forge/blob/main/README.md#L41-L50) |
| [`swarmforge/handoff-protocol.md`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md) | Detailed role flow and enumeration | [L61-L62](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md#L61-L62) |
| `test/swarmforge/pack_ui_test.clj` | Concrete `six-pack-roles` vector used by test harness | [L9](https://github.com/unclebob/swarm-forge/blob/main/test/swarmforge/pack_ui_test.clj#L9) |

## Summary

- The **SwarmForge six-pack** contains six sequential roles: specifier, coder, cleaner, architect, hardender, and QA.
- The **two additional roles** compared to the four-pack are **hardender** and **QA**.
- **Hardender** performs mutation hardening and language-mutation validation.
- **QA** converts procedures to executable scripts and executes final verification.
- Role definitions are authoritative in `test/swarmforge/pack_ui_test.clj` and documented in [`README.md`](https://github.com/unclebob/swarm-forge/blob/main/README.md) and [`handoff-protocol.md`](https://github.com/unclebob/swarm-forge/blob/main/handoff-protocol.md).

## Frequently Asked Questions

### Why does the six-pack add hardender and QA rather than other specializations?

The hardender and QA roles address specific gaps in the four-pack: **mutation testing coverage** and **automated final verification**. According to the SwarmForge source code, these were designed as distinct phases because mutation hardening (verifying test suite robustness) and final QA (verifying specification compliance) require different cognitive approaches—one adversarial, one confirmatory—making them unsuitable to combine into a single role.

### Can I customize or remove the additional six-pack roles?

The role structure is **hardcoded in the test suite** at `test/swarmforge/pack_ui_test.clj`, but individual role behavior is configurable through prompt files in `projects/<name>/swarmforge/roles/`. You cannot eliminate hardender or QA from a six-pack project without modifying framework source, though you can adjust their execution logic by editing the respective `.prompt` files.

### How does the hand-off protocol work between architect and hardender?

As specified in [`swarmforge/handoff-protocol.md`](https://github.com/unclebob/swarm-forge/blob/main/swarmforge/handoff-protocol.md) (lines 61-62), the architect completes **module boundary review and property-test verification** before passing deliverables to the hardender. The protocol requires explicit acknowledgment of **dependency direction compliance** and **coverage thresholds** as entry criteria for the hardening phase.

### What programming language is SwarmForge implemented in?

SwarmForge is implemented in **Clojure**, as evidenced by the `.clj` file extensions, `def` declarations, and REPL-based interaction patterns throughout the codebase. The role orchestration, test suite, and prompt management all use Clojure's functional programming model.