improve-architecture

Identifies shallow modules in a codebase and designs deeper module interfaces through parallel subagent analysis.

1|Updated Mar 26, 2026
One-click install
npx skills add https://github.com/arndvs/ctrlshft --skill improve-architecture-arndvs
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: improve-architecture
Source: https://github.com/arndvs/ctrlshft/tree/main/skills/improve-architecture
Command: npx skills add https://github.com/arndvs/ctrlshft --skill improve-architecture-arndvs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Codebases accumulate shallow modules whose interfaces are nearly as complex as their implementations, creating coupling, integration risk, and friction when navigating many small files. This Skill systematically finds those architectural weak points and turns them into actionable refactor proposals. ## Core Features & Use Cases - Deep Module Analysis: Explores the codebase with subagents to locate shallow modules, scattered concepts, and tightly coupled seams. - Parallel Interface Design: Spawns multiple subagents to produce 3 radically different interface designs for a chosen candidate, then recommends the strongest option or a hybrid. - Refactor RFC Creation: Converts the accepted design into a GitHub issue describing current state, proposed interface, migration path, and affected files. - Use Case: During a periodic codebase health check, ask the agent to find shallow modules; it presents 3-5 candidate clusters, you pick one, and it delivers competing interface designs plus a ready-to-file refactor RFC. ## Quick Start Ask the agent to improve the codebase architecture by finding shallow modules and proposing deeper interface designs.

Frequently Asked Questions about improve-architecture

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

FAQPage Schema
How do I find shallow modules in my codebase?▼

Run the skill and it uses subagents to explore the codebase, flagging modules whose interfaces are nearly as complex as their implementations. It presents 3-5 candidate clusters with the files involved, why they are coupled, and the friction they create.

What is a deep module in software architecture?▼

A deep module has a small interface hiding a large implementation, so callers get significant functionality through minimal surface area. Shallow modules are the opposite: their interface complexity rivals their implementation, adding coupling without hiding complexity.

How does the skill generate interface design options?▼

After you pick a candidate cluster, it spawns multiple subagents in parallel, each producing a radically different interface design. It then presents all options, recommends the strongest, and can propose a hybrid combining elements from different designs.

Can this skill create a refactor proposal for my team?▼

Yes. Once you accept a design, it creates a GitHub issue as a refactor RFC describing the current state, the proposed interface, the migration path, and the affected files, ready for team review.

When should I not use deep module refactoring?▼

Avoid it when modules are shallow because they are genuinely simple utilities, or when a refactor would destabilize code under active change. The skill is best suited for coupled clusters where integration risk concentrates at module seams.