GSTACK and H·AI·K·U

23 roles, each with its own responsibilities, constraints, and decision frames. Engineering covers architecture decisions and refactor-vs-ship judgment. Product covers spec-writing and feature prioritization. Each is legibly distinct so the agent doesn't blur them.

Hats. Every stage carries an ordered set — planner, builder, verifier, classifier, feedback-assessor — and each is a separate file with its own mandate. Hats fire as separate subagent invocations with fresh context. The same agent never wears two hats at once.

A structured collection of CLAUDE.md-style files the host harness reads at session start. The agent operates inside whichever role lens is active. No new interface, no new product — better instructions, organized.

Each role is a markdown file with a defined shape — organized by stage, studio, or global default. The same role can be specialized per studio without forking.

The prompt layer. Roles are instructions loaded at session start. The agent decides which role lens fits the current work and operates inside it.

The workflow layer. Roles are hats scoped to stages, dispatched by the engine. The cursor reads on-disk state and decides which hat fires next. The agent doesn't choose its role; the engine chose it before the subagent was spawned.

The agent. Reads the situation, decides which role applies, acts. The framework gives it a sharper toolkit per role; the choice of role stays in the agent's loop.

The engine. Stages declare hat sequences; the cursor fires the planner, then the builder, then the verifier, in the order the stage encodes. The agent never has the "which hat now?" decision because it never had the "what step now?" decision. (One Instruction at a Time.)

Whatever the host harness does for compaction or reset. Role instructions stay in context across role switches because they're loaded once and the agent carries them.

Every hat fires as a fresh subagent invocation. Context reset isn't a recovery move; it's the default state between hats. The planner finishes, returns, terminates. The builder spawns cold, with only the planner's artifacts and its own mandate.

The collection of CLAUDE.md files plus whatever the user types in chat. The spec lives in prompts.

intent.md plus units/*.md plus stage outputs. All on disk, all artifact-shaped. Drift detection runs against the files; verifiers grade against the files; feedback anchors to the files.

GSTACK's roles operate inside a single agent loop — the agent moves between CEO, engineer, QA mode as the work requires. There's no hard gate between role transitions because there's no engine to enforce one. H·AI·K·U's hat transitions are engine-mediated; review and approval transitions go through gates with named reviewers; intent completion goes through user gates. The engine enforces "you can't skip the verifier" the same way TypeScript enforces "you can't pass a string where a number's expected."

GSTACK's 23 roles are tuned for the solo-founder-running-a-startup shape. H·AI·K·U ships twenty-plus studios — software, security-assessment, legal, finance, incident-response, hwdev, marketing, sales, customer-success — each with its own stage sequence, hat library, and review-agent lineup. The role-as-lens intuition extends to "what counts as a stage in this domain" and "what handoffs the lifecycle enforces between stages." Different ceiling on how much domain shape you can encode.