Research and plan a large-scale change, then execute it in parallel across 5-30 isolated worktree agents that each open a PR. Use when the user wants to make a sweeping, mechanical change across many files (migrations, refactors, bulk renames) that can be decomposed into independent parallel units.

Go-style error handling for TypeScript. Functions return errors instead of throwing them — but instead of Go's two-value tuple (`val, err`), you return a single `Error | T` union. Instead of checking `err != nil`, you check `instanceof Error`. TypeScript narrows the type automatically. No wrapper

Event-sourced application state pattern for TypeScript apps. Prefer bounded event logs plus pure derivation functions over mirrored mutable lifecycle flags. Use when state transitions are driven by events and bugs can be reproduced from a saved event stream.

Zero-dependency, type-safe CLI framework for TypeScript. A CAC replacement with Standard Schema support.

Control Jitter (jitter.video) for exporting animations, replacing assets, and modifying text programmatically via Playwriter.

Create a new custom skill (SKILL.md) interactively by analyzing the current session's repeatable process. Conducts a multi-round interview to capture the user's workflow, then generates a structured SKILL.md file. Use when the user wants to turn a session into a reusable skill or automation.

Use this skill when scaffolding or fixing npm packages.

Build TUIs with a Raycast-like React API using termcast. Implements @raycast/api components (List, Detail, Form, Action) rendered to the terminal via opentui.

Centralized state management pattern using Zustand vanilla stores. One immutable state atom, functional transitions via setState(), and a single subscribe() for all reactive side effects. Based on Rich Hickey's "Simple Made Easy" principles: prefer values over mutable state, derive instead of cache, centralize transitions, and push side effects to the edges. Resource co-location in the same store is also valid when lifecycle management is safer that way. Also covers state encapsulation: keeping state local to its owner (closures, plugins, factory functions) so it doesn't leak across the app, reducing the blast radius of mutations. Also covers event sourcing: keeping a bounded event buffer and deriving state with pure functions instead of mutable flags, making event handlers easy to test and reason about. Use this skill when building any stateful TypeScript application (servers, extensions, CLIs, relays) to keep state simple, testable, and easy to reason about. ALWAYS read this skill when a project uses zustand/vanilla for state management outside of React.