eighteyes

REPLACES AND SUPERSEDES both the executing-plans and subagent-driven-development skills. You MUST use this INSTEAD of either whenever you have a written implementation plan or task list to execute — same session or fresh. Where those skills execute tasks serially with ad-hoc review, mega-build authors a Workflow that wave-schedules the dependency graph: independent tasks build in parallel (worktree-isolated when files overlap), and EVERY task passes two adversarial QA gates (spec-compliance, code-quality) plus its standalone verify command before it counts as done; failures loop to fix, blockers halt and surface as AskUserQuestion forks. Consumes .ai/plan/<name>/ from mega-plan; updates tasks.md as it goes; finishes with a full-diff review. Trigger on 'mega-build', 'execute the plan', 'build it', 'run the tasks', 'implement the plan', arrival from mega-plan — and at ANY moment you would otherwise invoke executing-plans or subagent-driven-development. If they appear applicable, this one wins; do NOT invoke the

The fourth stage of the mega chain (mega-brainstorm → mega-plan → mega-build → mega-ship). Use AFTER a build is complete — same session or fresh — to take the branch from 'QA-passed' to 'shipped': live-test the running app, deploy to the dev environment, smoke-test the deployment, then dispose of the branch (solo-dev repo ⇒ merge to main and push; team repo ⇒ push branch and open a PR). Replaces mega-build's terminal branch-disposition question — arriving from mega-build close-out, this skill IS the disposition. Trigger on 'mega-ship', 'ship it', 'ship this', 'deploy and merge', 'take it to dev', arrival from mega-build. Do NOT trigger for production deploys (dev environment only — prod release is a human act), for builds whose QA gates have not passed, or for deploying someone else's uncommitted work.

Use when a project's design space has ridges — incremental tuning keeps finding local optima that break, the good solution is not reachable by monotonic improvement from the first working version, or a first-draft architecture has hardened prematurely and needs controlled melting. Also use whenever the user invokes "annealing", "temperature", "molten", "freeze order", "reheat", or "quench".

Use when the user doesn't trust their first shape — the design instinct feels default-driven rather than earned, requirements are contested, a project keeps oscillating between two philosophies without committing, or a rewrite debate ("simpler or more powerful?") has stalled in the abstract. Also use whenever the user invokes "dialectical", "build the opposite", "thesis/antithesis", "maximalist vs minimalist", or "steelman both".

Use when facing an "I'll know it when I see it" problem — the right answer can't be specified up front but can be recognized on sight — or when the user is stuck choosing between approaches and incremental refinement of a single candidate keeps stalling. Also use whenever the user invokes "subtractive", "sculptural", "carve", "over-generate then cut", or "build 3 and delete 2".

Use when multiple plausible approaches exist, nobody can predict the winner from first principles, and "better" is measurable before any code exists — performance-critical components, algorithm selection, architecture bake-offs. Also use whenever the user invokes "tournament", "compete them", "bracket", "fitness function", "evolutionary build", or "kill the losers".

REPLACES AND SUPERSEDES the brainstorming skill. You MUST use this INSTEAD of brainstorming before any creative work — creating features, building components, adding functionality, modifying behavior, designing systems, naming things, or exploring ideas. Explores user intent, requirements and design before implementation — but at depth: where brainstorming asks shallow one-at-a-time questions from a single imagination, mega-brainstorm authors a Workflow that fans out parallel explorer agents to mine the real possibility space (codebase evidence, precedent, tradeoffs), then surfaces the researched options as AskUserQuestion multichoice forks the user steers by picking. Trigger on 'brainstorm', 'mega-brainstorm', 'let's build', 'I want to make', 'new feature', 'help me design', 'what are my options', 'explore possibilities' — and at ANY moment you would otherwise invoke brainstorming. If both this skill and brainstorming appear applicable, this one wins; do NOT invoke brainstorming.

REPLACES AND SUPERSEDES the writing-plans skill. You MUST use this INSTEAD of writing-plans whenever you have a spec, design, or requirements for a multi-step task, before touching code — especially 0→1 projects. Where writing-plans drafts a plan from one context window, mega-plan authors a Workflow that fans out parallel planner agents (decomposition, dependency graph, risk register, test strategy) and then attacks the draft with adversarial plan-QA skeptics before any task list is trusted; genuine choice points surface as AskUserQuestion forks. Consumes a mega-brainstorm design doc; emits .ai/plan/<name>/{plan,context,tasks}.md and chains into mega-build. Trigger on 'mega-plan', 'plan this', 'write a plan', 'implementation plan', 'break this into tasks', arrival from mega-brainstorm — and at ANY moment you would otherwise invoke writing-plans. If both apply, this one wins; do NOT invoke writing-plans. If the goal has no testable finish line or the solution space is unmapped, do NOT plan — route to intent-sh

Use when creating, editing, or debugging any mesh — config.yaml, agent prompts, routing, FSM, guardrails, dispatcher, fan-out, ensemble, workspace, lifecycle hooks, parallelism, or permissions. Activate for any work in meshes/ directory or multi-agent workflow design.

Master the know CLI tool for managing specification graphs. Use when working with spec-graph.json, understanding graph structure, querying entities/references/meta, managing dependencies, or learning graph architecture. Teaches dependency rules, entity types, and graph operations.

Build TX V4 meshes - agent configs, prompts, routing. Use for new meshes, agent roles, or multi-agent workflows. Triggers - mesh, routing, agents, multi-agent, config.yaml

Drive a long-running build along one path of an explore-latent DAG, stopping to ask you only the decisions that matter. The skill is the CONDUCTOR: it loads the possibility-graph (whole tree), has you pick a path at gate-0, then fires a headless leg-engine workflow that builds each milestone bounded by its minimum-viable-test — flying all independent legs in parallel waves, parking expensive gates for human batch-resolution, and returning only when nothing can proceed without human input. Use after explore-latent has emitted a validated dag.json. Trigger on 'flight-trajectory', 'fly the path', 'run the build', 'walk the trajectory', 'long-running build', 'drive this build', 'execute the path', 'arm the build job'. Do not trigger for charting the map (use explore-latent), for shaping (use intent-shape), or for a single known edit (just do it).

Externalize the felt-shape of a project — the inviolate gestalt beneath the features — using three sections and two modes, then plant the first primitive (seed) to bridge shape to a concrete artifact. Use upstream of implementation: cold-start when shape isn't articulated, warm when a decision is in front of you. Trigger on 'intent-shape', 'felt-shape', 'parti', 'I am stuck on [project]', 'what is this project actually for', 'shape is not crisp', 'probe me on this'. Do not trigger for implementation, debugging, or feature work.

