improve-architecture

Name: improve-architecture
Availability: InStock
Author: HerbertJulio

Detect circular dependencies, god files, and unclear module boundaries in codebases.

20|3|Updated Feb 22, 2026

Search Tags:#architecture #refactor #incremental #circular-dependency #module-boundaries #god-files

Ready to run

npx skills add https://github.com/HerbertJulio/specialist-agent --skill improve-architecture

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: improve-architecture
Source: https://github.com/HerbertJulio/specialist-agent/tree/main/skills/improve-architecture
Command: npx skills add https://github.com/HerbertJulio/specialist-agent --skill improve-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Architectural issues like tight coupling, circular dependencies, and unclear module boundaries slow teams down and make future changes risky. This Skill helps identify and address those issues incrementally without requiring a full migration.

Core Features & Use Cases

Architecture Scan: detect hotspots such as circular dependencies and oversized modules.
Guided Refactors: propose single-responsibility improvements and boundary corrections without rewriting large swaths of code.
Use Case: a legacy monolith can be gradually modularized, reducing coupling and enabling safer future migrations.

Quick Start

Run the improve-architecture skill on your targeted module to begin incremental architectural fixes.

Frequently Asked Questions about improve-architecture

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

FAQPage Schema

How do I fix circular dependencies and god files without a full rewrite?▼

Incremental architecture improvement identifies circular dependencies and god files to enable targeted refactors. It proposes single-responsibility fixes and boundary corrections without rewriting large swaths of code or requiring a full migration.

What is the best way to tighten module boundaries in a legacy monolith?▼

Tightening module boundaries in a legacy monolith is done through gradual modularization. This approach reduces coupling by applying structured analysis steps and lightweight validation without altering runtime behavior.

Can I use incremental refactoring on a medium-to-large codebase before migration?▼

Incremental refactoring is designed for medium-to-large codebases undergoing pre-migration cleanups. It detects architectural hotspots and recommends targeted fixes so teams can safely tighten boundaries before a full migration.

How does an architecture scan detect unclear module boundaries?▼

An architecture scan detects unclear module boundaries by identifying hotspots such as oversized modules and tight coupling. It applies structured analysis steps to map these issues and tracks progress with lightweight validation.

Why does refactoring module boundaries not alter runtime behavior?▼

Refactoring module boundaries does not alter runtime behavior because the process focuses on structural reorganization rather than functional changes. It uses lightweight validation steps to ensure improvements are safe and targeted.

When should I not use a full rewrite for architectural issues?▼

A full rewrite is not necessary when architectural issues like tight coupling and unclear boundaries can be addressed incrementally. This approach applies guided refactors and boundary corrections to reduce risk without a complete rewrite.