module-partitioning

Partition source corpora into bounded modules with per-module file references.

1|Updated Feb 26, 2026
One-click install
npx skills add https://github.com/agilebydesign/agilebydesign-skills --skill module-partitioning
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: module-partitioning
Source: https://github.com/agilebydesign/agilebydesign-skills/tree/main/agents/abd-ooad/skills/module-partitioning
Command: npx skills add https://github.com/agilebydesign/agilebydesign-skills --skill module-partitioning

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

After domain scan, partition the source corpus into modules by allocating source file references to per-module index files. No classes, no anchors — only module boundaries and file references to the source that belongs to each. Supports an Unallocated bucket for pending decisions and a Rejected bucket for out-of-scope context. Modules are flat by default and nested only when the source itself supports a sub-module. Use when the user asks to "partition the source", "allocate context to modules", "draw module boundaries", or needs a defensible scope cut before any class-level modeling.

Core Features & Use Cases

  • Flat module structure by default with clear criteria for when to nest.
  • Allocation rules that map source files to modules, unallocated, or rejected, using a source-driven independence test.
  • Outputs: a root module-partitioning index and per-module references to source files.

Quick Start

Run the module-partitioning workflow on your workspace to generate the root index and per-module references.

Frequently Asked Questions about module-partitioning

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

FAQPage Schema
How do I partition a source codebase into bounded modules for domain-driven design?▼

To partition a source corpus into bounded modules, apply allocation rules that map each on-disk source file to a named module, Unallocated, or Rejected bucket. This ensures complete coverage and defensible boundaries before class-level modeling.

What is the best way to draw module boundaries before starting domain modeling?▼

Drawing module boundaries requires a source-driven independence test to allocate file references to per-module index files. This creates clear scope walls and defensible boundaries, establishing a root index for downstream domain modeling work.

How does source file allocation to modules handle out-of-scope or pending context?▼

Source file allocation handles out-of-scope context using a Rejected bucket and pending decisions using an Unallocated bucket. This ensures every file is mapped while deferring ambiguous boundaries until a defensible scope cut is established.

Can I create nested module structures when partitioning source files?▼

Yes, you can create nested module structures, but modules are flat by default. Nesting is only applied when the source corpus itself explicitly supports a sub-module based on its inherent structure and dependencies.

What outputs do I get after partitioning a source corpus into modules?▼

Partitioning a source corpus outputs a root module-partitioning index file and per-module reference files. These outputs map source files to their respective bounded modules, establishing clear scope walls for downstream domain modeling and term-registry work.

When do I need to partition source context into modules instead of directly modeling classes?▼

You need to partition source context into modules when you require a defensible scope cut before any class-level modeling. It works by establishing module boundaries and file references first, preventing premature class modeling without clear scope walls.