make-groups

Decompose large documents into sequenced implementation groups with dependency metadata.

5|1|Updated Feb 18, 2026
One-click install
npx skills add https://github.com/TalonT-Org/AutoSkillit --skill make-groups
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: make-groups
Source: https://github.com/TalonT-Org/AutoSkillit/tree/main/src/autoskillit/skills/make-groups
Command: npx skills add https://github.com/TalonT-Org/AutoSkillit --skill make-groups

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill tackles the complexity of large projects by breaking down extensive documents, like feature specifications or architecture proposals, into smaller, manageable, and sequentially executable implementation groups.

Core Features & Use Cases

  • Requirement Grouping: Organizes requirements from a single source document into distinct implementation units.
  • Dependency Sequencing: Orders these groups based on their interdependencies, ensuring a logical flow for development.
  • Use Case: You have a 50-page product requirements document. This Skill will analyze it, identify logical chunks of work (e.g., user authentication, core data model, reporting module), and present them as ordered groups ready for the make-plan pipeline.

Quick Start

Use the make-groups skill to decompose the requirements in the attached document 'feature-spec-v2.md' into sequenced implementation groups.

Frequently Asked Questions about make-groups

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

FAQPage Schema
How do I break down a large feature specification into manageable development tasks?

To break down a large feature specification, you can decompose the document into sequenced implementation groups. This process clusters requirements, establishes inter-group dependencies, and outputs structured files for incremental development pipelines.

What is the best way to sequence implementation groups based on requirement dependencies?

Sequencing implementation groups requires analyzing requirement dependencies within architecture proposals. The decomposition process identifies interdependencies, clusters requirements into logical units, and orders the output groups to ensure a logical development flow.

Can I use decomposed requirement groups directly for automated pipeline consumption?

Yes, decomposed requirement groups are formatted for pipeline consumption. The process generates an index file, per-group files, and a machine-readable manifest, ensuring the structured output integrates seamlessly with incremental development pipelines.

How do I verify that decomposed requirement groups align with my existing codebase?

To verify decomposed requirement groups against an existing codebase, the decomposition process utilizes subagents. These subagents perform codebase verification during the requirement clustering and sequencing phases to ensure alignment.

Does requirement decomposition work for architecture proposals as well as product specs?

Yes, requirement decomposition works for architecture proposals and product specs. The process analyzes extensive documents, identifies logical chunks of work like core data models, and structures them into ordered implementation groups.

What limitations exist when decomposing a 50-page product requirements document?

When decomposing a 50-page product requirements document, the process relies on strict output formatting and subagent verification. Limitations depend on the source document's clarity, as ambiguous requirements may affect the accuracy of generated implementation groups.