wiring — Claude Code skill: verify that code actually runs
The wiring skill ensures infrastructure components are actually invoked, not left as dead code. It teaches how to verify entry points, trace call paths, test integration end-to-end, and detect orphaned modules.
MIT ★ 3,951 updated 2026-01-26
npx skills add parcadei/Continuous-Claude-v3 --skill wiring -a claude-codeWhat wiring does
When building infrastructure, it's easy to write logic that never executes. The wiring skill outlines a method to prevent dead code: identify the entry point (hook, skill, or CLI), trace the call chain from entry to module execution, run an integration test, and confirm every component is reachable.
The source includes diagnostic steps: grep .claude/settings.json to find unregistered hooks, verify that scripts are executable, test imports manually, and check that routers actually use the maps you built. Four common wiring gaps are documented—unregistered hooks, non-executable scripts, broken import paths, and routers that don't dispatch—along with fixes for each.
The examples show real cases where hundreds of lines of orchestration logic sat unused because no hook called it. Tools like grep and sys.path.insert require Python in your environment, but the patterns and checklist apply to any project with hooks, skills, or layered routing.
What it helps with
- find code that was written but never invoked
- verify that a hook is registered and passes control to the right script
- trace the full call path from user action to module execution
- confirm that imports and file paths resolve correctly during integration
- test the complete invocation chain instead of isolated unit tests
Example prompts for the agent
- Help me diagnose why my PreToolUse hook isn't firing
- Check whether my new orchestration module is actually called or if it's dead code
- Walk me through how to verify the call path from user action to dispatch works
How to install wiring
1Skills CLI (Vercel)
npx skills add parcadei/Continuous-Claude-v3 --skill wiring -a claude-code2Manually: put the files in place
~/.claude/skills/wiring/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/wiring/
1Skills CLI (Vercel)
npx skills add parcadei/Continuous-Claude-v3 --skill wiring -a codex2Manually: put the files in place
.agents/skills/wiring/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add parcadei/Continuous-Claude-v3 --skill wiring -a cursor2Manually: put the files in place
.cursor/skills/wiring/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install parcadei/Continuous-Claude-v3 .claude/skills/wiring2Manually: put the files in place
.github/skills/wiring/SKILL.md1Skills CLI (Vercel)
npx skills add parcadei/Continuous-Claude-v3 --skill wiring -a gemini-cli2Platform CLI
gemini skills install https://github.com/parcadei/Continuous-Claude-v3 --path .claude/skills/wiringManually: put the files in place
.devin/skills/wiring/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about wiring
How do I install wiring in Claude Code?
Run npx skills add parcadei/Continuous-Claude-v3 --skill wiring -a claude-code, then open ~/.claude/skills/wiring/SKILL.md.
What does the wiring skill do?
It teaches how to verify that infrastructure code is actually invoked rather than left unused. It provides a method, checklist, and diagnostic examples for finding breaks in the call chain.
What tools do I need to run the diagnostics?
The skill uses common commands like grep, ls, and chmod, plus Python for import checks. All examples work in a standard development environment.
Source text
SKILL.md · MIT
---
name: wiring
description: Wiring Verification
user-invocable: false
---
# Wiring Verification
When building infrastructure components, ensure they're actually invoked in the execution path.
## Pattern
Every module needs a clear entry point. Dead code is worse than no code - it creates maintenance burden and false confidence.
## The Four-Step Wiring Check
Before marking infrastructure "done", verify:
1. **Entry Point Exists**: How does user action trigger this code?
2. **Call Graph Traced**: Can you follow the path from entry to execution?
3. **Integration Tested**: Does an end-to-end test exercise this path?
4. **No Dead Code**: Is every built component actually reachable?
## DO
### Verify Entry Points
```bash
# Hook registered?
grep -r "orchestration" .claude/settings.json
# Skill activated?
grep -r "skill-name" .claude/skill-rules.json
# Script executable?
ls -la scripts/orchestrate.py
# Module imported?
grep -r "from orchestration_layer import" .
```
### Trace Call Graphs
```python
# Entry point (hook)
.claude/hooks/pre-tool-use.sh
↓
# Shell wrapper calls TypeScript
npx tsx pre-tool-use.ts
↓
# TypeScript calls Python script
spawn('scripts/orchestrate.py')
↓
# Script imports module
from orchestration_layer import dispatch
↓
# Module executes
dispatch(agent_type, task)
```
### Test End-to-End
```bash
# Don't just unit test the module
pytest tests/unit/orchestration_layer_test.py # NOT ENOUGH
# Test the full invocation path
echo '{"tool": "Task"}' | .claude/hooks/pre-tool-use.sh # VERIFY THIS WORKS
```
### Document Wiring
```markdown
## Wiring
- **Entry Point**: PreToolUse hook on Task tool
- **Registration**: `.claude/settings.json` line 45
- **Call Path**: hook → pre-tool-use.ts → scripts/orchestrate.py → orchestration_layer.py
- **Test**: `tests/integration/task_orchestration_test.py`
```
## DON'T
### Build Without Wiring
```python
# BAD: Created orchestration_layer.py with 500 lines
# But nothing imports it or calls it
# Result: Dead code, wasted effort
# GOOD: Start with minimal wiring, then expand
# 1. Create hook (10 lines)
# 2. Test hook fires
# 3. Add script (20 lines)
# 4. Test script executes
# 5. Add module logic (iterate)
```
### Create Parallel Routing
```python
# BAD: Agent router has dispatch logic
# AND skill-rules.json has agent selection logic
# AND hooks have agent filtering logic
# Result: Three places to update, routing conflicts
# GOOD: Single source of truth for routing
# skill-rules.json activates skill → skill calls router → router dispatches
```
### Assume Imports Work
```python
# BAD: Assume because you wrote the code, it's imported
from orchestration_layer import dispatch # Does this path exist?
# GOOD: Verify imports at integration test time
uv run python -c "from orchestration_layer import dispatch; print('OK')"
```
### Skip Integration Tests
```bash
# BAD: Only unit test
pytest tests/unit/ # All pass, but nothing works end-to-end
# GOOD: Integration test the wiring
pytest tests/integration/ # Verify full call path
```
## Common Wiring Gaps
### Hook Not Registered
```json
// .claude/settings.json - hook definition exists but not in hooks section
{
"hooks": {
"PreToolUse": [] // Empty! Your hook never fires
}
}
```
**Fix**: Add hook registration:
```json
{
"hooks": {
"PreToolUse": [{
"matcher": ["Task"],
"hooks": [{
"type": "command",
"command": "$CLAUDE_PROJECT_DIR/.claude/hooks/orchestration.sh"
}]
}]
}
}
```
### Script Not Executable
```bash
# Script exists but can't execute
-rw-r--r-- scripts/orchestrate.py
# Fix: Make executable
chmod +x scripts/orchestrate.py
```
### Module Not Importable
```python
# Script tries to import but path is wrong
from orchestration_layer import dispatch
# ModuleNotFoundError
# Fix: Add to Python path or use proper package structure
sys.path.insert(0, str(Path(__file__).parent.parent))
```
### Router Has No Dispatch Path
```python
# BAD: Router has beautiful mapping
AGENT_MAP = {
"implement": ImplementAgent,
"research": ResearchAgent,
# ... 18 agent types
}
# But no dispatch function uses the map
def route(task):
return "general-purpose" # Hardcoded! Map is dead code
# GOOD: Dispatch actually uses the map
def route(task):
agent_type = classify(task)
return AGENT_MAP[agent_type]
```
## Wiring Checklist
Before marking infrastructure "complete":
- [ ] Entry point identified and tested (hook/skill/CLI)
- [ ] Call graph documented (entry → module execution)
- [ ] Integration test exercises full path
- [ ] No orphaned modules (everything imported/called)
- [ ] Registration complete (settings.json/skill-rules.json)
- [ ] Permissions correct (scripts executable)
- [ ] Import paths verified (manual import test passes)
## Real-World Examples
### Example 1: DAG Orchestration (This Session)
**What was built:**
- `opc/orchestration/orchestration_layer.py` (500+ lines)
- `opc/orchestration/dag/` (DAG builder, validator, executor)
- 18 agent type definitions
- Sophisticated routing logic
**Wiring gap:**
- No hook calls orchestration_layer.py
- No script imports the DAG modules
- Agent routing returns hardcoded "general-purpose"
- Result: 100% dead code
**Fix:**
1. Create PreToolUse hook for Task tool
2. Hook calls `scripts/orchestrate.py`
3. Script imports and calls `orchestration_layer.dispatch()`
4. Dispatch uses AGENT_MAP to route to actual agents
5. Integration test: Submit Task → verify correct agent type used
### Example 2: Artifact Index (Previous Session)
**What was built:**
- SQLite database schema
- Indexing logic
- Query functions
**Wiring gap:**
- No hook triggered indexing
- Files created but never indexed
**Fix:**
1. PostToolUse hook on Write tool
2. Hook calls indexing script immediately
3. Integration test: Write file → verify indexed
## Detection Strategy
### Grep for Orphans
```bash
# Find Python modules
find . -name "*.py" -type f
# Check if each is imported
for file in $(find . -name "*.py"); do
module=$(basename $file .py)
grep -r "from.*$module import\|import.*$module" . || echo "ORPHAN: $file"
done
```
### Check Hook Registration
```bash
# List all hooks in .claude/hooks/
ls .claude/hooks/*.sh
# Check each is registered
for hook in $(ls .claude/hooks/*.sh); do
basename_hook=$(basename $hook)
grep -q "$basename_hook" .claude/settings.json || echo "UNREGISTERED: $hook"
done
```
### Verify Script Execution
```bash
# Find all Python scripts
find scripts/ -name "*.py"
# Test each can be imported
for script in $(find scripts/ -name "*.py"); do
uv run python -c "import sys; sys.path.insert(0, 'scripts'); import $(basename $script .py)" 2>/dev/null || echo "IMPORT FAIL: $script"
done
```
## Source
- This session: DAG orchestration wiring gap - 500+ lines of dead code discovered
- Previous sessions: Artifact Index, LMStudio integration - wiring added after initial build
© parcadei · MIT · parcadei/Continuous-Claude-v3