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.