From act101
Execute structural decompositions based on an architectural analysis report. Use when breaking circular dependencies, splitting god classes, reducing coupling between modules, extracting interfaces at seam boundaries, or executing any large-scale structural change identified in an architectural analysis. Requires the architectural-analysis skill to have been run first.
npx claudepluginhub act101-ai/act101 --plugin act101This skill uses the workspace's default tool permissions.
Execute structural decompositions based on an architectural analysis report.
Identifies refactoring opportunities by surfacing architectural friction using deletion test, deep-modules vocabulary, and seams analysis. For reviewing large files or architecture concerns.
Improves architecture incrementally by fixing circular dependencies, high coupling, god files, boundary violations, and unclear module structures without full migration. Scans and measures before/after.
Discovers architectural friction, proposes deep-module refactors with competing interface designs, and creates GitHub RFC issues. Use to improve architecture, deepen modules, or boost testability.
Share bugs, ideas, or general feedback.
Execute structural decompositions based on an architectural analysis report.
The architectural-analysis report must exist at docs/architectural-analysis-report.md.
If it doesn't exist, run the architectural-analysis skill first.
Start from the report — Read the analysis report first. Every refactoring decision should trace back to a finding in the report.
Find seams, don't invent them — Use act analyze seams to identify natural boundaries. Refactor along these boundaries, not against them.
Evaluate before cutting — Before extracting a module, use act analyze surface --files <files> to measure the API surface. If the surface is too wide, the extraction will create more coupling, not less.
Break cycles first — Circular dependencies are the highest priority. Use act analyze cycles to find them, then break the simplest edge in each cycle.
Extract interfaces at seams — At each seam boundary, extract an interface that both sides depend on. Use act query interface <file> to understand the current API, then act refactor extract-interface to create it.
Stable foundations first — Start with the most stable modules (lowest instability in act analyze coupling). Make them independent before touching unstable modules.
Measure coupling reduction — After each refactoring step, re-run act analyze coupling and act analyze cycles to verify that coupling decreased and cycles were broken.
Use dead code analysis for cleanup — Before and after each major refactoring, run act analyze dead-code to identify symbols that are no longer needed.
Document the architecture — After each major change, update the analysis report by re-running architectural-analysis.
Incremental, verifiable steps — Each refactoring step should be small enough to verify independently. Commit after each step. Never make multiple structural changes at once.
act analyze cycles / act analyze coupling)
b. Plan the refactoring (identify seams, measure surface)
c. Execute the refactoring using act refactor operations
d. Verify the fix (re-run analysis, check tests)
e. Commitrefactoring skill for individual operations (rename, extract, move)code-generation skill for scaffolding new modulescode-navigation skill to understand code before modifying itact analyze cycles with --max-length 3 to focus on the tightest cycles firstact analyze coupling --threshold 0.7 to focus on the most unstable modulesact query skeleton instead of reading full files