sidtheone

The Chariot VII — The Narrative Breaker. Catches when a coherent story is being forced onto disconnected events. Breaks the LLM default of narrative fallacy — constructing smooth causal stories from data that may be coincidental, unrelated, or more complex than the narrative allows. Use this skill when a post-mortem feels too clean, when a success story skips the luck, when 'the reason this happened is' oversimplifies a complex outcome, or when the team is pattern-matching a narrative rather than examining what actually happened. Trigger on: 'chariot this', 'narrative check', 'is that really why', 'too clean', 'correlation check', 'what actually happened', or when the explanation feels more satisfying than true.

Death XIII — The Chaos Agent. Relentlessly curious chaos agent that pokes assumptions, pokes decisions, and pokes what everyone was too polite to touch. Not a reviewer — an enthusiastic disruptor who breaks LLM agreeableness through sheer character. Use this skill whenever you need something stress-tested, challenged, or chaos-checked — plans, code, architecture, PRDs, decisions, diffs, or any artifact where 'this looks fine' is the most dangerous sentence. Trigger on: 'chaos check', 'death this', 'what are we missing', 'challenge this', 'poke this', 'stress test', or when things feel too comfortable.

The Devil XV — The Chain-Breaker. Reveals what the team is chained to — sunk costs, legacy decisions, emotional attachments, and commitments that no longer serve them but feel impossible to abandon. Breaks the LLM default of sunk cost loyalty — continuing to invest in approaches, tools, patterns, or plans because of what's already been spent, not because they're still the right choice. Use this skill when a project feels stuck but nobody can articulate why, when 'we've already invested too much to change' is the argument, when switching costs feel impossibly high, or when a tool or pattern persists despite everyone privately knowing it's wrong. Trigger on: 'devil this', 'what are we chained to', 'sunk cost check', 'why can't we let go', 'chain check', 'what's holding us back', or when momentum exists but joy doesn't.

The Emperor IV — The Systems Thinker. Looks at the process, the rules, and the governance structures rather than the people or the code. Breaks the LLM default of governance blindness — blaming individuals, code quality, or technical choices when the system, process, or organizational structure is the actual problem. Use this skill when the same problems keep recurring despite fixing them, when 'we need better developers' is the refrain, when process feels like the bottleneck but nobody examines it, or when the org structure is shaping the architecture more than the architecture is shaping the org. Trigger on: 'emperor this', 'systems check', 'is the process the problem', 'why does this keep happening', 'governance review', 'Conway's Law check', or when fixing the symptom never fixes the problem.

The Empress III — The Builder. The only card that generates instead of critiques. Breaks the LLM default of critique-only mode — analyzing, deconstructing, and finding problems without ever producing alternatives or new options. Every other card tears down. This one builds up. Use this skill when the team has plenty of analysis but no options, when criticism has paralyzed action, when 'we know what's wrong but not what to do', or when the problem needs creative solutions, not more diagnosis. Trigger on: 'empress this', 'give me options', 'what could we build', 'generate alternatives', 'build mode', 'what are our options', or when the team is drowning in findings but starving for direction.

The Fool 0 — The Beginner. Approaches everything with fresh eyes, stripping away accumulated expertise to see what a newcomer would see. Breaks the LLM default of expertise bias — pattern-matching 'expert' solutions from training data instead of seeing the simple, obvious thing that experience makes invisible. Use this skill when a solution feels over-engineered, when onboarding is painful, when 'obvious' things aren't obvious, or when the team is so deep in their own context they can't see the forest. Trigger on: 'fool this', 'fresh eyes', 'beginner check', 'is this obvious', 'why is this so complicated', 'onboarding review', or when expertise might be the problem, not the solution.

The Hanged Man XII — The Reframer. Flips the problem upside down to question whether you're solving the right problem in the first place. Breaks the LLM default of framing compliance — accepting the problem as stated without questioning whether the framing itself is wrong. Use this skill when a problem feels stuck, when solutions keep not working, when the team is debating solutions but nobody is questioning the problem, or when the constraints feel artificial. Trigger on: 'hanged-man this', 'reframe this', 'are we solving the right problem', 'flip this', 'what if the problem is wrong', 'perspective shift', or when the team has been circling the same problem without progress.

The Hermit IX — The Depth-Seeker. Goes deep on one thing instead of skimming many. Breaks the LLM default of completeness theater — producing comprehensive-looking output that covers surface area without depth on what actually matters. Use this skill when you need deep analysis of a specific piece rather than broad coverage, when surface-level reviews keep missing the real issue, or when the answer requires tracing one thread all the way down. Trigger on: 'hermit this', 'go deep', 'deep dive', 'trace this', 'dig into this', 'I need depth not breadth', or when previous analysis was too shallow to be actionable.

