improve-arch

Identify architectural frictions and propose deep module refactor candidates.

5|Updated Apr 24, 2026

Search Tags:#testing #architecture #refactoring #code-quality #seams #deepening #domain-glossary

Ready to run

npx skills add https://github.com/timurgaleev/vibestack --skill improve-arch

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: improve-arch
Source: https://github.com/timurgaleev/vibestack/tree/main/skills/improve-arch
Command: npx skills add https://github.com/timurgaleev/vibestack --skill improve-arch

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Surface architectural friction in a codebase and surface opportunities to deepen modules through refactors that tighten the interface while maintaining or improving behaviour and testability.

Core Features & Use Cases

Identify shallow modules where the interface is as complex as the implementation and propose targeted deepening strategies that increase leverage and locality.
Align changes with project domain language (e.g., from CONTEXT.md) and ADRs to avoid re-litigating decisions.
Generate candidate deep module architectures and evaluation criteria to guide reviews and testing.

Quick Start

Ask the system to find deepening opportunities in the current codebase and propose concrete refactor options.

Frequently Asked Questions about improve-arch

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

FAQPage Schema

How do I identify shallow modules in my codebase that need refactoring?▼

Identify shallow modules by analyzing code where the interface complexity matches the implementation, then propose targeted deepening refactors to increase leverage and locality.

What is a deepening refactor in software architecture?▼

A deepening refactor tightens a module's interface while preserving existing behavior, increasing locality and leverage to improve code testability without altering functionality.

How do I align architectural refactoring with existing project domain language?▼

Align refactors by referencing project domain vocabulary like CONTEXT.md and ADRs, ensuring consistent naming and avoiding re-litigating prior architectural decisions.

What's the best way to find architectural friction for testable code?▼

Surface architectural friction by analyzing modular projects to generate deepening candidates, evaluating them against criteria that maintain behavior while improving testability.

Can I use architectural seams to guide code refactoring?▼

Architectural seams help identify deepening opportunities by isolating modules, allowing targeted refactors that tighten interfaces and improve testability without breaking existing behavior.

When should I not use deepening refactors on my codebase?▼

Avoid deepening refactors when the codebase lacks modular structures, domain vocabulary, or ADRs, as these are required to guide consistent naming and evaluate targeted refactor candidates.