Quality Code Check

Purpose

Establish consistent code quality standards through automated validation tools, ensuring code reliability, maintainability, and consistency.

---

Core Principle

Code quality validation is a safety gate that catches errors early, prevents tech debt accumulation, and ensures code meets project standards.

---

Quality Check Categories

1. Linting - Code Style & Best Practices

**What linting detects:**

**Language-specific tools:**

**Approach:**

---

2. Type Checking - Type Safety

**What type checking validates:**

**Language-specific tools:**

**Approach:**

---

3. Build Verification - Compilability & Packaging

**What build checking validates:**

**Language-specific tools:**

**Approach:**

---

Tool Invocation

**Note:** Commands are examples. Adjust to your project's package manager, config files, and scripts.

Project Detection

**Use Glob to detect project type:**

Language-Specific Commands

#### JavaScript/TypeScript

```bash

Check package.json scripts first

npm run lint

npx eslint . --max-warnings=0

Type checking

npm run typecheck

npx tsc --noEmit

Build

npm run build

```

#### Python

```bash

Linting

ruff check .

ruff check . --fix # auto-fix

Type checking

mypy .

pyright

Import check

python -c 'import your_package'

```

#### Go

```bash

Linting

golangci-lint run

go vet ./...

Build (includes type checking)

go build ./...

```

#### Rust

```bash

Linting

cargo clippy -- -D warnings

Type checking

cargo check

Build

cargo build

cargo build --release # production

```

#### Java

```bash

Gradle

./gradlew check

./gradlew build

Maven

mvn verify

mvn compile

```

Error Handling

**Tool not found:**

**Check fails:**

---

Validation Workflow

When to Run

Quality Check Sequence

1. **Detect available tools** from project configuration

- Use Glob to find config files

- Identify which tools are available

2. **Run linting** (scoped to changed files when possible)

- Execute appropriate commands

- Fix auto-fixable issues first (--fix flag)

- Manually fix remaining violations

- Target: Meet project's warning standards

3. **Run type checks**

- Execute appropriate commands

- Fix all type errors

- Validate type consistency across modules

- Target: No type errors

4. **Run build** (full build, production config when available)

- Execute appropriate commands

- Ensure all code compiles

- Validate all imports resolve

- Confirm output artifacts generated

- Target: Build succeeds without critical errors

Error Recovery

**If quality checks fail:**

1. **Analyze errors** - Identify root causes

2. **Fix issues** - Make minimal changes to resolve

3. **Re-run checks** - Execute same commands again

4. **Repeat** - Continue until checks pass

**If unable to fix:**

---

Common Mistakes

1. **Ignoring warnings** - Warnings often indicate real problems

→ Fix them or understand why acceptable

2. **Only checking one file** - Changes can break type checking across others

→ Check all modified files and dependencies

3. **Skipping the build step** - Code might lint/type-check but fail to compile

→ Always verify full build

4. **Accepting auto-fixes blindly** - Auto-fixes might hide real issues

→ Review each auto-fix before committing

5. **Not checking package.json scripts** - Projects often define custom commands

→ Check scripts first before running tools directly

6. **Inconsistent standards** - Allowing different levels across features

→ Maintain consistent standards for your project

---

Validation Checklist

Before considering quality checks complete:

---

Key Takeaway

**Systematic quality validation catches issues early and maintains consistency.**

Quality checks are flexible gates that validate code against project standards:

Commands shown are examples - check your project's scripts first. Quality standards should be consistent within your project but may vary between projects.

Systematic checks catch errors early, prevent tech debt accumulation, and build confidence in code readiness.