CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

completion-check

Completion Check: Verify Infrastructure Is Wired

Quality

57%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./.claude/skills/completion-check/SKILL.md
SKILL.md
Quality
Evals
Security

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:

    # Example: Verify Task tool spawns correctly
    grep -r "claude -p" src/
    grep -r "Task(" src/
  2. Check hooks are registered, not just implemented:

    # 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:

    # 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:

    # 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:

    # 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
Repository

parcadei/Continuous-Claude-v3

Path

.claude/skills/completion-check/SKILL.md

Last updated
First committed

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.