cleanup-a-bead

Remove dead code, files, configs, and hooks with orphan hunting and verification.

Updated May 3, 2026
One-click install
npx skills add https://github.com/fkberthold/loom --skill cleanup-a-bead
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: cleanup-a-bead
Source: https://github.com/fkberthold/loom/tree/main/skills/cleanup-a-bead
Command: npx skills add https://github.com/fkberthold/loom --skill cleanup-a-bead

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Cleanup beads can leave orphan references, stale configs, and dangling hooks that break runtime behavior after removal. This Skill provides a disciplined, pre-emptive approach to safely remove dead artifacts by performing an explicit scope identification, orphan-hunting, removal, and post-removal verification.

Core Features & Use Cases

  • Pre-removal scope definition to enumerate exactly what will be removed.
  • Orphan-reference hunting across the codebase to surface downstream impact.
  • Atomic removal with kill-list-informed commits and post-removal verification.
  • Integration with bead-lifecycle-shell for consistent lifecycle phases.

Quick Start

Execute a cleanup bead by defining scope, hunting orphans, removing the targeted items, and verifying the repository integrity.

Frequently Asked Questions about cleanup-a-bead

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I remove dead code without breaking runtime references in my repository?

Safe dead code removal requires defining scope, hunting orphan references, executing atomic removal, and verifying repository integrity. This Skill automates that process by generating a kill-list and commit-bound diff to prevent runtime breakage.

What's the best way to clean up orphan references and stale configs after removing files?

Cleaning up orphan references and stale configs is best handled by hunting downstream impacts across the codebase before removal. This Skill identifies dangling hooks and orphan references, then produces post-removal smoke tests to verify runtime stability.

How do I automate safe code cleanup and generate a kill-list for version control commits?

Automating safe code cleanup involves enumerating removal targets into a kill-list, binding changes to a commit diff, and running post-removal verification. This Skill follows M1 to M4 lifecycle steps to ensure removals are tracked and tested.

Do I need bead-lifecycle-shell integration to perform safe repository cleanup?

Bead-lifecycle-shell integration is required for this cleanup approach. It provides the consistent lifecycle phases needed to execute scope definition, orphan hunting, removal, and verification across the repository.

Why does removing dead code leave orphan references that break my application runtime?

Removing dead code leaves orphan references because stale configs and dangling hooks often remain connected to deleted files. This Skill preempts that issue by hunting orphan references across the codebase before performing atomic removal.