---

name: code-check description: Validate and lint code after changes. Use after editing Rust/TypeScript files, when user mentions compilation errors, type checking, linting, clippy warnings, or before commits/PRs. Ensures all code passes checks and has zero warnings.

Code Checking Skill

This skill provides code validation and linting operations for the project codebase.

When to Use This Skill

Use this skill when you need to:

• Validate Rust or TypeScript code after making changes
• Run compiler checks without building
• Lint code with clippy
• Ensure code quality before commits or PRs

Command Selection Rules

Choose the appropriate command based on the number of crates edited:

Decision process:

1. Identify which crates contain your edited files
2. If 2 or fewer crates: use per-crate commands for each crate
3. If 3 or more crates: use global commands

Available Commands

Check Rust Code

Copyjust check-rs [EXTRA_FLAGS]

Checks Rust code using cargo check --all-targets. This runs the compiler without producing binaries.

Alias: just check (same as check-rs)

Examples:

• just check-rs - check all Rust code
• just check-rs --release - check with release optimizations

Check Specific Crate

Copyjust check-crate <CRATE> [EXTRA_FLAGS]

Checks a specific crate with all its targets using cargo check --package <CRATE> --all-targets.

Examples:

• just check-crate metadata-db - check the metadata-db crate
• just check-crate common --release - check common crate with release mode

Lint Rust Code (Clippy)

Copyjust clippy [EXTRA_FLAGS]

Lints all Rust code using cargo clippy --all-targets. Clippy catches common mistakes and suggests improvements.

Examples:

• just clippy - lint all code
• just clippy -- -D warnings - treat warnings as errors

Lint Specific Crate

Copyjust clippy-crate <CRATE> [EXTRA_FLAGS]

Lints a specific crate using cargo clippy --package <CRATE> --all-targets --no-deps.

The --no-deps flag ensures clippy only analyzes the specified crate's code, not its dependencies. This provides:

• Faster execution: Skip checking dependency code you don't control
• Focused output: See only warnings from your crate, not transitive dependencies
• Actionable results: All warnings shown are in code you can fix

Examples:

• just clippy-crate admin-api - lint the admin-api crate only
• just clippy-crate dataset-store -- -D warnings - lint with warnings as errors

Check All Code

Copyjust check-all

Checks both Rust and TypeScript code by running check-rs and check-ts sequentially.

Check TypeScript Code

Copyjust check-ts

Checks TypeScript code using pnpm check.

Important Guidelines

MANDATORY: Run Checks After Changes

You MUST run checks after making code changes. Use the Command Selection Rules above to choose the right command.

Before considering a task complete: all checks MUST pass AND all clippy warnings MUST be fixed.

Example Workflows

Single crate (1-2 crates edited):

1. Edit files in metadata-db crate
2. Format: use /code-format skill
3. Check compilation: just check-crate metadata-db
   • If errors → fix → return to step 2
4. Check clippy: just clippy-crate metadata-db
   • If warnings → fix ALL → return to step 2
5. Repeat until: zero compilation errors AND zero clippy warnings

Multiple crates (3+ crates edited):

1. Edit files across multiple crates
2. Format: use /code-format skill
3. Check compilation: just check-rs
   • If errors → fix → return to step 2
4. Check clippy: just clippy
   • If warnings → fix ALL → return to step 2
5. Repeat until: zero compilation errors AND zero clippy warnings

Common Mistakes to Avoid

❌ Anti-patterns

• Never run cargo check directly - Use just check-crate or just check-rs
• Never run cargo clippy directly - Justfile adds proper flags like --no-deps
• Never ignore clippy warnings - Clippy is enforced in CI, warnings will fail builds
• Never skip the check step - Even if "it should compile"
• Never use global commands for 1-2 crates - Use per-crate commands for efficiency
• Never use per-crate commands for 3+ crates - Use global commands for efficiency

✅ Best Practices

• Follow Command Selection Rules based on number of crates edited
• Use per-crate commands for 1-2 crates (faster, focused feedback)
• Use global commands for 3+ crates (more efficient)
• Fix compilation errors before running clippy
• Run clippy after EVERY code change
• Document any warnings you absolutely cannot fix (rare exception)

Pre-approved Commands

These commands can run without user permission:

• just check-rs - Safe, read-only compilation check
• just check-crate <crate> - Safe, read-only compilation check
• just clippy - Safe, read-only linting
• just clippy-crate <crate> - Safe, read-only linting

Next Steps

After all checks pass:

1. Run tests → See .claude/skills/code-test/SKILL.md
2. Generate schemas if needed → See .claude/skills/code-gen/SKILL.md
3. Commit changes → Ensure all checks green first