Verified:GitHub

propose-decomposition

Propose a polymorphic decomposition plan from codebase structure and coverage gaps.

3|Updated May 11, 2026

Search Tags:#codebase analysis #human-in-the-loop #coverage gaps #governed execution #dependency graphs #refactor planning

Ready to run

npx skills add https://github.com/JeromyJSmith/lattice-platform --skill propose-decomposition

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: propose-decomposition
Source: https://github.com/JeromyJSmith/lattice-platform/tree/main/.agents/skills/propose-decomposition
Command: npx skills add https://github.com/JeromyJSmith/lattice-platform --skill propose-decomposition

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps the organism identify where the harness should be decomposed next so the codebase improves without performing the risky execution step automatically.

Core Features & Use Cases

Self-inspection proposal: Analyzes codebase structure and coverage gaps to propose targeted decomposition points rather than executing changes.
Graph- and topic-aware planning: Uses dependency graph analysis and topic modeling to motivate candidate splits and surface coupling hotspots.
Safety-first governance: Enforces an inert mode for Phase 1, a depth guard, and a mandatory human checkpoint for deciding whether to run the actual cell-divide.

Quick Start

Use propose-decomposition to generate a human-readable refactor plan for the next harness split after Phase B, optionally focusing on a specific section with focus_section.

Frequently Asked Questions about propose-decomposition

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

FAQPage Schema

How do I plan a safe codebase refactor without automatically executing risky changes?▼

You can plan a safe codebase refactor by generating a human-readable decomposition proposal that analyzes structure and coverage gaps. This approach surfaces candidate targets and risk callouts while remaining completely inert, requiring a mandatory human checkpoint before any execution.

What is polymorphic decomposition and when do I need it for modularization?▼

Polymorphic decomposition is a codebase modularization technique that inspects dependency graphs and coverage gaps to identify safe splitting points. You need it when preparing for harness or genome modularization scenarios and want a controlled, human-gated plan rather than automated refactoring.

How do I find coverage gaps and coupling hotspots before splitting a large codebase?▼

To find coverage gaps and coupling hotspots, use dependency graph analysis combined with topic modeling to motivate candidate splits. This process generates a filesystem-backed proposal artifact containing lineage depth estimates and risk callouts for targeted decomposition points.

Can I focus a refactor proposal on a specific codebase section?▼

Yes, you can focus your refactor proposal on a specific codebase section by providing a focus section parameter. This constrains the decomposition analysis to generate targeted candidate targets and risk callouts for the specified area rather than the entire codebase.

What are the limitations of automated decomposition planning in Phase 1?▼

Automated decomposition planning in Phase 1 is strictly limited by an inert mode and a depth guard constraint, meaning it cannot execute refactor actions. Additionally, the planning process requires Phase B sensory availability to function and only emits a proposal artifact for human review.

Does dependency graph analysis work for generating refactor plans with human review?▼

Dependency graph analysis works for generating refactor plans by inspecting the codebase structure to identify coupling hotspots and candidate splits. It produces a filesystem-backed proposal artifact with lineage depth estimates while enforcing governed execution through a mandatory human checkpoint.