map-systems

Decompose concepts into modules and map dependencies into a prioritized design plan.

3|Updated Jun 3, 2026
One-click install
npx skills add https://github.com/Negentropy-Laby/Constitution-Driven-Development --skill map-systems-negentropy-laby
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: map-systems
Source: https://github.com/Negentropy-Laby/Constitution-Driven-Development/tree/main/.agents/skills/map-systems
Command: npx skills add https://github.com/Negentropy-Laby/Constitution-Driven-Development --skill map-systems-negentropy-laby

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams break down a concept into modular components, map their dependencies, and generate a prioritized design index to guide architecture and implementation planning.

Core Features & Use Cases

  • Automates concept-to-module decomposition across game and general product domains.
  • Maps dependencies, reveals design order, and highlights critical bottlenecks.
  • Generates a living module index at design/cdd/module-index.md for planning and handoff.
  • Supports optional assets directories for references and artifacts.

Quick Start

Invoke the skill with /map-systems to begin decomposing a concept into modules and generate the initial module index.

Frequently Asked Questions about map-systems

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

FAQPage Schema
How do I decompose a product concept into modules and map dependencies?

To decompose a product concept into modules, you read concept documents and design artifacts to enumerate modules, map dependency layers, and generate a prioritized design index for architecture planning.

What is the best way to plan early architecture and module enumeration?

The best way to plan early architecture is to map concept dependencies into layered modules and produce a prioritized design order. This highlights critical bottlenecks and generates a module index for planning and handoff.

How do I generate a module index with dependency layers from design documents?

You generate a module index with dependency layers by reading concept documents and design artifacts, decomposing the concept into modules, and mapping dependencies to output a prioritized design plan at module-index.md.

Can I use concept decomposition and dependency mapping for game design planning?

Yes, concept decomposition and dependency mapping applies to game design planning. It breaks down game concepts into modular components, maps dependencies, and generates a prioritized design index to guide implementation.

Does system decomposition support optional assets directories for references?

System decomposition does support optional assets directories. It reads concept documents and design artifacts while allowing you to include optional assets directories for references and artifacts during architecture planning.

How do I determine the recommended design order after mapping module dependencies?

You determine the recommended design order by mapping module dependencies to reveal layers and critical bottlenecks. This produces a prioritized design plan that guides the sequence of architecture and implementation tasks.