code-lint

When to Use This Skill

Use this skill when...	Use something else instead when...
Auto-detecting and running the correct linter for a polyglot repo	Detecting structural anti-patterns linters miss → `code-antipatterns`
Running ruff/eslint/clippy/gofmt with optional `--fix` and `--format`	Reviewing broader code quality and architecture → `code-review`
Driving a one-shot lint pass before commit	Scanning specifically for swallowed errors → `code-hidden-failures --track errors`
Looking up autofix commands or common fix patterns per language	(use this skill — autofix reference is now here)

Context

Package files: !find . -maxdepth 1 $ -name "package.json" -o -name "pyproject.toml" -o -name "setup.py" -o -name "Cargo.toml" -o -name "go.mod" $ -type f
Pre-commit config: !find . -maxdepth 1 -name ".pre-commit-config.yaml" -type f

Parameters

$1: Path to lint (defaults to current directory)
$2: --fix flag to automatically fix issues
$3: --format flag to also run formatters

Linting Execution

Python

{{ if PROJECT_TYPE == "python" }} Run Python linters:

Ruff check: uv run ruff check ${1:-.} --output-format=concise ${2:+--fix}
Type checking: uv run ty check ${1:-.} --hide-progress
Format check: uv run ruff format ${1:-.} ${3:+--check}
Security: uv run bandit -r ${1:-.} {{ endif }}

JavaScript/TypeScript

{{ if PROJECT_TYPE == "node" }} Run JavaScript/TypeScript linters:

ESLint: npm run lint ${1:-.} ${2:+-- --fix}
Prettier: npx prettier ${3:+--write} ${3:---check} ${1:-.}
TypeScript: npx tsc --noEmit {{ endif }}

Rust

{{ if PROJECT_TYPE == "rust" }} Run Rust linters:

Clippy: cargo clippy --message-format=short -- -D warnings
Format: cargo fmt ${3:+} ${3:--- --check}
Check: cargo check {{ endif }}

Go

{{ if PROJECT_TYPE == "go" }} Run Go linters:

Go fmt: gofmt ${3:+-w} ${3:+-l} ${1:-.}
Go vet: go vet ./...
Staticcheck: staticcheck ./... (if available) {{ endif }}

Pre-commit Integration

If pre-commit is configured:

pre-commit run --all-files ${2:+--show-diff-on-failure}

Multi-Language Projects

For projects with multiple languages:

Detect all language files
Run appropriate linters for each language
Aggregate results

Fallback Strategy

If no specific linters found:

Check for Makefile: make lint
Check for npm scripts: npm run lint
Suggest installing appropriate linters via /deps:install --dev
Suggest configuring project linting standards via /configure:linting

Auto-fixing

Autofix Command Reference

Language	Linter	Autofix Command
TypeScript/JS	biome	`npx @biomejs/biome check --write .`
TypeScript/JS	biome format	`npx @biomejs/biome format --write .`
Python	ruff	`ruff check --fix .`
Python	ruff format	`ruff format .`
Rust	clippy	`cargo clippy --fix --allow-dirty`
Rust	rustfmt	`cargo fmt`
Go	gofmt	`gofmt -w .`
Go	go mod	`go mod tidy`
Shell	shellcheck	No autofix (manual only)

Detect-and-Fix Script

Auto-detect project linters and run all appropriate fixers in one command:

bash "${CLAUDE_PLUGIN_ROOT}/skills/code-lint/scripts/detect-and-fix.sh"
bash "${CLAUDE_PLUGIN_ROOT}/skills/code-lint/scripts/detect-and-fix.sh" --check-only

Detects biome, eslint, prettier, ruff, black, clippy, rustfmt, gofmt, golangci-lint, shellcheck. Reports which linters were found and shows modified files.

Common Fix Patterns

JavaScript/TypeScript (Biome): unused imports, prefer-const (let x = 5 → const x = 5).

Python (Ruff): import sorting (I001), unused imports (F401), long lines auto-wrapped.

Rust (Clippy): redundant clone, match → if let for single-arm patterns.

Shell (ShellCheck — manual fixes): quote variables ($var → "$var"), use $() instead of backticks.

When to Escalate from Autofix

Stop autofix and use a different approach when:

Fix requires understanding business logic
Multiple files need coordinated changes
Warning indicates a potential bug (not just style)
Security-related linter rule
Type error requires interface/API changes

Post-lint Actions

After linting:

Summary of issues found/fixed
If unfixable issues exist, suggest /code:refactor command
If all clean, ready for /git:smartcommit