flow

Validates animation durations, enforces typography scale, checks component accessibility, and prevents layout anti-patterns in Tailwind CSS projects. Use when building UI components, reviewing CSS utilities, or enforcing design consistency.

Making changes to the app's functionality.

Create Criterion benchmarks with proper group macros and configuration. Use when writing benchmarks, creating benchmark groups, using criterion_group! and criterion_main! macros, setting throughput, or benchmarking multiple implementations. Handles benchmark groups, throughput metrics, conditional compilation, and proper black_box usage.

Read and parse GitHub issues; extract title, body, labels, checklists, and acceptance criteria to support triage and delegation.

Apply cognitive and perception-based UI principles from Laws of UX. Use when evaluating layout, interaction design, target size and distance, choice count, information grouping, memory load, or response time. Cites specific laws (e.g. Fitts's Law, Hick's Law) to justify design decisions or suggest improvements.

Work with async/await, futures, and asynchronous Rust code. Use when writing async functions, working with tokio or async-std, understanding futures, or implementing async traits. Handles async/await syntax, futures, executors, pinning, Send/Sync bounds, and async patterns.

Use std::hint::black_box correctly in benchmarks and tests. Use when writing benchmarks, preventing compiler optimizations, or ensuring code actually executes. Handles proper placement, when to use it, and common patterns for benchmarking.

Work with Cargo commands, workspace configuration, dependency management, and build systems. Use when managing dependencies, configuring workspaces, building projects, running tests, or publishing crates. Handles Cargo.toml configuration, workspace setup, dependency resolution, and build commands.

Use Clippy lints effectively, understand common warnings, and apply appropriate fixes. Use when running clippy, fixing lint warnings, understanding when to allow/deny lints, or improving code quality. Handles common lints, performance suggestions, style improvements, and lint configuration.

Read and understand Rust crate documentation from crates.io or local crates. Use when needing to understand how to use a crate, find API documentation, check version compatibility, or understand crate features. Handles cargo doc, docs.rs, local documentation, and dependency information.

Write Rust documentation comments following project conventions. Use when writing doc comments, documenting functions, structs, modules, or creating crate-level documentation. Handles /// for items, //! for crate/module docs, markdown formatting, code examples, and panic/safety sections.

Handle Rust errors using Result types, thiserror, and error propagation. Use when writing functions that can fail, creating error types, propagating errors with ?, or using custom Result aliases. Handles thiserror derive macros, error conversion, and proper error context.

Work with Cargo features and conditional compilation. Use when adding optional dependencies, using #[cfg(feature = "...")], conditional compilation, or organizing optional functionality. Handles feature flags, optional dependencies, and cfg attributes.

Work with Foreign Function Interface (FFI) in Rust, including C interop, binding generation, and safety in FFI. Use when interfacing with C libraries, creating Rust bindings, calling C functions, or ensuring FFI safety. Handles extern blocks, C types, binding generation, and FFI best practices.

Use Rust iterators effectively, understand iterator adaptors, and write efficient iterator chains. Use when working with collections, transforming data, filtering, mapping, or collecting results. Handles iterator adaptors, lazy evaluation, collecting strategies, and performance considerations.

Understand and work with Rust lifetimes, lifetime annotations, and lifetime elision. Use when fixing lifetime errors, understanding borrowing rules, working with references, or implementing traits with lifetime parameters. Handles explicit lifetimes, lifetime elision, higher-ranked trait bounds, and common lifetime patterns.

Write and understand Rust macros, including declarative macros (macro_rules!) and procedural macros. Use when writing macros, understanding macro expansion, creating derive macros, or working with macro hygiene. Handles macro_rules!, procedural macros, derive macros, and macro best practices.

Optimize Rust code for performance, understand profiling, memory layout, and zero-cost abstractions. Use when optimizing code, profiling performance, understanding memory usage, or implementing performance-critical code. Handles profiling techniques, memory optimization, SIMD usage, and performance best practices.

Use rand crate correctly for generating random numbers. Use when creating random data, using Rng::gen_range, seeding RNGs, or generating test data. Handles proper range syntax, seeding with SeedableRng, choosing appropriate RNG types, and generating random values for different types.

Perform pull requests, merge branches, and Rust crate releases using cargo-smart-release. Use when releasing crates, creating PRs for release branches, merging release branches, or when the user asks for release workflow, dry-run release, changelog updates, or crate publishing.

Write Rust tests following project conventions. Use when writing unit tests, integration tests, test modules, or test helpers. Handles test organization, Result-based tests, test fixtures, and common testing patterns.

Work with unsafe Rust code safely, understand safety invariants, and review unsafe blocks. Use when writing unsafe code, reviewing unsafe blocks, understanding safety requirements, or working with FFI. Handles unsafe blocks, safety invariants, unsafe traits, and best practices for unsafe code.

Use proper semantic HTML elements per MDN so structure reflects meaning for accessibility, SEO, and maintainability. Use when writing or reviewing HTML, Svelte, or other template markup.

Install shadcn-svelte UI components via CLI. Use when adding a new shadcn-svelte component (e.g. switch, label, checkbox) or when the user asks to add a component from shadcn-svelte.

Choose the right subagent for a task and write a clear delegation prompt including issue context and success criteria.

Evaluate and improve interfaces using usability heuristics from Stanford, Nielsen, Visily, and Shopify. Use when reviewing screens or flows, improving UX, auditing an app, or ensuring user control, clarity, consistency, feedback, error handling, forgiveness, and accessibility.

Applies visual hierarchy, readability, and UI color best practices for aesthetically pleasing interfaces. Use when reviewing or designing UI for layout, typography, color, contrast, grouping, and scannability; complements usability-heuristics and baseline-ui for full UI/UX review.