The Filter (兔). Orchestrator and post-processor that makes LLM output actually readable. Invokes other zodiac animals based on what the user needs, then synthesizes and reshapes their raw output for the specific human reading it. Breaks the LLM default of audience-blind verbosity — walls of text, wrong detail level, buried answers, structured-for-machines formatting. Use this skill as the front door to the zodiac — give it a request, it picks the right animals, runs them, and delivers a shaped result you can actually use. Trigger on: 'rabbit this', 'filter this', 'make this readable', 'summarize the analysis', 'review this for me', or any request where the user wants actionable output shaped for their context rather than raw analytical findings.

The Chaos Monkey (猴). Relentlessly curious chaos agent that pokes assumptions, pokes decisions, and pokes what everyone was too polite to touch. Not a reviewer — an enthusiastic disruptor who breaks LLM agreeableness through sheer character. Use this skill whenever you need something stress-tested, challenged, or chaos-checked — plans, code, architecture, PRDs, decisions, diffs, or any artifact where 'this looks fine' is the most dangerous sentence. Trigger on: 'chaos check', 'monkey this', 'what are we missing', 'challenge this', 'poke this', 'stress test', or when things feel too comfortable.

The Consequence Mapper (鼠). Sees danger before everyone else. Maps every exit because missing one is fatal. Breaks the LLM default of linear thinking — following the happy path without tracing second and third-order effects. Use this skill when a change could have ripple effects — migrations, API changes, dependency updates, database schema changes, infrastructure moves, feature removals, refactors that touch shared code, or any change where 'what could go wrong' has more than one answer. Trigger on: 'consequence map', 'rat this', 'what could go wrong', 'blast radius', 'ripple effects', 'what breaks if', 'trace the impact', or when a change touches something that other things depend on.

The Solution Attacker (虎). Brave, aggressive stress-tester that attacks solutions from multiple angles to find fatal flaws. Breaks the LLM default of premature convergence — picking the first plausible approach and defending it instead of genuinely testing it. Use this skill when a solution has been chosen and you need to know if it's actually the best one or just the first one that worked — architecture proposals, design decisions, migration plans, technology bets, or any committed direction that hasn't been attacked yet. Trigger on: 'attack this solution', 'tiger this', 'is this really the best approach', 'stress test the decision', 'what are we not seeing', or when a proposal was accepted too quickly.

The Drift Detector (狗). Loyal to the original scent. Barks when the pack wanders from the trail. Breaks the LLM default of recency bias and context drift — optimizing for whatever was said last instead of what was said first. Use this skill when a project, feature, or conversation has been running long enough that the original intent might be lost — mid-sprint reviews, long-running features, scope discussions, PRDs that evolved over weeks, or any artifact where 'wait, what were we building again?' is a real question. Trigger on: 'drift check', 'dog this', 'are we still on track', 'what was the original plan', 'scope check', 'have we drifted', or when a project feels like it changed direction without anyone deciding to.

The Visionary (龙). Elevated, expansive thinker that analyzes present decisions for their temporal properties — reversibility, optionality, compounding, and entanglement. Breaks the LLM default of short-term thinking — solving the immediate problem without considering how today's choice shapes tomorrow's options. Use this skill when a decision has long-term consequences the team hasn't examined — architecture choices, technology bets, hiring structures, data model designs, vendor commitments, or any decision where the cost of being wrong increases with time. Trigger on: 'long-term check', 'dragon this', 'what does this decision lock in', 'are we thinking far enough ahead', 'what doors does this close', 'future-proof this', or when a decision feels permanent but is being treated as temporary.

The Wanderer (羊). Unhurried, curious explorer that climbs ridges nobody else bothers with because the view is different from up there. Breaks the LLM default of convergent thinking — jumping to the most common solution pattern from training data instead of exploring genuinely novel approaches. Use this skill when the solution feels obvious and you suspect that's the problem — when the team converged too fast, when every option on the table is a variation of the same idea, or when the problem deserves creative exploration before commitment. Architecture brainstorms, product ideation, stuck problems, technology selection, or any situation where 'what else could this be?' is the most valuable question. Trigger on: 'explore alternatives', 'goat this', 'what else could this be', 'think differently about this', 'creative options', 'we keep arriving at the same answer', 'what are we not considering', or when every proposed solution is a variation of the same pattern.

The Sprinter (马). Kinetic, impatient, trembling at the gate. Breaks the LLM default of over-planning and analysis paralysis — generating comprehensive plans, listing all considerations, enumerating all options when the answer is 'just start.' Use this skill when a project, decision, or feature is stuck in planning mode — too many meetings, too many documents, too many 'we need to think about this more' conversations. Sprint planning that never ends, architecture discussions that loop, PRDs that keep growing, or any situation where the team is confusing preparation with progress. Trigger on: 'are we overthinking this', 'horse this', 'just start', 'stop planning', 'what's blocking us really', 'analysis paralysis', 'we keep going in circles', or when a project has more planning documents than code.

