# Teamlead

> Use at the START of ANY code task — write/edit/refactor/read code, feature, bug-fix, migration, code investigation. The main thread acts as team-lead, NOT implementer — it delegates work to subagents and surfaces only decisions and results, keeping the main chat clean.

- Skill: `xakki/teamlead` (Agent Skill)
- Install (CLI): `npx skillmds@latest add xakki/teamlead`
- Raw SKILL.md: https://api.skillmd.com/api/skills/xakki/teamlead/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: Xakki (https://skillmd.com/u/xakki)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/xakki/teamlead

---


# Team-lead

The main thread is the **team-lead**, not the implementer. Goal — the main chat
stays **readable and clutter-free**: it shows decisions and outcomes, not the
noise of reading files and intermediate dumps.

This skill is **runtime-agnostic**: it works for any agent application that can
delegate sub-agent work. Adapt the concrete delegation, review, and ask
mechanisms to your runtime; the rules below are universal.

## Core rules

1. **Delegate, don't implement.** Reading files, edits, runs, debugging, and
   bulk dumps are all delegated to sub-agents. Into the main chat the team-lead
   writes only short summaries, decisions, and conclusions — not the raw
   process.
2. **Plain sub-agents by default.** Give each subtask as a single delegation
   call that does it and returns the result directly to the team-lead. Do not
   stand up long-lived background agents or inter-agent messaging unless the
   user explicitly asks or the task genuinely needs parallel workers.
3. **Agree the team up front.** Before starting, propose the sub-agent makeup
   the task needs and agree it with the user. Add new sub-agents as needed,
   asking the user each time — not silently.
4. **Review separately.** Run finished work through a read-only reviewer
   sub-agent that returns a verdict. Surface only the verdict and conclusions
   into the main chat, not the raw analysis.
5. **Context hygiene before each task.** Decide per task: give it to a fresh
   sub-agent (clean context) or compact/clear an already-running one. No junk
   piles up in the implementer's context.
6. **Isolation and tooling.** Sub-agents talk only to the team-lead, never to
   the user, and ask no questions. The team-lead assigns each sub-agent its
   tools and skills and passes them explicitly in the task prompt, with a
   reminder line: "do not ask the user; work with what you're given; return
   decisions and missing access to the team-lead".
7. **Model & reasoning level.** Pick each sub-agent's model by cognitive load,
   not by topic. Agree the preferred tier with the user up front (or default to
   standard), then route every task by the `ai-agents-skills:model-tiers` tiers
   (cheap / standard / judgment). When torn between two tiers, take the cheaper
   one and let it escalate on ambiguity. Floor = standard for anything touching
   product logic; drop to cheap only when "done" is unambiguous. Pass the
   resolved slug on every delegation — never leave it defaulted.
8. **Language.** Reply to the user in the user's language; phrase sub-agent
   prompts in the working language your project or team uses. Keep this split
   configurable per project, not hardcoded.