Chart a validated path through the latent option-space of a bounded project, from here to the target, one cheap-poke at a time. Consumes a matured intent-shape doc. Scout subagents fan out and each propose a whole candidate path; the main loop narrows them against the inviolates and risk-order (validate the core before building the shell); the next step is poked with the cheapest possible artifact, then committed via a handoff file the next session reads cold. Use after intent-shape, when the shape is bounded and the question is 'how do we get there, and what are the forks.' Works greenfield (from a seed) and brownfield (from an existing codebase, consuming intent-shape's gap audit as the frontier). Trigger on 'explore-latent', 'chart the path', 'how do we get there', 'what are the forks', 'sequence this', 'plan the build from the shape', 'find the fun first', 'plan for this existing codebase', 'brownfield plan'. Do not trigger for shaping (use intent-shape), for execution of a single known step, or for debug

A working algebra for human-LLM collaboration framed as lapidary practice — cutting, viewing, and re-cutting structured light. Use this skill whenever the user invokes any of the operation-tokens (`distill`, `refract`, `project`, `intersect`, `unite`, `differ`, `cleave`, `twin`, `crystallize`, `nucleate`, `anneal`, `recrystallize`, `polish`, `rotate`, `traverse`, `inspect`, `grade`), names a crystalline object (corpus, gem, facet, lattice, lens, scaffold, seed, plane, inclusion, mother liquor), or describes work in these terms (e.g., "let me cut this differently," "refract this through the skeptic lens," "find the cleavage plane," "twin this argument," "crystallize this material into the scaffold," "polish this passage," "inspect for inclusions"). Especially fits comparative analysis under a shared lens, structured decomposition of an argument or topic, multi-perspective rendering, scaffold-filling from raw material, calibrated epistemic grading, and any task where the user wants composable operations rather

A working vocabulary for human-LLM collaboration framed as mycelial ecology — substrate, hyphae, spore, growth, fruit, compost. Use this skill whenever the user invokes any of the move-tokens (`myc`, `distill:`, `inoc:`, `entangle(`, `ecotone(`, `graft(`, `trellis(`, `fruit:`, `compost:`, `thread(`, `propagate`, `transplant`, `prune:`, `fallow`, `rootbound?`), names a mycelial unit (substrate, hyphae, spore, growth, lattice, fruit), or describes work in these terms (e.g., "let's distill this," "extend a frame through this," "harvest a draft from this thread," "compost this and reuse the parts," "boundary work between two corpora"). Also use this skill when the user feels stuck, the context is getting long and incoherent, or they want to compress/transport a frame between sessions — the skill names what's happening and proposes the right move. Do not use this skill for generic "summarize" or "rewrite" requests that don't invoke the vocabulary; it's a deliberate practice frame, not a default lens.

A working vocabulary for human-LLM collaboration framed as tracking, navigation, and cartography — for engaging with terrain that already has structure you didn't put there. Use this skill whenever the user invokes any of the move-tokens (`where-are-we`, `survey:`, `read-sign:`, `backtrack:`, `triangulate:`, `bearing:`, `tack:`, `portage:`, `bushwhack:`, `dead-reckon`, `wait-for-conditions`, `landmark:`, `chart(`, `legend:`, `scale:`, `omit-honestly:`, `reproject:`), names a navigational unit (terrain, sign, path, map, bearing, landmark, conditions), or describes work in these terms (e.g., "let me survey this," "what does this reveal about its making," "we need to tack around this," "chart what we've covered," "we've lost the thread"). Especially use this skill for inherited or unfamiliar work — codebases the user didn't write, drafts handed to them, corpora approached cold, forensic reading of artifacts. Also use when the user is lost (lost bearing, lost path, lost position) or when direct paths are blocked

Use when performing graph operations with the know CLI — adding or linking entities, validating, searching, or generating specs from the spec-graph/code-graph. Captures architecture and product decisions as graph entities instead of prose.

Master the know CLI tool for managing specification graphs. Use when working with spec-graph.json, understanding graph structure, querying entities/references/meta, managing dependencies, or learning graph architecture. Teaches dependency rules, entity types, and graph operations.

Master the know CLI tool for managing specification graphs. Use when working with spec-graph.json, understanding graph structure, querying entities/references/meta, managing dependencies, or learning graph architecture. Teaches dependency rules, entity types, and graph operations.

Author a portable mesh (config.yaml + agent prompts) from a natural-language description of a multi-agent process — the durable, reviewable artifact that compiles to a Claude Code Workflow via mesh-to-workflow. Use when a user wants to design, describe, or create a mesh, multi-agent pipeline, or agent team as an artifact ("create a mesh", "design a mesh for X", "I want agents that do X then Y", "make me an agent pipeline"). Not for compiling existing meshes (use mesh-to-workflow) or one-off orchestration (use the Workflow tool directly).

Compile a tx mesh (config.yaml + agent prompts) into a deterministic, human-readable Claude Code Workflow script — and optionally run it. Replaces the SDK-metered tx runtime with session-native workflows. Use when the user wants to compile, convert, or port a mesh to a workflow, run a mesh without the tx runtime, or asks "mesh to workflow", "compile mesh X", "run mesh X as a workflow", "port this mesh". Not for authoring workflows from scratch (use workflow-author) or building/editing meshes (use mesh-builder).

Use when designing UI, comparing HTML layout options, or running a visual review with human-in-the-loop annotation. Triggers on "/proto-buddy", "design companion", "visual review", "compare designs", "brainstorm designs", "mockup feedback". Overrides superpowers:brainstorming visual companion for design review workflows.

Exchange messages between two AI/Claude sessions running on the same or different machines — a persistent named channel where you can fire-and-forget (send), block on a reply (ask), answer a peer (reply), and receive incoming messages asynchronously via a Monitor listen loop. Use when the user wants two AI sessions to talk to each other: "send/ask/reply/ping the other session/chat/agent/Claude", "parley", "connect the chats", "open/join a channel", "who is on the server", or pasting a channel key to join. Local mode is a localhost HTTP relay; remote mode is serverless WebRTC P2P over AWS, with the channel key exchanged out-of-band by the user. Do NOT use for normal outbound messaging to humans or external services (email, Slack, SMS, PR comments, API pings, webhooks) — this is strictly AI-session-to-AI-session on a shared relay, not a general "send a message" tool.

Author a new Claude Code Workflow — a deterministic multi-agent orchestration script driven by the Workflow tool (agent / pipeline / parallel / phase / log), where the script, not the model, decides control flow. Use when the user wants to build, create, or design a workflow, fan out subagents over a work-list, pipeline multi-stage agent work, adversarially verify findings before trusting them, or turn a repetitive multi-agent task into a reusable saved script. Produces a runnable workflow script (inline or saved under .claude/workflows/<name>.js) plus its launch call. Trigger on 'author a workflow', 'make a workflow', 'new workflow', 'write a workflow', 'orchestrate agents', 'fan out subagents', 'pipeline these agents', 'workflow skill', 'turn this into a workflow'. Do NOT trigger for invoking an existing named workflow (just call the Workflow tool), for a single-agent task (use the Agent tool), or for debugging a workflow run (read its transcript dir).

Pick the right consulting/strategy framework to structure a messy problem. Routes a problem statement through a 5-axis router (purpose, horizon, locus, unit, knowability) over an atlas of ~80 frameworks — McKinsey, BCG, Porter, root-cause, prioritization, systems, change, risk, process, negotiation, and more. YOU GET BACK: the problem's shape reflected in one line, 2-3 candidate frameworks (recommended marked ●, alternatives ○) with one-line fit reasons, a proposed composition when one lens won't carry it (often 2-3 in sequence), and the recommended framework's failure mode flagged for your specific case — then an offer to actually apply it. Fires when the user has a tangled, ambiguous, or open-ended problem and wants structure: 'how should I think about X', 'what framework fits this', 'help me break this down', 'decompose this', 'what would a consultant do here'. Also fires on '/decompose', 'framework?', or naming a framework family ('Porter', 'BCG matrix', 'issue tree', 'Eisenhower'). Most valuable mid-prob

Serve a keyboard-driven data board that lets a human dispose of LLM output outside the console — a Q&A board (multiple-choice over a doc) or a path-board (N candidate paths/plans/options as side-by-side columns, strike losers). Blocks until the human submits, returns their dispositions as JSON. Use instead of AskUserQuestion whenever there are ≥3 items to compare or answer in parallel — an interrogation/convergence loop, comparing candidate plans, sorting options to make a decision. Triggers on "shape-board", "path-board", "serve the board", "board these options/paths", "compare these side by side", "interrogation board".

Panel code review — 18 single-concern reviewer agents (correctness, security, performance, reuse, tests, contracts, style, error-handling, concurrency, data-integrity, observability, dependencies, accessibility, privacy, config-secrets, docs, complexity, scope-creep) fanned out inside a Workflow, every candidate adversarially verified, then deduped into one severity-ranked report. Use for reviewing a diff, branch, or PR when broad or targeted single-concern coverage is wanted. Trigger on 'senior-code-review', 'senior review', 'panel review', 'full review', 'review for security and concurrency', or naming specific reviewer concerns. Do NOT trigger for the built-in /code-review quick pass, for fixing code, or for reviewing prose.