wiring
Wiring ensures your infrastructure components are reachable and actually execute when needed. It guides you through verifying entry points, tracing call paths from trigger to execution, testing end-to-end flows, and eliminating orphaned modules—preventing dead code and wasted effort.
Wiring verifies that your infrastructure code is actually invoked in the execution path, not left as dead code.
AI-generated summary based on this skill's SKILL.md
Install
parcadei/Continuous-Claude-v3/wiring · repository language: Python
git clone https://github.com/parcadei/Continuous-Claude-v3
cp -r Continuous-Claude-v3/.claude/skills/wiring ~/.claude/skills/wiringFrequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How to verify infrastructure code is actually being called?
Wiring helps you confirm that your infrastructure code executes in the actual call path. Start by tracing from your entry point through the complete call graph to the target module. Use integration tests to validate end-to-end flows rather than relying on unit tests alone. Check that hooks are registered in settings.json and that all component dependencies are properly imported. Add logging at key checkpoints to confirm execution reaches your infrastructure code.
How does Wiring help identify dead code and orphaned modules?
Wiring guides you through systematic code auditing to find unreachable paths and unused components. Map your entry points and trace which modules are actually invoked during execution. Identify imports that aren't referenced and modules with no incoming calls. Wiring's approach helps you eliminate orphaned code that wastes maintenance effort and creates confusion about what actually runs in your infrastructure setup.
Can Wiring trace execution path from entry point to module?
Yes. Wiring's core strength is validating the call graph from trigger to execution. Document each step: entry point registration, hook firing, component instantiation, and final execution. Use integration tests to verify the complete wiring path works end-to-end. This prevents gaps where infrastructure code appears correct but never actually runs due to missing connections or broken dependencies.
What should a Wiring checklist for infrastructure setup include?
Wiring recommends verifying: entry points are connected properly, hooks are registered and firing, all component dependencies are imported, scripts have correct permissions, no orphaned modules exist, call graph is traceable from trigger to execution, and end-to-end integration tests pass. Document your infrastructure component registration and audit the wiring to ensure every piece is reachable and actually invoked when needed.
How does Wiring ensure all components are wired together?
Wiring validates infrastructure component connectivity by confirming each piece is registered, imported, and reachable from your entry points. Test full invocation paths rather than isolated units. Verify hook registration, check that permissions allow execution, and trace the complete call path. Integration testing confirms end-to-end flows work, preventing gaps where components appear connected but fail during actual execution.
Why test end-to-end call graph execution instead of just unit tests?
Wiring emphasizes end-to-end testing because infrastructure code often fails not from logic errors but from broken wiring—missing imports, unregistered hooks, or unreachable entry points. Unit tests pass while the actual execution path never reaches your code. Integration tests validate the complete call graph from trigger through all components to final execution, catching wiring failures that unit tests miss.
SKILL.md
rendered from the published skill — quoted content, verbatim
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:
- Entry Point Exists: How does user action trigger this code?
- Call Graph Traced: Can you follow the path from entry to execution?
- Integration Tested: Does an end-to-end test exercise this path?
- No Dead Code: Is every built component actually reachable?
DO
Verify Entry Points
# 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
(truncated - see the full file via the links below)
Read as markdown · JSON record · Browse the source repository
File tree — 1 file
.claude/skills/wiring/SKILL.md