4.6K skills · sorted by relevance
Connect json-render interfaces to XState Store for state management. The skill shows how to adapt an atom, a container holding application state, so json-render reads and writes through it.
Plan Table v9 state ownership across the table, framework state, and external atoms that hold values. Covers initial values, update callbacks, and reset behavior, helping coordinate individual state sections without conflicting owners.
Refactor state held in Redux or React Context by separating API data, URL settings, shared interface state, and local component state. Move each part to React Query, nuqs, Zustand, or React’s local state hooks.
Provider (v6.x) state management for Flutter using ChangeNotifier and InheritedWidget with MVVM architecture pattern. Use this skill when implementing Provider-based state management, using Consumer/Consumer2 widgets for targeted rebuilds, accessing state with context.read/context.watch/context.select, setting up ChangeNotifierProvider or StateNotifierProvider, configuring MultiProvider for multiple providers, implementing ProxyProvider for dependent state, using Selector for optimized rebuilds, migrating from StatefulWidget to reactive state, maintaining legacy Provider codebases, debugging provider not found errors, preventing memory leaks with proper ChangeNotifier disposal, fixing context access issues in initState, or resolving .value constructor anti-patterns. Essential for apps with shared state across widgets (shopping carts, authentication, global settings, form state, theme management), when teaching state management fundamentals, or when debugging memory leaks and resource cleanup in Provider-based applications.
The English summary is being prepared. Showing the original description.
Interface-based state machine patterns for Unity game states, character controllers, and UI flows. Use when implementing game flow (menu -> gameplay -> game over), character states (idle -> run -> jump -> fall), AI behavior states, or UI screen transitions. Triggers on "state machine", "game states", "character states", "screen flow", "game flow", "add states to", "idle/run/jump", "menu flow", "AI states", "boss phases", or any task involving managing discrete states with transitions between them. Reads ProjectConfig.yaml -> architecture_pattern to adapt patterns for SO-first or DI-first.
The English summary is being prepared. Showing the original description.
Implement asynchronous work and changing data streams in Android and Kotlin Multiplatform apps using Kotlin Coroutines and Flow. Apply patterns for parallel loading, UI state updates, cancellation, error handling, and tests that check emitted values.
Complete an existing financial model template by entering historical data and forecast assumptions, then linking the income statement, balance sheet, and cash flow statement with formulas. Check statement balances, cash consistency, and scenario behavior as each section is completed.
Connect TanStack Table v9 state to lit rendering. Manage state such as pagination through reactive properties, choose which changes trigger component updates, and subscribe to selected state so individual template regions can update independently.
Connect json-render to Redux or Redux Toolkit so UI state reads and writes use a Redux store. The skill explains how to select the relevant state and dispatch actions that replace it when updates occur.
Helps connect json-render to a Zustand store, where application values are managed. Covers sharing the entire store or selecting a nested portion, with configurable update behavior for the selected state.
Run work as an explicit event-driven state machine executed by subagents. The orchestrator is the runtime from the canonical loop — `state, effects = init(machine); execute(effects); while state is active: event = nextEvent(); state, effects = transition(machine, state, event); execute(effects); return state.output`. All routing judgment is authored ONCE, at plan time, into a machine file (states, event alphabet, transition table, budgets, final states); at runtime the orchestrator does pure table lookups and dispatches effects — it never decides, never authors, never ingests artifacts. Subagent/sync protocol is the timeboxed-iterating one: role prompts scaffolded once to disk and dispatched BY PATH, an initialiser preamble every subagent reads first, a self-populating cheatsheet, per-unit files, tiny structured returns, independent measurement gate. Use when the user says "workmachine", "run this as a state machine", "state-machine this", or when a goal has a small number of clearly named phases with explicit outcomes (built / passed / failed / blocked) and you want the routing to be auditable rather than judged on the fly. For clock-driven loops use timeboxed-iterating; for wide graphs with judged edge criteria use workgraph.
The English summary is being prepared. Showing the original description.
Use this skill when the user asks how to determine whether a CMV operation is interstate vs intrastate, why it matters (federal vs state rules apply), the "continuation of journey" rule, state-specific intrastate exemptions, and what happens when an intrastate carrier picks up an interstate load. Cite 49 CFR 390.5 + state-specific exemptions.
The English summary is being prepared. Showing the original description.
Plan how an Angular app stores and updates data used by its screens. Covers local and shared state, choices involving Signals, NgRx, and RxJS, synchronization with server data, debugging, and migration from older patterns.
Connect Table v9 state to Alpine bindings and manage pagination from application code. Explains reactive reads, getter and callback setup, shared state atoms, and why some captured values fail to follow later updates.
Read and control TanStack Table v9 state in Vue while keeping updates synchronized with the interface. Covers reactive reads, externally controlled state, update callbacks, shared state containers, and component boundaries for rendering.
Review stored LifeOS goals and personal context against available records such as sleep, app usage, work, and expenses. The skill prioritizes stale information and contradictions, proposes corrections for approval, and reviews the gap between current and ideal states.
Helps connect json-render to a writable Jotai atom, a unit that holds application state. Covers adapter setup and sharing a Jotai store so json-render and React components read and update the same values.
Prepare income statements with prior-period and budget comparisons, highlight significant differences, and explain their drivers. Reference formats for balance sheets and cash flow statements also support financial reporting and period-end adjustments.
Manage TanStack Table v9 state in Octane, including controlled pagination and subscriptions that keep the UI updated. It explains component subscription boundaries, stable external atoms for shared state, and how controlled updates reach the store.
Implement reactive state reads and external control for Table v9 in Solid. Learn where to track changes, how to manage pagination state, and how to handle updater functions or shared state correctly.
Manage Table v9 state in Svelte 5, including pagination controlled by application code. Guides reactive reads that update the interface, getter and callback wiring, and the distinction between tracked values and one-time snapshots.
Manage TanStack Table v9 state in React, including controlled pagination and subscriptions that update the UI when state changes. It also guides narrower rendering boundaries and fixes for React Compiler memoized components.
Read and control Table v9 state in Preact, including pagination. Guides state subscriptions, which keep the interface updated, and externally managed state so table changes and controls stay synchronized while rerenders can be scoped to relevant values.
Create a temporary workbench for one existing component, using realistic mock data and a grouped state switcher. View loading, empty, error, access, and other implemented states individually, with a link to each state.