Many Rust codebases hide failures behind panics or vague errors. This skill reviews patterns and suggests idiomatic Result, thiserror, and anyhow improvements.

Rust error conversions can become repetitive and confusing across application layers. This skill guides Claude, Codex, and Claude Code toward idiomatic From, map_err, anyhow, and thiserror patterns.

Weak domain layers scatter business rules and make validation inconsistent. This skill helps Claude, Codex, and Claude Code design expressive Rust domain models.

Large data lakes can become slow, expensive, and hard to govern without clear architecture choices. This skill guides partitioning, storage layout, schema evolution, table formats, retention, and cost-aware lakehouse design.

Slow DataFusion queries can waste compute and hide simple plan issues. This skill reviews SQL and DataFrame patterns, then suggests concrete performance improvements.

Rust Lambda functions can suffer slow first responses when binaries are large or initialization is heavy. This skill guides Claude, Codex, and Claude Code through concrete optimizations for build settings, dependencies, and deployment.

Rust Lambda handlers often mix I/O and CPU work, which can block runtimes or waste parallelism. This skill guides Claude, Codex, and Claude Code toward clear async, blocking, and Rayon patterns.

Rust async APIs can be hard to design when traits, closures, and dispatch choices interact. This skill gives practical guidance for modern native async patterns and async-trait migration.

Outdated Swift patterns can create concurrency errors, unclear APIs, and avoidable performance costs. This skill provides current Swift 6 guidance for implementation, review, and migration.

Poorly tuned motion makes interfaces feel slow, unstable, or inaccessible. This skill reviews animation code against specific standards and returns prioritized, actionable findings.

Choosing among frontend libraries can waste time and create inconsistent dependencies. This skill maps a defined UI task to an opinionated, curated library recommendation.

Inconsistent motion can make interfaces feel slow, distracting, or inaccessible. This skill audits animation code and produces prioritized findings with detailed implementation plans.

Teams often add motion without a clear user benefit, which can make interfaces feel slow or distracting. This skill audits UI seams, applies a strict decision gate, and produces a short ranked list of precise motion recommendations.

Interfaces often work correctly but still feel slow, inconsistent, or unclear. This skill reviews interaction details and recommends purposeful, accessible, performant motion.

Sonner integrations can fail through duplicate toasters, server-side calls, styling conflicts, or incorrect promise handling. This skill provides focused setup, API, styling, and troubleshooting guidance.

Gesture-driven web interfaces often feel delayed, rigid, or visually inconsistent. This skill provides practical guidance for responsive motion, materials, typography, accessibility, and interaction design.

Vague motion descriptions make design discussions and AI prompts unclear. This skill maps those descriptions to precise terms and explains close alternatives.

Mobile animations often stutter, ignore accessibility, or conflict with gestures. This skill designs Expo motion with suitable tools, timing, threading, and device checks.

Marketplace maintainers must release plugins without mixing versions across a shared repository. This skill guides validation, version updates, tags, pushes, and GitHub releases for one plugin at a time.

Large Markdown projects become hard to navigate when headings change. This skill helps generate, preview, and update tables of contents across files.