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

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:

(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 (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:

;; 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:

# 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:

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	Canonical description of six-pack roles and hand-off order	L41-L50
swarmforge/handoff-protocol.md	Detailed role flow and enumeration	L61-L62
test/swarmforge/pack_ui_test.clj	Concrete six-pack-roles vector used by test harness	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 and 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 (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.

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