tail-wag

Detect and rank architectural inversions in software systems.

30|12|Updated Jun 21, 2026

Search Tags:#architecture #refactoring #code-analysis #design-patterns #technical-debt

Ready to run

npx skills add https://github.com/anthony-chaudhary/fak --skill tail-wag

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: tail-wag
Source: https://github.com/anthony-chaudhary/fak/tree/main/.claude/skills/tail-wag
Command: npx skills add https://github.com/anthony-chaudhary/fak --skill tail-wag

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill identifies architectural inversions where peripheral or secondary concerns are disproportionately driving core design decisions, helping you simplify your codebase by realigning priorities.

Core Features & Use Cases

Inversion Detection: Automatically scans codebases to find where low-level details like vendor-specific error codes or minor configuration needs are dictating high-level architecture.
Prioritized Analysis: Ranks findings based on inversion severity, blast radius, and counterfactual cheapness to ensure you focus on the most impactful refactors.
Use Case: Use this when you notice that a single vendor's API quirks are forcing complex workarounds throughout your entire application, making the system brittle and hard to maintain.

Quick Start

Run the tail-wag skill on the current directory to identify and rank the most significant architectural inversions.

Frequently Asked Questions about tail-wag

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

FAQPage Schema

How do I detect architectural inversions in my codebase?▼

To identify architectural inversions, systematically inspect routing, storage, and configuration patterns to calculate inversion severity and blast radius, revealing where peripheral concerns disproportionately influence core design.

What are architectural inversions in software engineering?▼

Architectural inversions occur when peripheral or secondary concerns, such as minor configuration needs or vendor-specific API quirks, disproportionately dictate high-level architecture, making the system brittle and difficult to maintain.

How do I refactor code to reduce technical debt from vendor API workarounds?▼

Refactoring to reduce technical debt involves analyzing your system to rank architectural inversions by blast radius and counterfactual cheapness, identifying opportunities for simplification and decoupling from vendor-specific constraints.

Can this tool analyze infrastructure layers and configuration surfaces for design flaws?▼

Yes, analyzing infrastructure layers and configuration surfaces is supported. The tool systematically inspects these areas alongside codebases to identify and rank opportunities for decoupling and simplification.

What is the best way to prioritize refactoring efforts in a complex software system?▼

Prioritize refactoring efforts by ranking architectural inversions based on their severity, blast radius, and counterfactual cheapness, ensuring you focus on the most impactful decoupling opportunities first.