Verification Loop

````instructions
---
name: verification-loop
description: Post-change verification workflow ensuring all code changes build, lint, and function correctly before marking tasks complete.
---

# Verification Loop

## When to Activate

- After ANY code change (even a single-line edit)
- Before pushing to any branch
- When fixing build or lint errors
- After refactoring or moving files
- Before marking a task as complete

## The Loop

```
Make Change → Lint → Build → Verify Behavior → Next Task
     ↑                                            |
     └────────── Fix if any step fails ←────────────┘
```

## Steps

### 1. Make the Change
- Edit the minimal set of files needed
- One logical change at a time
- Keep changes small and verifiable

### 2. Check for Errors
```bash
# Check TypeScript / ESLint errors in the editor
# Or run explicitly:
pnpm lint
```
- If errors: fix them and go back to step 2
- Zero errors required

### 3. Build
```bash
pnpm build
```
- If errors: fix them and go back to step 2
- Must compile successfully
- Verify static pages are generated

### 4. Verify Behavior
- For UI changes: mentally verify the component renders correctly
- For data changes: verify the resource appears in the unified index
- For config changes: verify the configuration takes effect

### 5. Mark Complete
- Only mark the task as done after steps 2-4 pass
- Move to next task

## Verification Levels

| Level    | When              | Steps                              |
|----------|-------------------|------------------------------------|
| Quick    | Simple edits      | Lint + check errors in editor      |
| Standard | Feature work      | Lint + Build                       |
| Full     | Before push       | Lint + Build + Manual verify       |

## Anti-Patterns

- Making 5 changes then running lint once
- Ignoring type errors ("it works at runtime")
- Skipping lint ("I'll fix it later")
- Not building before marking a task complete
- Pushing without running the full verification

## Rules

1. **Never mark a task done without verification**
2. **Run the verification loop after every change**
3. **If verification fails 3 times on the same issue, reassess the approach**
4. **Keep changes small so verification is fast**
5. **Don't combine unrelated changes in one verification cycle**

## Checklist

- [ ] Change is minimal and focused
- [ ] `pnpm lint` passes with 0 errors
- [ ] `pnpm build` passes successfully
- [ ] Behavior verified (UI renders, data loads, config applies)
- [ ] Task marked complete only after verification

````