improve-codebase-architecture

Identify codebase refactoring opportunities using the deletion test and ADR-aware candidate framing.

1|Updated May 6, 2026
One-click install
npx skills add https://github.com/ThorStarlord/interface-skills --skill improve-codebase-architecture-thorstarlord
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: improve-codebase-architecture
Source: https://github.com/ThorStarlord/interface-skills/tree/main/skills/improve-codebase-architecture
Command: npx skills add https://github.com/ThorStarlord/interface-skills --skill improve-codebase-architecture-thorstarlord

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill reduces architectural friction by identifying refactoring opportunities where the current module boundaries are shallow, hard to test, and poorly discoverable by both humans and AI agents.

Core Features & Use Cases

  • Deepening opportunity discovery: explores the codebase to find places where the “deletion test” suggests complexity should be consolidated into deeper modules.
  • ADR-aware candidate framing: surfaces architectural friction and flags conflicts when a proposal would contradict a recorded architectural decision.
  • Testability and AI-navigability focus: emphasizes placing the seam so the interface becomes the test surface and documentation is routed for agent discovery.

Quick Start

Ask the AI to run the deepening exploration and list 3–5 architecture candidates in the area you’re working on, then pick one candidate to grill for seam placement and testing strategy.

Frequently Asked Questions about improve-codebase-architecture

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

FAQPage Schema
How do I find refactoring opportunities to make shallow codebase architecture more testable?

To find refactoring opportunities, you can explore the codebase to identify where the deletion test suggests consolidating complexity into deeper modules. This surfaces shallow boundaries and finds areas where increasing module depth improves testability, locality, and AI agent navigability.

What is the deletion test in software architecture and how does it improve module boundaries?

The deletion test is a technique used to evaluate module boundaries by assessing whether consolidating complexity into a deeper module increases leverage and locality. Applying it helps clarify seams and ensures interfaces become effective test surfaces for maintainable architecture.

How do I place seams and adapters in a codebase to improve testing strategy?

To place seams and adapters effectively, you frame architectural candidates and grill them for optimal seam placement. This ensures the interface becomes the primary test surface while routing documentation for agent discovery, resulting in a robust testing strategy.

Can I use ADR-informed design to resolve architectural friction during refactoring?

Yes, you can use ADR-informed design during refactoring to surface architectural friction. It flags conflicts when a proposed refactoring candidate contradicts a recorded architectural decision, ensuring new module boundaries align with existing project constraints.

What is the best way to make a complex codebase easier to navigate for AI agents?

The best way to make a codebase navigable for AI agents is to deepen modules and place seams so documentation is explicitly routed for agent discovery. This reduces architectural friction by ensuring interfaces are clear and dependencies are easy to test.

When should I avoid deepening modules in a codebase architecture?

You should avoid deepening modules when the deletion test shows that consolidating complexity would reduce locality or create conflicts with existing ADRs. If the current shallow interface already provides high leverage and clear test surfaces, deepening is unnecessary.