az-skills

Call the premium Fable advisor through Claude Code CLI from Codex for hard judgment, architecture, product thinking, frontend/design critique, and high-stakes decisions. Treat the advisor as the smartest and most expensive local AI. Use when the user asks to call an advisor, consult Fable/Claude, get a second opinion, compare another agent's output, improve design quality, reason through a hard problem, start or resume an advisor session, reuse advisor/Fable session cache, use high thinking/effort, or manage Claude Code background agents while controlling cost. Prefer call-worker for routine implementation, fast code edits, tests, and mechanical cleanup.

Call the fast Codex GPT-5.5 worker through Codex CLI from Codex or another terminal for clean code implementation, focused repo exploration, tests, refactors, bug fixes, and mechanical engineering tasks. Treat the worker as fast and strong at code, but less suited than the Fable advisor for hard judgment and frontend/design taste. Use when the user asks to call a worker, trigger Codex from the CLI, delegate bounded code work, run Codex outside the Codex IDE/app, run non-interactive codex exec, resume or reuse a worker/Codex CLI thread, use GPT-5.5 with high reasoning effort, or wrap Codex CLI behavior for repeatable agent runs. Prefer call-advisor for expensive advisor work, design critique, architecture judgment, and ambiguous strategy.

Before implementing a feature or non-trivial change, scan the code it will land in and surface prep refactors that make the change easy — so the feature lands clean instead of accreting tech debt (Kent Beck "make the change easy, then make the easy change"). Use BEFORE writing code, when about to build a feature, add a new case/provider/handler to an existing pattern, restructure in service of upcoming work, or just after an implementation plan is set. Every proposal must trace to the upcoming change — not generic cleanups. Skip tiny edits and brand-new code; for changes already written use complexity-check instead.

Audit an AI answer back to the searches, sources, citations, and assumptions behind it — which results actually shaped it, and which claims are unsupported model guesswork. Traces what the answer was based on; does not grade whether it is correct. User-run on an answer (with its question if available); read-only — never alters the answer.

Multi-persona naming exploration with consensus. Spawns parallel sub-agents — each embodying a different naming philosophy (David Placek's Lexicon methodology, the Poet, the Linguist, the Culture Hacker, the Futurist) — to explore divergent naming directions for a product or company, then synthesizes into a ranked shortlist. Based on David Placek's naming framework (Lexicon Branding — Swiffer, BlackBerry, Impossible, Sonos, Pentium). Use when naming a product, company, feature, or brand and you want breadth, surprise, and strategic advantage before committing.

Turn an ai-answer-audit into a prioritized plan to get a brand cited in AI answers (ChatGPT, Perplexity, Google AI Overviews). Acts only on the audit's affectable content layer — earned citations, your own pages, open territory — and never promises to move the model layer. User-run on an audit + your brand/URL; a one-shot plan, not citation monitoring.

5 legendary designers debate your brief in parallel using the most powerful AI model available. Spawns sub-agents as Dieter Rams, Jony Ive, Massimo Vignelli, Naoto Fukasawa, and Hella Jongerius — each explores independently, then synthesizes into a ranked consensus. Use when starting a new screen, component, or visual direction and you want breadth before committing.

Multi-lens code review — spawns parallel sub-agents to independently review branch changes for bugs, security, and design, then validates and reports only high-signal findings. Use when you want a thorough review before merging or when self-reviewing your own changes.

Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Use when asked to "simplify code", "clean up code", "refactor for clarity", "improve readability", or review recently modified code for elegance. Focuses on project-specific best practices.

After making changes, audit the diff through four lenses — Additions, Premises, Spread, Duplicates — to catch overbuilt changes and surface simplification opportunities the change itself can't see. Use after implementing a feature, refactor, or bug fix, before committing. Apply only the lenses that have signal to find for your diff; mark the rest N/A.

Remove AI-generated code slop and clean up code style

5 legendary engineers debate your problem in parallel using the most powerful AI model available. Spawns sub-agents as John Carmack, Rich Hickey, Sandi Metz, Linus Torvalds, and Kent Beck — each explores independently, then synthesizes into a ranked consensus. Use when facing architectural decisions, non-obvious implementation choices, or when you want to stress-test an approach from multiple angles before committing.

Greenlight a PR — fix CI failures, triage review comments, iterate until green.

Build a durable, evidence-backed "book" of how an engineering project evolved by mining git history, PRs, releases, and docs. Use when the user wants repository archaeology, commit-by-commit walkthroughs, engineering learning extraction, pivot analysis, or a readable chronology of what the team changed, learned, reverted, and refined over time.

Submit concise feedback about AZ skills directly to PostHog. Use when a skill was useful, confusing, broken, missing context, or worth improving.

Take a guided tour of a codebase subsystem — explore the code in parallel, then produce a self-contained HTML tour document that teaches the architecture so the reader doesn't need to read the code themselves. Optionally critiques the architecture for issues.

Interview the user about a plan, design, or idea until reaching shared understanding. Walks down every branch of the decision tree, resolving dependencies one by one. Maintains a durable transcript on disk so the interview survives context loss. Use when you want to stress-test a plan, think through a design, or need the agent to gather all the context it needs before building.

Rank mental models from Noah Zender's curated 468-item idea library by leverage for your current situation, with one concrete way to apply each. Use when you're at a decision point — naming, positioning, writing, picking a project, scoping work — and you want frameworks that actually fit your case, not generic mental-models advice. Default source library: noahzender.com/ideas.

Turn whatever's in the current conversation into one prompt to hand to the agent's `/goal` orchestration loop (Claude Code, Codex, or any harness with the same shape). The prompt is re-injected on every turn of the loop, so it must hold direction, taste, and a self-verification path across many iterations. Use when you're ready to hand a piece of work to `/goal`.

Turn a multi-objective piece of work into a roadmap on disk plus a small pointer prompt for the agent's `/goal` orchestration loop. Each sub-goal in the roadmap is shaped like a single `plan-for-goal` output; the roadmap holds the multi-goal scaffolding that wouldn't fit in `/goal`'s 4000-character objective limit. Use when the conversation has 3+ distinct objectives that share a destination.