---
name: Completion Check
slug: completion-check
category: Quality
description: Completion Check verifies that infrastructure code is actually connected and invoked before marking work complete. Use it to trace execution paths, confirm hooks and database backends are registered, and run end-to-end tests.
github: "https://github.com/parcadei/Continuous-Claude-v3/tree/main/.claude/skills/completion-check"
language: Python
stars: 3902
forks: 296
install: "npx degit https://github.com/parcadei/Continuous-Claude-v3/tree/main/.claude/skills/completion-check ~/.claude/skills/completion-check"
installs_to: ~/.claude/skills/completion-check
source_path: .claude/skills/completion-check/SKILL.md
collection_size: 25
category_size: 1354
collection_url: "https://dirskills.com/collections/parcadei/Continuous-Claude-v3"
added: 2026-08-16T07:01:45.401Z
last_synced: 2026-08-16T07:01:45.401Z
canonical_url: "https://dirskills.com/skills/completion-check"
---

# Completion Check

Completion Check verifies that infrastructure code is actually connected and invoked before marking work complete. Use it to trace execution paths, confirm hooks and database backends are registered, and run end-to-end tests.

**Install:**

```bash
npx degit https://github.com/parcadei/Continuous-Claude-v3/tree/main/.claude/skills/completion-check ~/.claude/skills/completion-check
```

## README

# Completion Check: Verify Infrastructure Is Wired

When building infrastructure, verify it's actually connected to the system before marking as complete.

## Pattern

Infrastructure is not done when the code is written - it's done when it's wired into the system and actively used. Dead code (built but never called) is wasted effort.

## DO

1. **Trace the execution path** - Follow from user intent to actual code execution:
   ```bash
   # Example: Verify Task tool spawns correctly
   grep -r "claude -p" src/
   grep -r "Task(" src/
   ```

2. **Check hooks are registered**, not just implemented:
   ```bash
   # Hook exists?
   ls -la .claude/hooks/my-hook.sh

   # Hook registered in settings?
   grep "my-hook" .claude/settings.json
   ```

3. **Verify database connections** - Ensure infrastructure uses the right backend:
   ```bash
   # Check connection strings
   grep -r "postgresql://" src/
   grep -r "sqlite:" src/  # Should NOT find if PostgreSQL expected
   ```

4. **Test end-to-end** - Run the feature and verify infrastructure is invoked:
   ```bash
   # Add debug logging
   echo "DEBUG: DAG spawn invoked" >> /tmp/debug.log

   # Trigger feature
   uv run python -m my_feature

   # Verify infrastructure was called
   cat /tmp/debug.log
   ```

5. **Search for orphaned implementations**:
   ```bash
   # Find functions defined but never called
   ast-grep --pattern 'async function $NAME() { $$$ }' | \
     xargs -I {} grep -r "{}" src/
   ```

## DON'T

- Mark infrastructure "complete" without testing execution path
- Assume code is wired just because it exists
- Build parallel systems (Task tool vs claude -p spawn)
- Use wrong backends (SQLite when PostgreSQL is architected)
- Skip end-to-end testing ("it compiles" ≠ "it runs")

## Completion Checklist

Before declaring infrastructure complete:

- [ ] Traced execution path from entry point to infrastructure
- [ ] Verified hooks are registered in .claude/settings.json
- [ ] Confirmed correct database/backend in use
- [ ] Ran end-to-end test showing infrastructure invoked
- [ ] Searched for dead code or parallel implementations
- [ ] Checked configuration files match implementation

## Example: DAG Task Graph

**Wrong approach:**
```
✓ Built BeadsTaskGraph class
✓ Implemented DAG dependencies
✓ Added spawn logic
✗ Never wired - Task tool still runs instead
✗ Used SQLite instead of PostgreSQL
```

**Right approach:**
```
✓ Built BeadsTaskGraph class
✓ Wired into Task tool execution path
✓ Verified claude -p spawn is called
✓ Confirmed PostgreSQL backend in use
✓ Tested: user calls Task() → DAG spawns → beads execute
✓ No parallel implementations found
```

## Source Sessions

- This session: Architecture gap discovery - DAG built but not wired, Task tool runs instead of spawn, SQLite used instead of PostgreSQL