Clean Project

I'll help clean up development artifacts while preserving your working code.

Token Optimization:

This skill is optimized for 75% token reduction (2,000-3,000 → 500-750 tokens) through Bash-based cleanup operations and template-based pattern matching.

Core Optimization Strategies:

Bash-Based Cleanup Operations (70-80% savings)
- Use find + rm commands for file deletion (external tools)
- Execute git status --porcelain for untracked file detection
- Use ls -la for directory size verification
- Pattern: find . -name "*.log" -type f -delete
- Never use Read tool - only Bash commands for cleanup

Template-Based Cleanup Patterns (60-70% savings)

Pre-defined patterns for common artifacts:

# Debug/log files
find . -name "*.log" -o -name "*.tmp" -o -name "*~" -type f

# Node.js artifacts
find . -name "*.log" -o -name "npm-debug.log*" -type f

# Python artifacts
find . -name "*.pyc" -o -name "__pycache__" -type d

# Editor artifacts
find . -name ".DS_Store" -o -name "Thumbs.db" -type f

Load patterns from cache if available
No file reading - pattern-based identification only

Git Status for Untracked Detection (80% savings)
- Single command: git status --porcelain | grep "^??"
- Identifies untracked files without Read operations
- Filter by extension/pattern using grep in same pipeline
- Example: git status --porcelain | grep "^??" | grep -E '\.(log|tmp|bak)$'
Early Exit When Clean (90% savings)
- Check for cleanup targets before any operations:
```
if [ -z "$(find . -name '*.log' -o -name '*.tmp' 2>/dev/null)" ]; then
  echo "Project is already clean"
  exit 0
fi
```
- Exit immediately if no artifacts found
- Saves 500-700 tokens on clean projects
Dry-Run Preview with Bash (prevents wasted operations)
- Show what will be deleted: find . -name "*.log" -type f
- Count files: find . -name "*.log" -type f | wc -l
- Display sizes: find . -name "*.log" -type f -exec du -h {} + | awk '{sum+=$1} END {print sum}'
- No Read operations for preview
Batch Deletion Operations (80% savings)
- Delete all matching files in one command
- Use -delete flag or -exec rm {} + for efficiency
- Process entire directories: rm -rf .cache/ .tmp/
- Never iterate through files individually

Protected Path Filtering (template-based)

Exclude patterns in find command:

find . -path "./node_modules" -prune -o \
       -path "./.git" -prune -o \
       -path "./.claude" -prune -o \
       -name "*.log" -type f -print

No verification reads - trust path patterns

Progressive Cleanup Phases (optional for large projects)
- Phase 1: Safe artifacts (*.log, *.tmp) - auto-delete
- Phase 2: Debug files (debug_, test_output) - confirm before delete
- Phase 3: Large caches (.cache/, .webpack/) - size-based decision
- Each phase is a single Bash command
Git Checkpoint Management (minimal token cost)
- Create checkpoint: git add -A && git commit -m "Pre-cleanup checkpoint"
- Verify safety: git status (single call)
- No file operations - only git commands
Cleanup Verification (Bash-only)
- Post-cleanup status: git status --short
- Disk space saved: du -sh .
- Remaining artifacts: find . -name "*.log" | wc -l
- No Read operations for verification

Caching Strategy:

Cache Location: .claude/cache/cleanproject/
Cached Data:
  - cleanup_patterns.json:
      common: ["*.log", "*.tmp", "*~", ".DS_Store"]
      node: ["npm-debug.log*", "yarn-error.log"]
      python: ["*.pyc", "__pycache__/"]
      editor: [".vscode/.history", ".idea/workspace.xml"]
  - protected_paths.json:
      always: [".git", ".claude", "node_modules"]
      conditional: [".cache", ".webpack"]
  - last_cleanup.json:
      timestamp, files_deleted, space_saved
Cache Validity: 7 days or until .gitignore changes
Cache Updates: After each successful cleanup

Tool Usage Patterns:

Optimized Workflow:

1. Check if clean → Bash: find/ls (50 tokens)
2. Early exit if clean → Exit (0 tokens saved: 500+)
3. Git checkpoint → Bash: git commit (50 tokens)
4. Preview targets → Bash: find (50 tokens)
5. Batch delete → Bash: find -delete (50 tokens)
6. Verify cleanup → Bash: git status (50 tokens)
Total: 250-500 tokens for typical cleanup

Anti-Patterns (Avoided):

❌ Read tool for file inspection (500+ tokens per file)
❌ Glob + Read iteration (200+ tokens per file)
❌ Individual file deletions (loops)
❌ Content verification before delete
❌ Detailed file analysis

Token Budget by Scenario:

Scenario	Optimized	Unoptimized	Savings
Already clean	50-100	800-1,500	90-95%
Few artifacts (<10)	300-500	1,200-2,000	70-75%
Many artifacts (>50)	500-750	2,500-3,500	75-80%
Large codebase	600-800	3,000-4,000	75-80%

Expected Performance:

Baseline: 2,000-3,000 tokens (read-heavy approach)
Optimized: 500-750 tokens (Bash-only approach)
Reduction: 75% average (1,500-2,250 tokens saved)
Best case: 90% reduction (already clean project)
Optimization status: ✅ Fully Optimized (Phase 2 Batch 3D-F, 2026-01-26)

Strategic Thinking Process

Artifact Identification
- What patterns indicate temporary/debug files?
- Which files might look temporary but are actually important?
- Are there project-specific conventions for temp files?
- What about generated files that should be kept?
Safety Analysis
- Which deletions are definitely safe?
- Which require more careful inspection?
- Are there active processes using these files?
- Could removing these break the development environment?
Common Pitfalls
- .env files might look like artifacts but contain config
- .cache directories might be needed for performance
- Some .tmp files might be active session data
- Debug logs might contain important error information
Cleanup Strategy
- Start with obvious artifacts (*.log, *.tmp, *~)
- Check file age - older files are usually safer to remove
- Verify with git status what's tracked vs untracked
- Group similar files for batch decision making

Based on this analysis, I'll create a git checkpoint for safety:

git add -A
git commit -m "Pre-cleanup checkpoint" || echo "No changes to commit"

Important: I will NEVER:

Add "Co-authored-by" or any Claude signatures
Include "Generated with Claude Code" or similar messages
Modify git config or user credentials
Add any AI/assistant attribution to the commit
Use emojis in commits, PRs, or git-related content

I'll identify cleanup targets using native tools:

Glob tool to find temporary and debug files
Grep tool to detect debug statements in code
Read tool to verify file contents before removal

Critical directories are automatically protected:

.claude directory (commands and configurations)
.git directory (version control)
node_modules, vendor (dependency directories)
Essential configuration files

When I find multiple items to clean, I'll create a todo list to process them systematically.

I'll show you what will be removed and why before taking action:

Debug/log files and temporary artifacts
Failed implementation attempts
Development-only files
Debug statements in code

After cleanup, I'll verify project integrity and report what was cleaned.

If any issues occur, I can restore from the git checkpoint created at the start.

This keeps only clean, working code while maintaining complete safety.