# Claude Code Task System: Multi-Agent Orchestration

**Video:** [Claude Code Task System: ANTI-HYPE Agentic Coding (Advanced)](https://youtu.be/4_2j5wgt_ds)
**Autor:** (Tactical Agentic Coding)
**Durată:** ~30 min
**Tags:** @work @tech @coding

---

## TL;DR

Sistemul de task-uri din Claude Code permite orchestrarea echipelor de agenți care lucrează în paralel, cu dependențe între task-uri și validare automată. Anti-hype: nu e despre tool-uri fancy, ci despre înțelegerea fundamentelor (context, model, prompt, tools) și construirea de sisteme reproductibile.

---

## Concepte cheie

### Task System = Orchestrare Multi-Agent

**Diferența față de generația anterioară:**
- **Vechi:** To-do list simplu, sub-agenți ad-hoc fără comunicare
- **Nou:** Task-uri cu dependențe, blocări, și comunicare între agenți

**Tools disponibile:**
| Tool | Scop |
|------|------|
| `task_create` | Creează task nou |
| `task_get` | Citește detalii task |
| `task_list` | Listează toate task-urile |
| `task_update` | Actualizează/comunică status |

**Key insight:** Sub-agenții și agentul principal comunică prin `task_update` - aceasta e "magic"-ul.

### Arhitectura: Builder + Validator

**Minimum viable team:**
1. **Builder Agent** - construiește, face task-ul
2. **Validator Agent** - verifică că builder-ul a făcut corect

**De ce 2 agenți:**
- 2x compute = 2x încredere în rezultat
- Fiecare agent are context window focusat pe UN lucru
- Builder se auto-validează + Validator verifică overall

**Self-validation în Builder:**
```yaml
hooks:
  post_tool_use:
    - on: write, edit
    - if: file ends .py
    - run: ruff, mypy  # linters
```

### Template Meta-Prompt

**Definiție:** Un prompt care generează alt prompt într-un format specific și validat.

**Componente (3):**
1. **Self-validation** - hooks care verifică că output-ul e corect
2. **Agent orchestration** - instrucțiuni pentru construirea echipei
3. **Templating** - format specific pentru plan/output

**Exemplu workflow:**
1. User → Meta-prompt "plan with team"
2. Meta-prompt → Generează plan cu echipă
3. Stop hook → Validează că fișierul există și conține secțiunile cerute
4. Kick off → Agenții încep lucrul în paralel
5. Agenții finalizează → Ping înapoi la orchestrator
6. Orchestrator → Raportează rezultat

### Flux Multi-Agent

```
┌─────────────────────────────────────────┐
│         ORCHESTRATOR AGENT              │
│  (primary, face planning)               │
└─────────────────┬───────────────────────┘
                  │ task_create (multiple)
                  ▼
┌─────────────────────────────────────────┐
│           TASK LIST                     │
│  [1] Build hook A (parallel)            │
│  [2] Build hook B (parallel)            │
│  [3] Build hook C (parallel)            │
│  [4] Validate A (depends: 1)            │
│  [5] Validate B (depends: 2)            │
│  [6] Update README (depends: 4,5,6)     │
└─────────────────┬───────────────────────┘
                  │ sub-agents work
                  ▼
┌────────┐ ┌────────┐ ┌────────┐
│Builder1│ │Builder2│ │Builder3│
└───┬────┘ └───┬────┘ └───┬────┘
    │          │          │
    └────┬─────┴─────┬────┘
         │ task_update (done!)
         ▼
┌─────────────────────────────────────────┐
│ Orchestrator primește events și         │
│ deblochează următoarele task-uri        │
└─────────────────────────────────────────┘
```

---

## Anti-Hype: Fundamentele

**Core 4 al Agentic Coding:**
1. **Context** - ce știe agentul
2. **Model** - ce LLM folosești
3. **Prompt** - cum îi spui ce să facă
4. **Tools** - ce poate face

**Greșeala comună:** Oamenii folosesc Moltbot/Clawdbot fără să înțeleagă ce se întâmplă sub capotă.

**Soluția:** Învață primitivele, apoi folosește tool-uri avansate.

> "Don't work on the application anymore. Work on the agents that build the application for you."

### Evoluția Agentic Engineering

```
1. Base Agent (un singur agent)
      ↓
2. Context & Prompt Engineering (mai bun)
      ↓
3. Multi-Agent (mai mulți agenți)
      ↓
4. Specialized Agents (customizați)
      ↓
5. Orchestrator Agent (conduce echipa)
```

---

## Aplicare practică

### Când să folosești Task System?

**DA:**
- Task-uri complexe care pot fi paralelizate
- Când ai nevoie de validare la fiecare pas
- Proiecte cu multe fișiere/componente
- Update-uri documentație + cod simultan

**NU neapărat:**
- Task-uri simple, one-shot
- Când nu ai nevoie de validare
- Când overhead-ul de orchestrare > beneficiu

### Cum să construiești echipa

1. **Identifică task-urile** care pot rula în paralel
2. **Definește dependențe** (ce depinde de ce)
3. **Creează 2 tipuri de agenți:** builder + validator
4. **Adaugă self-validation** în builder (linters, type checkers)
5. **Template-uiește** într-un meta-prompt reutilizabil

### Exemplu: Update codebase vechi

**Task list generat:**
1. Build session_end hook (parallel)
2. Build permission_request hook (parallel)
3. Build setup hook (parallel)
4. Validate session_end (depends: 1)
5. Validate permission_request (depends: 2)
6. Validate setup (depends: 3)
7. Update README (depends: 4,5,6)

**Rezultat:** 2 minute, toate fișierele actualizate, logs generate, documentație completă.

---

## Conexiuni cu munca noastră

1. **Clawdbot folosește Claude Code** - putem aplica aceste tehnici
2. **Vending Master:** Ar putea beneficia de multi-agent pentru UI + backend + docs
3. **Overnight coding:** În loc de un agent, orchestrează echipă
4. **Validare automată:** Adaugă self-validation în task-urile de coding

---

## Citate cheie

> "More agents, more autonomy, and more compute doesn't always mean better outcomes. What we want is more ORGANIZED agents that can COMMUNICATE together."

> "The more agents you have with focused context windows doing one specific thing, the better."

> "There's going to be a big gap between engineers that turn their brain off and engineers that keep learning."

---

## Resurse menționate

- Claude Code Hooks Mastery (repo)
- Tactical Agentic Coding (curs)
- Agentic Horizon (curs avansat)
- Ralph Wickham technique

---

*Procesat: 2026-02-03*
*Sursă: https://youtu.be/4_2j5wgt_ds*