# Claude Code Game Studios Agent Delegation Hierarchy: A Three-Tier System

> Explore the Claude Code Game Studios strict three-tier agent delegation hierarchy, detailing how Directors, Leads, and Specialists ensure a clear chain of command for complex decisions.

- Repository: [Donchitos/Claude-Code-Game-Studios](https://github.com/Donchitos/Claude-Code-Game-Studios)
- Tags: architecture
- Published: 2026-04-16

---

**Claude Code Game Studios implements a strict three-tier agent delegation hierarchy where Directors delegate to Leads, who delegate to Specialists, ensuring vertical chain-of-command without skipping tiers for complex decisions.**

The **agent delegation hierarchy** in Claude Code Game Studios (CCGS) organizes autonomous Claude agents into a studio-style management structure inspired by real-world game development. This system ensures clear accountability, prevents conflicting edits, and maintains code quality through enforced delegation chains documented in the repository's core workflow files.

## The Three-Tier Agent Delegation Hierarchy Structure

CCGS categorizes every agent into one of three distinct tiers based on scope of authority and decision-making power.

### Tier 1 – Directors (Strategic Decision-Makers)

**Directors** sit at the apex of the agent delegation hierarchy with ultimate authority over project-wide decisions. They synthesize information across the entire codebase and provide phase-gate verdicts that lower tiers cannot override.

Key director agents include:
- `creative-director` – Resolves design disputes and approves creative vision
- `technical-director` – Arbitrates technical architecture decisions
- `producer` – Manages scope, schedule, and resource conflicts

### Tier 2 – Leads (Discipline Owners)

**Leads** translate director intent into concrete implementation plans and supervise specialists within their domains. They act as the crucial middle layer that bridges strategic vision and tactical execution.

Lead agents include:
- `game-designer` and `systems-designer`
- `lead-programmer`
- `art-director`, `audio-director`, `narrative-director`
- `qa-lead`, `release-manager`, `localization-lead`

### Tier 3 – Specialists (Domain Experts)

**Specialists** perform hands-on work within narrowly defined domains. They write code, create assets, and perform analysis but cannot make cross-domain changes without explicit delegation from a Lead or Director.

Specialist roles include:
- Programming: `gameplay-programmer`, `engine-programmer`, `ai-programmer`, `network-programmer`, `ui-programmer`, `tools-programmer`
- Design: `level-designer`, `economy-designer`, `world-builder`, `writer`, `prototyper`, `live-ops-designer`
- Art & Audio: `technical-artist`, `sound-designer`, `ux-designer`
- Operations: `qa-tester`, `performance-analyst`, `devops-engineer`, `analytics-engineer`, `accessibility-specialist`, `security-engineer`, `community-manager`
- Engine-specific specialists for Godot, Unity, and Unreal

## Coordination Rules and Governance

The agent delegation hierarchy enforces strict rules to prevent conflicts and ensure accountability, documented in [`docs/WORKFLOW-GUIDE.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/docs/WORKFLOW-GUIDE.md) and [`README.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/README.md).

### Vertical Delegation Protocol

Directors delegate to Leads, and Leads delegate to Specialists. **No tier may be bypassed** for decisions affecting multiple domains. A Specialist cannot report directly to a Director without the Lead's intermediate framing.

### Horizontal Consultation

Agents on the same tier may request advice from peers, but they **cannot issue binding cross-domain changes**. A `gameplay-programmer` cannot unilaterally modify audio system files, even after consulting with the `sound-designer`.

### Conflict Resolution Pathways

Disputes follow explicit escalation routes:
- **Design disputes** → `creative-director`
- **Technical disputes** → `technical-director`
- **Scope or schedule conflicts** → `producer`

### Domain Boundary Enforcement

Every agent owns specific directories. An agent **must not edit files outside its owned directory** without explicit delegation from the owning Director or Lead. This prevents accidental cross-contamination of codebases.

## Implementing Agent Delegation in Skills

The hierarchy is enforced programmatically through skill definitions. Every skill requiring lower-tier expertise includes an **"Agent delegation (MANDATORY)"** section that spawns the appropriate agent before proceeding.

In [`.claude/skills/design-system/SKILL.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/.claude/skills/design-system/SKILL.md), the delegation pattern appears as:

```markdown
**Agent delegation (MANDATORY)**: After the framing answer is given but before drafting,
spawn `creative-director` via Task:
- Provide: system name, framing answer, game pillars, etc.
- Ask: "Shape the Player Fantasy …"

**Agent delegation (MANDATORY)**: Before drafting Section C, spawn specialist agents via Task in parallel:
- Look up the system category in the routing table
- Spawn the Primary Agent AND Supporting Agent(s) listed for this category

```

This pattern ensures that a **Director** reviews high-level framing before a **Lead** or **Specialist** validates detailed mechanics, preventing incorrect assumptions from propagating into implementation.

## Key Files and Configuration

| File | Purpose |
|------|---------|
| [`README.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/README.md) | Top-level hierarchy overview and coordination rules |
| [`docs/WORKFLOW-GUIDE.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/docs/WORKFLOW-GUIDE.md) | Definitive tier list and detailed delegation policies |
| [`.claude/skills/design-system/SKILL.md`](https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/.claude/skills/design-system/SKILL.md) | Concrete example of mandatory agent delegation |
| `CCGS Skill Testing Framework/agents/*` | YAML/Markdown definitions for every Director, Lead, and Specialist |

## Summary

- Claude Code Game Studios uses a **three-tier agent delegation hierarchy**: Directors (Tier 1), Leads (Tier 2), and Specialists (Tier 3).
- **Vertical delegation** is mandatory—Directors delegate to Leads who delegate to Specialists, with no tier skipping allowed.
- **Domain boundaries** are strictly enforced; agents cannot edit files outside their owned directories without explicit permission.
- **Conflict resolution** follows specific pathways: creative disputes go to the `creative-director`, technical disputes to the `technical-director`, and scope issues to the `producer`.
- The hierarchy is **programmatically enforced** through mandatory delegation sections in skill definitions, ensuring compliance at runtime.

## Frequently Asked Questions

### What is the agent delegation hierarchy in Claude Code Game Studios?

The agent delegation hierarchy is a three-tier management structure that organizes autonomous Claude agents into Directors (strategic decision-makers), Leads (discipline owners), and Specialists (domain experts). This system ensures clear chain-of-command and prevents conflicting edits by enforcing vertical delegation rules and domain boundaries.

### How does vertical delegation work between the three tiers?

Vertical delegation requires that Directors delegate tasks to Leads, who then delegate to Specialists. No agent may skip a tier when making decisions that affect multiple domains. For example, a `creative-director` cannot directly assign implementation tasks to a `gameplay-programmer`; the request must flow through the `lead-programmer` or relevant Lead first.

### What happens when agents disagree on implementation details?

Disputes follow explicit escalation pathways defined in the hierarchy. Design disagreements escalate to the `creative-director`, technical architecture disputes go to the `technical-director`, and conflicts involving scope or schedule are resolved by the `producer`. These rules prevent deadlock by establishing clear authority for different types of decisions.

### Can a Specialist modify code outside their assigned domain?

No, Specialists must not edit files outside their owned directories without explicit delegation from the owning Director or Lead. This domain boundary enforcement prevents accidental cross-contamination between systems. If a Specialist needs to modify external code, they must request delegation through the proper hierarchical channel, ensuring the change is reviewed by the appropriate Lead or Director.