4-step build loop for human+AI teams. Consumes plan.md (with Challenge section) from /insight-plan, then executes: Frame (triage) → Build (TDD + parallel worktrees) → Ship (merge + normalize + verify). Use after /plan produces artifacts, or for any scoped task ready to build. Trigger on: 'build this', 'execute the plan', 'run devloop', 'start building', or when plan.md exists and user wants to proceed.

Speed mode build loop. Same crew, same Monkey, less ceremony. Auto-triages (no approval gate for small/medium), confidence-filters findings (80+ only). The Monkey never sleeps — she just doesn't block. Use when you trust the plan and want to ship fast. Trigger on: 'fast build', 'quick build', 'devloopfast', 'speed mode', 'just build it'.

Exhaustive path enumeration for unhandled edge cases in code. Mechanically walks every branching path and boundary condition, reports only unhandled paths with guard snippets. Use on diffs, files, or functions after implementation. Trigger on: 'hunt edge cases', 'check for edge cases', 'find unhandled paths', 'review this diff for edge cases', or when /insight-devloop reaches the Ship step.

The Chaos Monkey. Relentlessly curious chaos agent that pokes assumptions, pokes requirements, and pokes what the crew was too polite to touch. Not a reviewer — an enthusiastic disruptor. Invoked at every step of /insight-devloop and /insight-devloopfast, also standalone. Trigger on: 'chaos check', 'monkey this', 'what are we missing', 'challenge this', or when the crew is too comfortable.

Work decomposition agent. Takes any plan.md and produces a deterministic frame.md — atomic tasks, worktree assignments, parallelization plan, test file mapping, sharpened acceptance criteria. Invoked by /insight-devloop Step 1, also standalone. Trigger on: 'frame this plan', 'decompose this', 'quartermaster', 'break this down for build'.

Implementation builder. Makes failing tests pass — fast, clean, no wasted wood. Follows blueprints exactly, adds nothing that isn't in the plan. Invoked by /insight-devloop Step 2b in isolated worktrees, also standalone. Trigger on: 'implement this', 'make tests pass', 'build from tests', 'shipwright'.

Adversarial code reviewer and consistency enforcer. Finds the leak before the sea does — irreversible decisions, implicit assumptions, failure modes under partial state, naming mismatches, and cross-module assumption conflicts. Invoked by /insight-devloop Step 3b, also standalone. Trigger on: 'adversarial review', 'storm review', 'find what breaks', 'review this diff', 'normalize this', 'check consistency', 'naming check', 'find inconsistencies'.

TDD contract writer. Derives failing test suites from plan intent — writes contracts that define behavior, not implementation. Invoked by /insight-devloop Step 2a, also standalone. Trigger on: 'write tests for this', 'TDD this plan', 'write contracts', 'sentinel', 'derive tests from plan'.

Guides building and testing conversational Claude skills. Use when creating a new skill, reviewing an existing skill, or iterating on skill design. Trigger when users say things like "create a new skill", "build a skill", "review this skill", or "make this skill better."

Deeply analyze codebase architecture and dependencies. Use when understanding system design, finding patterns, or mapping how components interact.

Project coding standards and conventions. Loaded automatically when writing or reviewing code to ensure consistency.

Fix a GitHub issue by implementing the requested changes

Summarize changes and discussion in a pull request

Brief description of when to use this skill

Research-backed business strategy advisor using MBA frameworks — no MBA required. Use when users discuss business viability, revenue models, market opportunity, pricing, competitive analysis, growth planning, or any business problem that needs structured thinking. Also trigger when users mention frameworks by name (SWOT, Porter's Five Forces, Blue Ocean, etc.) or say things like "is this business idea worth it?", "how should I price this?", "who are my competitors?", "should I launch this?", or "help me think through this business problem." Trigger even without MBA jargon — if they're describing a business challenge, this skill applies.

Cost-efficient code editing using a 4-tier cost ladder. Use for any edit, refactor, rename, replace, or transform request — single file or entire codebase. Automatically picks the cheapest approach: LSP-scoped ast-grep (free, semantic), ast-grep alone (free, structural), Haiku (cheap model edits), or Sonnet fallback (complex reasoning). Requires ast-grep and a language server to be available. Invoke with /smart-edit <description of change> [target path].

Helps users write sharp, constraining project values (VALUES.md) — both product values and engineering values that serve them. Use this skill whenever the user wants to define project values, create a VALUES.md, write guiding principles, establish a project philosophy, or figure out "what matters" for their codebase. Also trigger when users say things like "my AI keeps over-engineering", "too much abstraction", "I need guardrails for my project", "how do I stop framework drift", "what should my product care about", or "I have a PRD but no values" — these are values problems even if the user doesn't know it yet.