recursive-decomposition

Partition large inputs and invoke sub-agents recursively for complex analysis.

Updated Feb 18, 2026
One-click install
npx skills add https://github.com/riddopic/cc-tools --skill recursive-decomposition
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: recursive-decomposition
Source: https://github.com/riddopic/cc-tools/tree/main/.claude/skills/recursive-decomposition
Command: npx skills add https://github.com/riddopic/cc-tools --skill recursive-decomposition

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill tackles tasks that exceed typical context limits by programmatically breaking them into smaller, manageable pieces and processing them recursively, ensuring comprehensive analysis without overwhelming the AI.

Core Features & Use Cases

  • Scalable Analysis: Process large codebases, documents, or datasets that would otherwise be impossible due to token limits.
  • Efficient Information Retrieval: Systematically search and aggregate information scattered across numerous files or documents.
  • Use Case: When asked to "analyze all error handling patterns in the entire codebase," this Skill will intelligently identify relevant files, partition them, and recursively analyze each part before synthesizing a complete report.

Quick Start

Use the recursive-decomposition skill to analyze all files in the current directory.

Frequently Asked Questions about recursive-decomposition

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

FAQPage Schema
How do I analyze a large codebase that exceeds the AI context window?

Recursive decomposition handles large-scale codebase analysis by programmatically partitioning inputs into smaller pieces and recursively processing them via sub-agents, ensuring comprehensive analysis without exceeding context window limits.

What is the best way to aggregate information scattered across multiple large documents?

The best way to aggregate information across multiple large documents is recursive processing, which systematically searches, partitions, and synthesizes scattered data to overcome token limitations and generate comprehensive reports.

How does recursive decomposition work for complex reasoning over extensive datasets?

Recursive decomposition works by iteratively self-invoking sub-agents to process partitioned chunks of extensive datasets, retrieving and structuring data efficiently to enable complex reasoning across the entire input scope.

Can I use this approach to find all error handling patterns in my entire codebase?

Yes, you can use recursive decomposition to find error handling patterns in your entire codebase; it intelligently identifies relevant files, partitions them, and analyzes each part recursively before synthesizing a complete report.

When should I avoid recursive task decomposition for large context processing?

You should avoid recursive task decomposition for large context processing when tasks are simple enough to fit within standard context windows, as the overhead of iterative self-invocation and structured data handling is unnecessary for small-scale analysis.