# GStack + GSD + Superpowers: A Long-Horizon Agentic Delivery Stack

GStack, GSD, and Superpowers can be composed into a highly autonomous end-to-end software delivery workflow — but the recommended approach isn’t to have all three frameworks each “own the whole pipeline” simultaneously. Instead, use layered responsibility + guarded autonomy:

Layer	Primary tool	Core responsibility
Decision & expert review layer	GStack	Product/engineering/design/QA/release expert personas
Phase decomposition & context control layer	GSD	Discuss→Plan→Execute→Verify→Ship; fresh-context subagents
Engineering discipline & verification layer	Superpowers	TDD, systematic-debugging, verification-before-completion

GStack Spec Council → Superpowers Refinement → GSD Phase Graph
→ Build Loop → Superpowers TDD → GStack QA/Review/Ship → Retro

Difference from OpenSpec + Superpowers + gstack: this stack uses GSD instead of OpenSpec to own phase orchestration and context control, making it better suited for long-horizon, multi-phase features that need fresh context, rather than brownfield delta-spec management.

Three Gaps It Fills

1. Decision-making gap — generic agents blend product/engineering/design/QA together; GStack separates them with explicit gears
2. Context gap — long tasks suffer context rot; GSD counters this with phase loops + fresh-context subagents
3. Verification gap — AI self-assessment is overly optimistic; Superpowers TDD + verification plus GStack QA provide triple evidence

Where Each Layer Sits

GStack — Expert Decisions and the Delivery Closed Loop

Capability	Command
Product/strategy	/office-hours, /plan-ceo-review
Engineering/design plan review	/plan-eng-review, /plan-design-review
Browser QA	/qa
Release/retro	/ship, /retro

GSD — Phase Orchestration and Context Engineering

Discuss → Plan → Execute → Verify → Ship

• Each execution unit gets fresh context
• Phase boundaries cap context load
• Mandatory handoff files chain phases together

Superpowers — The Engineering Discipline Core

brainstorming → writing-plans → TDD → systematic-debugging → verification-before-completion → code review

Recommended Architecture

GStack drafts direction (/office-hours)
    ↓
Superpowers clarifies (brainstorming → writing-plans)
    ↓
GSD splits into phases (Discuss → Plan)
    ↓
GStack reviews the plan (/plan-eng-review, /plan-design-review)
    ↓
Build Loop iterates through phases (Superpowers TDD within each phase)
    ↓
GStack /qa + /review
    ↓
GStack /ship + /retro

Directory Structure

repo/
├── .gsd/phases/          # phase contracts
├── .gsd/handoffs/        # phase handoffs
├── docs/superpowers/     # implementation plans
├── .gstack/qa-reports/   # QA evidence
├── AGENTS.md             # routing rules
└── src/

AGENTS.md Routing

- GStack owns multi-role decisions, plan/design reviews, browser QA, ship, retro.
- GSD owns phase decomposition, context budget, handoffs, phase verify/ship.
- Superpowers owns TDD, debugging, verification-before-completion, code review.
- Scope/data model/security/pricing changes → stop for human approval.
- Every phase must produce tests, verification evidence, and handoff before next phase.

Mid-Flight Decision Strategy

Issue type	Auto-handled	Needs a human
Copy, layout density	GStack design role	No
Test naming, low-risk implementation details	Superpowers plan constraints	No
Scope trade-offs, business priority	GStack CEO recommendation	Depends on risk
Data model, permissions, security, billing	Stop	Yes
Release/migration/production impact	Stop	Yes

Decisions get written into .gstack/decisions/ and .gsd/handoffs/.

Good Fit vs. Poor Fit

Good fit:

• Mid-sized features spanning multiple files/modules
• Full-stack changes across UI + API + domain + tests
• Tasks verifiable via tests, browser QA, or PR diff
• Long-horizon work that can be bounded by phase boundaries

Not recommended to fully enable:

• Small fixes under 30 minutes
• Highly uncertain requirements needing extensive human exploration
• High-risk changes with no human gate
• Weak test foundations that can’t provide automated verification signal

Risks and Controls

Risk	Control
Overlapping tool responsibilities	AGENTS.md makes routing explicit
Overnight tasks running out of control	Phase contracts, budgets, checkpoint commits
Hallucination from multi-role voting	High-risk human gates, decision records
TDD becoming a formality	GStack eng review inspects failure modes
Missing context handoff	Mandatory handoff files
Dependence on Claude Code ecosystem	Core routing/phase contracts written as tool-agnostic Markdown

Comparison with Using GSD Alone

Dimension	GSD alone	GStack + GSD + Superpowers
Context control	Strong	Strong
Expert review	Weak	GStack gears
TDD discipline	Optional configuration	Enforced by Superpowers
Long-horizon autonomy	Phase graph	+ Build Loop + decision delegation

SDD selection background: SDD Tools Comparison (GSD sits on the execution-orchestration end).

Pilot Metrics

• Requirement clarification rounds
• Phase pass rate
• Test-first ratio
• Automatic mid-flight issue resolution rate vs. manual interruption count
• Defects found by QA, PR critical findings
• Lead time / rework time

References

• gstack
• GSD Core
• Superpowers