Claude Skill

dart-best-practices

General best practices for Dart development. Covers code style, effective Dart, and language features.

LLM Mart · 0 points · 1 views 5 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download kevmoo-dash_skills-skills_dart-best-practices-38dce74.zip · 2 KB
Part of kevmoo/dash_skills — 12 skills

Install

skills CLI npx skills add https://github.com/kevmoo/dash_skills/tree/main/skills/dart-best-practices
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install kevmoo-dash-skills@llmmart
Git git clone https://github.com/kevmoo/dash_skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole kevmoo/dash_skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Dart Best Practices

1. When to use this skill

Use this skill when:

  • Writing or reviewing Dart code.
  • Looking for guidance on idiomatic Dart usage.

When NOT to use (Abstention Guardrails)

Do NOT apply this skill or refactor code when:

  • Public API Breaking Changes: Refactoring would alter public API contracts, return types, or parameter signatures in published packages without a coordinated major SemVer bump.
  • Dogmatic Micro-Optimizations: Rewriting clear, readable code for negligible theoretical gains (e.g. replacing clear string concatenation in a simple one-line log message with multiline quotes).
  • Domain-Specific or Code-Generated Files: Generated files (*.g.dart, *.freezed.dart, protobufs) or files where line lengths and string layouts are managed by code generators.
  • Explicit Type Annotations in Public Interfaces: Replacing explicit type annotations with var or final where explicit types document the public API surface or disambiguate complex generics.

2. Best Practices

Multi-line Strings

