Flutter

Reviews your Dart code for style, idiom, and language-feature use. Flags non-idiomatic patterns and suggests rewrites that match Dart conventions.

Maps your app's features into a layered architecture (UI, Logic, Data) with file structure, dependency patterns, and state management wired correctly from the start.

Configures MaterialApp.router with go_router to handle URL-based navigation, deep links, and browser back buttons—essential for web apps and cross-platform releases.

Wires up GET, POST, PUT, and DELETE requests to a REST API using the standard `http` package, with error handling and response parsing included.

Runs dart doc validation to find unresolved references and broken macros in your documentation comments before they ship with the package.

Edits a memo, doc, or analysis for clarity and flow without over-softening the voice. Catches the jargon, passive voice, and unclear transitions that slow readers down.

Injects previews.dart scaffolding into your component so you can see it render in isolation, tweak props, and catch bugs before pushing to main.

Step-by-step guide to writing and registering a new validation rule in the dart_skills_lint CLI tool, with code patterns and test scaffolding included.

Shows the most readable way to write test expectations in Dart, when to use matchers vs. plain assertions, and the gotchas that slow down test debugging.

Walks through versioning conventions, changelog hygiene, and the publish-to-pub.dev workflow. Includes a checklist for PRs that touch public APIs.

Runs a repo-specific checklist on Dart and markdown files—linting, formatting, tests, docs—before you commit or open a PR. Stops silent mistakes.

Converts a feature request or bug report into a suite of test cases that define the expected behavior, catching edge cases before implementation starts.

A broken example SKILL.md that demonstrates each validation rule's error message. Reference it when writing your own skills to understand what Claude expects.

Scans a Dart codebase and rewrites all `expect()` calls and matcher assertions to their `package:checks` equivalents, preserving assertion logic and readability.

Walks you through installing dart_skills_lint, configuring validation tests, and resolving dependency drift so your SKILL.md files stay valid.

A reference SKILL.md that passes all linting rules: correct naming, description length, and frontmatter structure. Copy the format when authoring your own.

Reads your error message (RenderFlex overflow, unbounded height, etc.), traces the widget tree, and rewrites the layout with constraints that actually work.

Walks through exit codes, argument parsing, and package choices so a Dart CLI doesn't feel like a hastily-written script. Includes patterns for common failure modes.

Scans Dart code for lines over 80 characters and refactors them into readable chunks—breaking function calls, string literals, and conditionals while preserving intent.

Adds the required packages, enables code generation, and configures your localization file so your app can serve multiple languages from a single codebase.

Generates a WidgetTester test that validates a Flutter widget renders data correctly and handles user interactions like taps and text input without manual boilerplate.

Takes a Flutter design and applies responsive patterns—LayoutBuilder, MediaQuery, Expanded/Flexible—so it looks polished on phone, tablet, and desktop without three separate layouts.

Reads a JSON schema or API response and generates Dart model classes with fromJson and toJson constructors, ready to paste into your project.

Reads a pull request or code diff and delivers structured feedback on logic, style, and risk. Iterates through multiple angles—correctness, readability, performance—so you catch edge cases before merge.

Reference guide for records, pattern matching, switch expressions, and extension types in Dart 3.0+. Shows idiomatic ways to cut boilerplate and improve readability.

Covers test groups, lifecycle hooks, and configuration for the Dart `package:test` framework. Includes setup/teardown patterns and dart_test.yaml conventions.

Asks sharp follow-up questions about your design or strategy, pushes back on weak points, and keeps drilling until both of you agree on what you're actually building and why.

Adds the linter as a dev dependency, writes the config file, and runs a baseline so your Dart project can validate skills without breaking existing code.

Records your taps and swipes through a Flutter app, then generates integration_test code that runs the same flow automatically. No need to write test syntax by hand.

Runs coverage on your Dart package, maps the results to source files, and pinpoints which functions and branches are missing tests—with suggestions on what to write.

Runs dart_skills_lint against a skill file, catches structural violations (bad frontmatter, missing fields, malformed triggers), and generates fix suggestions.

Challenges your proposal against your codebase's domain model and documented decisions, then updates CONTEXT.md and ADRs inline as gaps and contradictions surface.