deepen

Audits module architecture and ranks refactoring candidates by evidence read from scoped code.

1|Updated Sep 10, 2026
One-click install
npx skills add https://github.com/blauwtje/exo --skill deepen-blauwtje
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: deepen
Source: https://github.com/blauwtje/exo/tree/main/skills/deepen
Command: npx skills add https://github.com/blauwtje/exo --skill deepen-blauwtje

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve? When you ask where or how to improve a codebase's architecture without naming a specific change, you get vague impressions instead of grounded findings. This Skill audits modules for shallow interfaces, coupling, and tech debt, producing ranked refactor cards backed by files and symbols actually read. ## Core Features & Use Cases - Scoped architecture audit: Audits a named path, module, or pain point, or derives scope from git churn hotspots over the last six months via scripts/hotspots.mjs. - Delegated evidence-based analysis: Dispatches a general-purpose delegate on Opus that reads the scoped code within a strict read budget and writes at most 5 ranked cards with friction, refactor, payoff, confidence, and migration cost. - Two output modes: Produces ranked cards in the reply, or in a read-only planning mode writes a full plan artifact following the planning skill's plan specification. - Use Case: Ask where the coupling problems are in your checkout flow, and receive ranked cards naming exact files and symbols, each with the interface the refactor leaves and its migration cost. ## Quick Start Ask the assistant to run the deepen skill on the payments module to find the refactors that would give it a smaller interface over its implementation.

Frequently Asked Questions about deepen

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

FAQPage Schema
How do I find refactoring candidates in a large codebase?▼

Run an architecture audit scoped to a path or module, or let the hotspots script rank the paths committed to most in the last six months. A delegate reads the scoped code and writes at most 5 ranked cards, each naming files, friction, the refactor, payoff, confidence, and migration cost.

What is a shallow module and how is it detected?▼

A module is shallow when learning its interface teaches most of its implementation. The audit applies the deletion test: imagine inlining the module, and if complexity gathers in one place it is shallow; if it only spreads, the claim is recorded as friction instead.

Can this audit run in a read-only planning mode?▼

Yes. In a read-only planning mode or when a plan is requested, the skill audits and then writes a plan for the top findings into the harness's plan file or docs/plans/<topic>.md, following the planning skill's plan specification. Otherwise it returns ranked cards with no edits.

When should I not use an architecture audit skill?▼

Do not use it for a single named refactor or rename, which is a decided change for a refactoring skill, nor for failing existing behavior, which routes to debugging. It also does not perform security or dependency audits.

Why does the audit survive context compaction?▼

The delegate writes the ranked cards to <git dir>/exo/deepen/<topic>.md, which acts as a compaction anchor. After a compaction, the session rereads that file rather than rerunning the audit or re-reading the scoped code.