Claude Skills

This skill performs pre-cleanup tasks for repository maintenance, checking and removing common development artifacts like build directories, cache files, logs, and temporary files. It helps prepare repositories for cleanup operations by identifying important untracked files and creating backups when needed. Developers should use it before major cleanup operations to ensure build artifacts and temporary files are properly handled.

This skill helps developers identify untracked files in Git repositories, particularly large or duplicate files that may need cleanup. It provides shell commands to list untracked files, find files by size thresholds, and detect potential duplicates. Use this skill when preparing repositories for commits or optimizing storage by removing unnecessary files.

This sub-skill provides standardized `.gitignore` entries for Python projects to exclude build artifacts, test outputs, and IDE files. Developers should use it as part of the repo-cleanup process to ensure common temporary and local files are not tracked in version control. It automatically generates the necessary ignore patterns for a clean repository state.

This skill provides git commands to remove tracked files from repositories using `git rm`. It covers removing files and directories while optionally preserving local copies with `--cached`. The skill also includes complementary commands for untracked files and safety checks with dry runs.

This skill identifies and provides safe deletion commands for obsolete repository folders like legacy configs and empty directories. It includes verification checks to confirm folders aren't referenced before removal and offers consolidation paths for others. Use this when cleaning up technical debt in codebases to remove confirmed-safe clutter.

This skill provides conflict resolution patterns and commands for merging repository structures, particularly when consolidating codebases. It offers specific strategies for handling filename conflicts, similar content, and duplicate files with actionable bash commands. Developers should use it during repository cleanup operations to systematically resolve merge conflicts while preserving historical context.

This skill identifies and provides cleanup guidance for common hidden folders in repositories, focusing on legacy AI/agent directories and orphaned utility folders. It offers specific actions for each folder type (consolidate, delete, or keep) along with discovery commands to assess current usage. Use this when you need to clean up hidden technical debt and standardize your repo structure.

This skill provides best practices for safely cleaning up repository files, focusing on verification before deletion and proper Git workflows. It guides developers on using appropriate commands, maintaining commit clarity, and handling large files. Use it when performing repository cleanup to avoid data loss and keep changes organized.

This skill consolidates scattered agent-related directories into a single `.claude/agents/` structure. It handles runtime data, prototype code relocation, and test output organization for cleaner repository management. Use it when standardizing multi-agent project layouts to reduce clutter and improve maintainability.

The repo-cleanup skill systematically removes repository clutter like build artifacts, temp files, and duplicates while consolidating scattered directories. It's designed for repository maintenance, performing safe cleanup operations and updating .gitignore files. Developers should use it to clean up untracked files and organize project structure.

This skill identifies and helps clean up build artifacts and generated files that shouldn't be tracked in version control. It specifically targets Python development outputs like bytecode caches, distribution directories, and log files. Use this sub-skill when you need to maintain a clean repository by removing temporary build files and development logs.

This skill restructures flat repositories into a modular 5-layer architecture (src/tests/specs/docs/examples) while preserving git history. It's designed for major reorganizations, import path migrations, and cleanup of artifacts or duplicate directories. Key features include a parallel agent strategy and a 4-phase atomic commit workflow for reliable large-scale refactoring.

This skill provides version metadata for the hidden-folder-audit tool, specifying compatibility with Python 3.10+ and major operating systems. Developers should reference it to verify system requirements and dependency information when working with the parent audit skill.

This skill verifies the state of hidden folders in a project, checking which ones remain after consolidation into the `.claude/` directory. It lists remaining hidden folders and validates the structure of consolidation targets like `.claude/` and `scripts/git/`. Use this skill during project audits to ensure hidden folder organization follows established conventions.

This skill inventories all hidden folders in a repository root, excluding `.git`, and provides their sizes and symlink status. It also checks each folder's Git tracking status to identify whether they're tracked, ignored, or untracked. Use this as the first step in a hidden folder audit to establish a baseline before analysis.

This skill archives completed specification plans by moving them from `specs/modules/` to `specs/archive/`. It also provides guidelines for organizing benchmark directories, separating reference data, scripts, and generated reports. Use it to maintain a clean specification structure and manage benchmark artifacts.

This pre-audit skill systematically analyzes hidden folders before cleanup, documenting their state and identifying duplicates, broken symlinks, and usage. It creates a migration plan by listing files to move, delete, or update. Use it as the first step when preparing to reorganize or remove hidden directories in a codebase.

This skill migrates legacy `.agent-os` and `.ai` directories to the new `.claude` structure for agent and prompt management. It handles file copying, creates necessary directories, and includes cleanup of dead symlinks. Use it when upgrading older Claude Code projects to the current organizational standard.

This reference skill provides a curated list of common hidden folders (like `.git/`, `.env`, `.vscode/`) with recommended actions (KEEP or DELETE) for cleanup operations. It helps developers quickly audit project directories by identifying which hidden files are essential versus disposable. Use it as a sub-skill within a broader hidden-folder-audit to ensure safe and consistent project maintenance.

This skill provides best practices for safely removing hidden folders from Git repositories. It offers actionable guidance on backup strategies, proper Git commands, and workflow steps to prevent data loss. Developers should use it when consolidating or cleaning up repository structure to maintain history and avoid breaking dependencies.

This skill audits and consolidates hidden folders in repositories, identifying duplicates, dead directories, and consolidation opportunities for folders like .agent-os/, .ai/, and .claude/. It's useful when repositories have accumulated multiple AI/agent configuration directories over time or contain broken symlinks. The tool helps clean up and standardize hidden folder structures.

This skill provides a verification checklist for refactoring code into discipline-based modules. It validates that all code, tests, docs, and specs are properly organized in their respective module directories with consistent naming. Use it to ensure complete and consistent module restructuring before finalizing refactoring work.

This skill defines the target repository structure for refactoring projects into a modular architecture organized by technical discipline. It provides a standardized layout with parallel directories for source code, tests, documentation, specifications, and data—all grouped under discipline-specific modules. Developers should use this as a reference template when restructuring codebases to improve separation of concerns and maintainability.

This skill refactors a project's standard folder structure into a discipline-based module organization, grouping related files (like source code, tests, and docs) under `modules/<discipline>/` subdirectories. It's used to transition from a flat, type-based layout to a more modular, feature-focused architecture. The transformation applies to common directories like `src/`, `tests/`, and `docs/`, while keeping certain folders like `specs/templates/` flat as exceptions.