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
Decision gist · record as of 2026-01-26
Wiring verifies that your infrastructure code is actually invoked in the execution path, not left as dead code. 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.
Use it when
- Wiring guides you through systematic code auditing to find unreachable paths and unused components.
- Yes.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Install
parcadei/Continuous-Claude-v3/wiring · repository language: Python
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently 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)
File tree — 1 file
.claude/skills/wiring/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Verify that infrastructure code is actually invoked in the execution path”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Skill Developer is a comprehensive guide for creating and managing Claude Code skills with auto-activation. It covers skill structure, YAML frontmatter, trigger types, enforcement levels, hook mechanisms, and the 500-line rule. Use it when building new skills, modifying skill-rules.json, debugging activation issues, or implementing progressive disclosure patterns.
Extract patterns from recent sessions and convert them into persistent capabilities—rules for heuristics, skills for workflows, and hooks for automation. The skill guides you through gathering learnings, consolidating similar patterns, detecting meta-themes, and proposing artifacts with appropriate signal thresholds before creation.
Skill Developer is a meta-skill for building new Claude Code skills from the ground up or converting existing scripts. It provides templates, step-by-step guidance for wrapping MCP pipelines, and configuration patterns to enable Claude's automatic skill discovery.
Debugging provides structured methodologies across four sub-skills: systematic investigation to isolate root causes, backward tracing through call stacks, layered validation to prevent recurrence, and verification before claiming fixes are complete. Use it when encountering bugs, test failures, or unexpected behavior.
Root Cause Tracing teaches you to work backward from where an error appears to discover what actually caused it. Rather than patching the symptom, you'll follow the call chain upward, add instrumentation when needed, and identify the source trigger. The skill includes real examples and defense-in-depth strategies to prevent the bug from recurring.
Systematic Debugging enforces a disciplined four-phase process: investigate root cause, analyze patterns, form and test hypotheses, then implement fixes. It stops you from guessing or patching symptoms, ensuring you understand the actual problem before making changes.