dev-architecture-governor

Name: dev-architecture-governor
Availability: InStock
Author: Grig

Analyze codebase structure and generate incremental refactoring plans.

4|Updated Dec 7, 2025

Search Tags:#design #architecture #refactoring #codebase #governance #dependency

Ready to run

npx skills add https://github.com/grigb/gas-prompt-library --skill dev-architecture-governor

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: dev-architecture-governor
Source: https://github.com/grigb/gas-prompt-library/tree/main/agents/agent-dev-architecture-governor
Command: npx skills add https://github.com/grigb/gas-prompt-library --skill dev-architecture-governor

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the risks associated with large-scale codebase refactoring, such as circular dependencies, bloated files, and architectural drift, by providing a structured, incremental approach to structural improvements.

Core Features & Use Cases

Structural Analysis: Evaluates codebase organization, dependency direction, and module boundaries to identify technical debt.
Incremental Refactor Planning: Generates step-by-step, low-risk migration plans for decomposing monolithic files or correcting layer violations.
Use Case: When a core file like App.tsx grows unmanageable, this skill maps responsibilities, proposes domain-based splits, and sequences the refactor into small, verifiable PRs.

Quick Start

Invoke the dev-architecture-governor to analyze the current dependency graph and propose an incremental refactor plan for the identified oversized modules.

Frequently Asked Questions about dev-architecture-governor

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

FAQPage Schema

How do I plan a large-scale codebase refactoring without breaking existing dependencies?▼

Codebase refactoring requires an incremental approach that applies safety protocols and verification gates to ensure system stability. You map module boundaries and sequence structural improvements into small, verifiable PRs to prevent architectural drift.

What is the best way to fix circular dependencies and bloated files in a complex software project?▼

Fixing circular dependencies and bloated files involves structural analysis to evaluate codebase organization and dependency direction. This identifies technical debt and generates step-by-step, low-risk migration plans for decomposing monolithic files.

How do I split an oversized core file like App.tsx into manageable modules?▼

Splitting an oversized file like App.tsx requires mapping its responsibilities and proposing domain-based splits. The refactor is then sequenced into incremental execution patterns, ensuring each step is a small, verifiable PR.

When do I need architectural governance for software projects?▼

Architectural governance is needed when complex software projects face structural risks like layer violations, bloated files, and circular dependencies. It provides oversight and incremental refactoring strategies to correct module boundaries safely.

Does incremental refactoring require specific verification gates for each pull request?▼

Yes, incremental refactoring requires adherence to defined safety protocols and verification gates for each step. These gates ensure system stability during module boundary definition and dependency management tasks.

Can I use this approach to correct layer violations in my codebase organization?▼

Yes, you can correct layer violations by evaluating codebase organization and dependency direction. This process generates step-by-step, low-risk migration plans to enforce proper module boundaries during structural improvements.