Receive many tasks. Analyze. Split. Dispatch. Track.
When to Use
Trigger this skill when:
- User sends 3+ tasks in one message
- Tasks span different pages, modules, or domains
- Parallel agent execution is possible
- User says "ajrat", "bo'lib chiq", "agentlarga ber"
Phase 1 — Intake
1.1 Read all tasks first
- Read the ENTIRE user message before doing anything
- Do NOT start implementing
- Do NOT ask clarifying questions yet (unless a task is completely ambiguous)
1.2 Categorize each task
For each task, identify:
- Domain — which page, module, or feature area
- Type — bug fix / new feature / refactor / config
- Size — small (< 1 hour) / medium / large (cross-cutting)
- Dependency — does it depend on another task?
Phase 2 — Decompose
2.1 Group by isolation boundary
Rule: Tasks that touch the same files → same agent
Rule: Tasks that are cross-cutting (e.g. alias migration) → separate agent
Rule: Tasks with no file overlap → separate agents (parallel)
2.2 Agent assignment
Name agents alphabetically:
AGENT A — [Domain or Theme]
AGENT B — [Domain or Theme]
AGENT C — [Domain or Theme]
...
Each agent gets:
- A clear responsibility label
- A list of tasks (numbered A.1, A.2, ...)
- A list of files it owns (no overlap with other agents)
2.3 Isolation rule (HARD)
⚠️ ISOLATION — Non-negotiable
- Each agent owns its files. No other agent touches them.
- If two tasks need the same file → assign both to the same agent.
- If a file conflict is unavoidable → flag it to the user before starting.
- Agents NEVER read or modify each other's output mid-session.
Phase 3 — Prioritize
| Priority | When | Examples |
|---|---|---|
| HIGH | Broken functionality, blocking others | Auth bug, crash, core feature |
| MEDIUM | Important but not blocking | New page, filter, export |
| LOW | Polish, cleanup, migration | Alias refactor, rename, docs |
Execution order:
- HIGH agents first (run in parallel if isolated)
- MEDIUM after HIGH is verified
- LOW last
Phase 4 — Write tasks.md
Create tasks.md in project root with this format:
# Task List — [Project Name]
Generated: [date]
---
## 🤖 AGENT A — [Theme]
**Files owned:** `src/x/`, `src/y/file.ts`
**Priority:** HIGH
### Task A.1 — [Title]
- **What:** Clear description of what to do
- **Why:** Reason / user complaint / bug
- **Acceptance:** Specific condition that proves it's done
- **Files:** Exact file paths
### Task A.2 — [Title]
- **What:** ...
- **Why:** ...
- **Acceptance:** ...
- **Files:** ...
---
## 🤖 AGENT B — [Theme]
**Files owned:** `src/z/`
**Priority:** MEDIUM
### Task B.1 — [Title]
...
---
## ⚠️ ISOLATION CONTRACT
| Agent | Files | Must NOT touch |
|-------|-------|---------------|
| Agent A | src/x/, src/y/ | src/z/ |
| Agent B | src/z/ | src/x/, src/y/ |
---
## 📋 SUMMARY
| # | Agent | Tasks | Priority | Can start? |
|---|-------|-------|----------|------------|
| A | [Theme] | 2 | HIGH | Yes |
| B | [Theme] | 3 | MEDIUM | After A verified |
**Total agents:** N
**Total tasks:** M
**Parallel groups:** [A, C] then [B] then [D]
---
## ✅ VERIFICATION (each agent runs after finishing)
\`\`\`bash
pnpm typecheck
pnpm lint
pnpm test # if available
\`\`\`
Phase 5 — Dispatch
After tasks.md is written, dispatch agents:
Parallel dispatch (no dependencies):
Agent A, B, C — parallel start.
Each reads only its section in tasks.md.
Each runs typecheck + lint after finishing.
Sequential dispatch (dependencies exist):
1. Start Agent A (HIGH priority)
2. After Agent A: pnpm typecheck && pnpm lint
3. Start Agent B only after A is VERIFIED
Dispatch message format per agent:
## Agent [X] — START
Your tasks are in tasks.md under "AGENT [X]" section.
Files you own: [list]
Files you must NOT touch: [list]
After completing ALL your tasks:
1. pnpm typecheck
2. pnpm lint
3. Report: which tasks done, any blockers
Phase 6 — Track
After all agents complete:
| Agent | Status | Typecheck | Lint | Blockers |
|---|---|---|---|---|
| A | ✅ Done | ✅ Pass | ✅ Pass | None |
| B | 🟡 WIP | — | — | Waiting for A |
| C | ❌ Blocked | — | — | Unclear requirement |
For blocked agents → ask user before resuming.
Rules
NEVER:
- Start implementing before writing tasks.md
- Mix tasks from different domains into one agent
- Let two agents own the same file
- Mark a task complete if typecheck/lint fails
- Guess on ambiguous tasks — ask the user
ALWAYS:
- Write tasks.md before any agent starts
- Assign priority to every task
- State the isolation contract explicitly
- Run typecheck + lint after each agent
- Report blockers immediately
Quick Reference
User sends tasks
↓
Phase 1: Read all. Categorize.
↓
Phase 2: Group by isolation. Assign agents.
↓
Phase 3: Set priorities.
↓
Phase 4: Write tasks.md
↓
Phase 5: Dispatch agents (parallel or sequential)
↓
Phase 6: Track. Verify. Report.