Dash Discover

Dash Discover (Meta-Skill)

The Meta-Skill Discovery Engine evaluates a Dart or Flutter project's architecture, language idioms, testing patterns, and documentation health to uncover latent modernization opportunities that standard static analysis passes ignore.

1. When to use this skill

Use this skill when:

• Asked questions like: "Am I doing this right?", "Am I holding it right?", or "What skills should I use on this repository?"
• Entering a new or unfamiliar Dart/Flutter repository and determining where to focus modernization effort.
• dart analyze reports clean code (0 errors, 0 warnings), but the codebase may still harbor outdated pre-Dart 3 constructs, legacy matcher assertions, unstructured CLI entrypoints, or rotting doc examples.

When NOT to use (Abstention Guardrails)

Do NOT run or prescribe discovery scans when:

• Non-Dart / Non-Flutter Projects: The repository or directory has no pubspec.yaml or Dart source files (e.g. pure documentation repositories or external language services).
• Targeted Single-File Edits or Bug Fixes: The user is requesting a narrow, isolated bug fix or single-file adjustment. Do not derail the turn into a broad repository-wide architectural audit unless specifically solicited.
• Active In-Flight Breaking Migrations: The repository is midway through a breaking SDK upgrade or uncommitted refactoring. Allow primary migrations to stabilize before running discovery sweeps.

2. Core Mental Model: The Analyzer Blindspot

Static analysis (dart analyze) verifies syntactic and semantic correctness, not architectural quality or modern idiomatic design. A package can pass dart analyze --fatal-infos with zero warnings while simultaneously:

• Using 7-branch polymorphic else if (x is Y) cascades instead of concise Dart 3 switch expressions with pattern destructuring.
• Relying on legacy package:test expect(actual, matcher) calls instead of fluent, type-safe package:checks.
• Storing rotting, unverified code snippets in /// ``` doc comments instead of automated {@example} region testing.
• Building ad-hoc monolithic 300+ line bin/main.dart entrypoints without package:args/command_runner.dart.

Dash Discover systematically identifies these latent gaps and points directly to the specialized skills equipped to remediate them.

3. Two-Tier Discovery Protocol

Tier 1: Fast Static Heuristics (<50ms)

Run the discovery CLI from anywhere in the workspace:

dart run dash_discover <path-to-target-package>

Or for structured machine ingestion:

dart run dash_discover <path-to-target-package> --json

<!-- DISCOVERY_RULES_START -->

The static scanner performs rapid, zero-network checks across 7 built-in rules:

<!-- prettier-ignore -->

1. Testing Architecture (dart-migrate-to-checks-package): Detects test or flutter_test in dependencies when checks is absent.
2. Dart 3 Language Idioms (dart-use-pattern-matching): Detects legacy else if (... is ...) type cascades and returning switch statements.
3. CLI Architecture (dart-build-cli-app): Detects ad-hoc bin/*.dart CLI entrypoints lacking structured argument parsing.
4. Cross-Platform Robustness (dart-use-path-package): Detects manual path string concatenation without package:path.
5. Testing Architecture (dart-generate-test-mocks): Detects handwritten fake or mock class definitions without mockito or mocktail.
6. Testing Architecture (dart-matcher-best-practices): Detects unidiomatic expect() assertions (e.g. expect(x.length, ...) or expect(x.isEmpty, true)).
7. Dart 3 Language Idioms (dart-seal-type-hierarchies): Detects closed type hierarchies that are not sealed, so the compiler cannot check switch exhaustiveness over them.

<!-- DISCOVERY_RULES_END -->