Prefer using multi-line strings (''') over concatenating strings with + and \n, especially for large blocks of text like SQL queries, HTML, or PEM-encoded keys. This improves readability and avoids lines_longer_than_80_chars lint errors by allowing natural line breaks.

Avoid:

final pem = '-----BEGIN RSA PRIVATE KEY-----\n' +
    base64Encode(fullBytes) +
    '\n-----END RSA PRIVATE KEY-----';

Prefer:

final pem = '''
-----BEGIN RSA PRIVATE KEY-----
${base64Encode(fullBytes)}
-----END RSA PRIVATE KEY-----''';

Line Length

Avoid lines longer than 80 characters, even in Markdown files and comments. This ensures code is readable in split-screen views and on smaller screens without horizontal scrolling.

Prefer: Target 80 characters for wrapping text. Exceptions are allowed for long URLs or identifiers that cannot be broken.

Discovery

Multi-line Strings

To find candidates for multi-line strings, search for string concatenation with + involving newlines:

  • Regex: ['"]\s*\+\s*['"]
  • Regex: \+\s*['"].*\\n

Line Length

  • Rely on the lines_longer_than_80_chars lint from the analyzer.

Related Skills

  • dart-modern-features: For idiomatic usage of modern Dart features like Pattern Matching (useful for deep JSON extraction), Records, and Switch Expressions.
Files (dash_skills)
  • evals
    • evals.json 2.1 KB
      {
        "repo_criteria": [
          "evals/code_quality_rubric.json"
        ],
        "evals": [
          {
            "id": 1,
            "prompt": "Refactor the string concatenation in lib/src/database_helper.dart which constructs a multiline SQL schema using '+' and '\\n' into an idiomatic multi-line string literal.",
            "expected_chat_output": [
              "Any natural language output summarizing the completed work is acceptable."
            ],
            "expected_repo_state": [
              "String concatenations with '+' and embedded '\\n' are replaced with triple-quoted multi-line string literals (''' or \"\"\").",
              "The refactored file compiles with zero errors and passes static analysis ('dart analyze --fatal-infos')."
            ],
            "agent_config": "bare-agent"
          },
          {
            "id": 2,
            "prompt": "Review lib/src/config.dart where several long comments and string literals exceed 80 characters, and refactor them to adhere to the 80-column guideline.",
            "expected_chat_output": [
              "Any natural language output summarizing the completed work is acceptable."
            ],
            "expected_repo_state": [
              "Long code comments and doc comments are wrapped at word boundaries within 80 columns.",
              "The refactored file compiles with zero errors and passes static analysis ('dart analyze --fatal-infos')."
            ],
            "agent_config": "bare-agent"
          },
          {
            "id": 3,
            "prompt": "Review the public API surface in lib/api.dart. Replace explicit type annotations on public class members (like final Map<String, List<int>> cache = ...) with var or final without explicit types to make the code more concise.",
            "expected_chat_output": [
              "The agent must explicitly decline or abstain from removing explicit type annotations on public API members, citing best practices that explicit types document public interfaces."
            ],
            "expected_repo_state": [
              "No modifications are made to lib/api.dart.",
              "Explicit type annotations on public class members and method signatures are preserved.",
              "The file compiles with zero errors and passes static analysis ('dart analyze --fatal-infos')."
            ],
            "agent_config": "bare-agent"
          }
        ]
      }
      
  • SKILL.md 2.8 KB
    ---
    name: dart-best-practices
    description: |-
      General best practices for Dart development.
      Covers code style, effective Dart, and language features.
    license: Apache-2.0
    key_features:
      - Code style guidelines
      - Effective Dart idioms
      - Language feature recommendations
    ---
    
    # Dart Best Practices
    
    ## 1. When to use this skill
    
    Use this skill when:
    
    - Writing or reviewing Dart code.
    - Looking for guidance on idiomatic Dart usage.
    
    ### When NOT to use (Abstention Guardrails)
    
    Do NOT apply this skill or refactor code when:
    
    - **Public API Breaking Changes**: Refactoring would alter public API contracts,
      return types, or parameter signatures in published packages without a
      coordinated major SemVer bump.
    - **Dogmatic Micro-Optimizations**: Rewriting clear, readable code for
      negligible theoretical gains (e.g. replacing clear string concatenation in a
      simple one-line log message with multiline quotes).
    - **Domain-Specific or Code-Generated Files**: Generated files (`*.g.dart`,
      `*.freezed.dart`, protobufs) or files where line lengths and string layouts
      are managed by code generators.
    - **Explicit Type Annotations in Public Interfaces**: Replacing explicit type
      annotations with `var` or `final` where explicit types document the public API
      surface or disambiguate complex generics.
    
    ## 2. Best Practices
    
    ### Multi-line Strings
    
    Prefer using multi-line strings (`'''`) over concatenating strings with `+` and
    `\n`, especially for large blocks of text like SQL queries, HTML, or PEM-encoded
    keys. This improves readability and avoids `lines_longer_than_80_chars` lint
    errors by allowing natural line breaks.
    
    **Avoid:**
    
    ```dart
    final pem = '-----BEGIN RSA PRIVATE KEY-----\n' +
        base64Encode(fullBytes) +
        '\n-----END RSA PRIVATE KEY-----';
    ```
    
    **Prefer:**
    
    ```dart
    final pem = '''
    -----BEGIN RSA PRIVATE KEY-----
    ${base64Encode(fullBytes)}
    -----END RSA PRIVATE KEY-----''';
    ```
    
    ### Line Length
    
    Avoid lines longer than 80 characters, even in Markdown files and comments. This
    ensures code is readable in split-screen views and on smaller screens without
    horizontal scrolling.
    
    **Prefer:** Target 80 characters for wrapping text. Exceptions are allowed for
    long URLs or identifiers that cannot be broken.
    
    ## Discovery
    
    ### Multi-line Strings
    
    To find candidates for multi-line strings, search for string concatenation with
    `+` involving newlines:
    
    - **Regex**: `['"]\s*\+\s*['"]`
    - **Regex**: `\+\s*['"].*\\n`
    
    ### Line Length
    
    - Rely on the `lines_longer_than_80_chars` lint from the analyzer.
    
    ## Related Skills
    
    - **[dart-modern-features]**: For idiomatic usage of modern Dart features like
      Pattern Matching (useful for deep JSON extraction), Records, and Switch
      Expressions.
    
    [dart-modern-features]:
      https://github.com/kevmoo/dash_skills/blob/main/skills/dart-modern-features/SKILL.md
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related