verification-stack

# Verification Stack

Verification-driven development uses automated checks as gates instead of manual approval. This skill teaches the verification pipeline that enables autonomous development.

## Core Principle

**Asymmetry of Verification**: Many tasks are easier to verify than to solve. Software development is highly verifiable through:

- Tests (unit, integration, e2e)
- Linters and formatters
- Type checkers
- Build systems
- Security scanners

## The Verification Pipeline

Run checks in this order (fast-fail):

```bash
# 1. Format (auto-fix)
uv run ruff format .

# 2. Lint (auto-fix where possible)
uv run ruff check . --fix

# 3. Type check
uv run mypy src/

# 4. Tests (fast subset first)
uv run pytest tests/ -x --tb=short

# 5. Full test suite
uv run pytest tests/ --cov=src/

# 6. Security (optional)
uv run bandit -r src/ --severity-level high
```

## One-Command Verification

Create a verification script for the project:

```bash
#!/bin/bash
# scripts/verify.sh
set -e

echo "=== Formatting ==="
uv run ruff format .

echo "=== Linting ==="
uv run ruff check . --fix

echo "=== Type Checking ==="
uv run mypy src/

echo "=== Tests ==="
uv run pytest tests/ -x --tb=short

echo "=== All checks passed ==="
```

Run with: `bash scripts/verify.sh`

## Language-Specific Stacks

### Python (uv + ruff + mypy + pytest)

```bash
uv run ruff format .
uv run ruff check . --fix
uv run mypy src/
uv run pytest tests/ -x
```

### TypeScript (pnpm + eslint + tsc + vitest)

```bash
pnpm format
pnpm lint --fix
pnpm typecheck
pnpm test
```

### Go

```bash
go fmt ./...
golangci-lint run --fix
go build ./...
go test ./...
```

## Verification as Gate

The key insight: **verification replaces permission prompts**.

Instead of:
```
Claude: "Can I proceed with implementing this feature?"
Human: "Yes"
```

Use:
```
Claude: [implements feature]
Claude: [runs verification]
Verification: PASS → proceed
Verification: FAIL → fix and retry
```

## Handling Failures

When verification fails: