subagent-teams

Delegate parallel subtasks to subagent teams while preserving the main context window.

1|1|Updated Jan 6, 2026
One-click install
npx skills add https://github.com/alijilani-dev/Claude --skill subagent-teams-alijilani-dev
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: subagent-teams
Source: https://github.com/alijilani-dev/Claude/tree/main/skills/subagent-teams
Command: npx skills add https://github.com/alijilani-dev/Claude --skill subagent-teams-alijilani-dev

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill prevents Claude's context window from filling up with heavy computational tasks, which leads to auto-compaction and degraded reasoning quality.

Core Features & Use Cases

  • Parallel Task Execution: Decomposes complex tasks into independent subtasks that can run concurrently.
  • Context Window Management: Isolates heavy work in subagent sessions, keeping the main orchestrator's context lean.
  • Optimized Model Selection: Assigns the most cost-effective model (Haiku, Sonnet, Opus) based on subtask complexity.
  • Use Case: When tackling a large feature implementation involving code research, writing, and testing, use this skill to delegate each phase to specialized subagents, ensuring consistent performance throughout.

Quick Start

Use the subagent-teams skill to break down the task of adding user authentication into parallel subagent tasks for research, implementation, and testing.

Frequently Asked Questions about subagent-teams

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I prevent context window auto-compaction during complex multi-step tasks?

To prevent context window auto-compaction, you can use AI orchestration to delegate heavy computational work to parallel subagent teams. This isolates complex processing, keeping the main orchestrator's context lean and preserving reasoning quality.

What is the best way to decompose a large feature implementation into parallel subtasks?

The best way to decompose a large feature implementation is to use subagent teams that break the work into independent subtasks for research, implementation, and testing, assigning optimal models like Haiku, Sonnet, or Opus based on each subtask's complexity.

How does parallel task execution with subagents manage codebase context?

Parallel task execution with subagents manages codebase context by isolating heavy work in separate subagent sessions. This preserves the main context window, preventing degradation and ensuring consistent performance throughout the task.

Can I assign different models to independent subtasks running in parallel?

Yes, you can assign different models to independent subtasks running in parallel. The orchestration process selects the most cost-effective model—such as Haiku, Sonnet, or Opus—based on the specific complexity requirements of each decomposed subtask.

When should I use AI orchestration for task decomposition instead of processing sequentially?

You should use AI orchestration for task decomposition when your context window is getting large, when independent subtasks can run in parallel, or when performing complex multi-step tasks that would otherwise degrade reasoning quality through auto-compaction.

Why does my main context window degrade when running heavy codebase management tasks?

Your main context window degrades during heavy codebase management tasks because filling it with complex computational work triggers auto-compaction. Delegating these tasks to parallel subagents isolates the processing load and prevents this degradation.