CLI Modern Tools Skill

Purpose: Automatically suggest and use modern CLI alternatives for 50%+ speed improvements and better UX

⚠️ CRITICAL: Claude's Internal Tool Usage

Before Claude executes ANY bash command internally, MUST check:

bash find . -name "*.js"

pattern="**/*.js"

bash grep -r "pattern"

pattern="pattern"

bash cat file.txt

file_path="file.txt"

bash ls -la

bash eza --long --git

Why this matters:

• Skills only auto-activate on user messages, NOT on Claude's internal tool calls
• Claude must consciously check this table before executing bash commands
• Prevents bypassing token-efficient Claude Code tools

See CLAUDE.md "Tool Usage Guidelines" for complete replacement rules.

🎯 Core Concept

Replace traditional Unix commands with modern, faster, feature-rich alternatives:

• bat > cat (syntax highlighting)
• eza > ls (git status, icons)
• fd > find (18x faster)
• ripgrep > grep (10x faster) [Note: Use Grep tool in Claude Code]
• watchexec for automation

🔧 BASH COMMAND ATTRIBUTION PATTERN

CRITICAL: Before executing EACH bash command, MUST output:

🔧 [cli-modern-tools] Running: <command>

Examples:

🔧 [cli-modern-tools] Running: bat app.js
🔧 [cli-modern-tools] Running: eza --long --git
🔧 [cli-modern-tools] Running: fd "\.tsx$"
🔧 [cli-modern-tools] Running: watchexec -e php ./vendor/bin/pest

Why: This pattern helps users identify which skill is executing which command, improving transparency and debugging.

🎨 VISUAL OUTPUT FORMATTING

IMPORTANT: Use MINIMAL colored output (2-3 calls max) to prevent screen flickering!

Use Colored-Output Skill

Example formatted output (MINIMAL PATTERN):

# START: Header only
bash .claude/skills/colored-output/color.sh skill-header "cli-modern-tools" "Replacing traditional CLI commands..."

# MIDDLE: Regular text (no colored calls)
Using bat instead of cat for syntax highlighting...
Using eza instead of ls for git status integration...
Using fd instead of find for faster file search...

# END: Result only
bash .claude/skills/colored-output/color.sh success "" "Modern CLI tools applied"

WHY: Each bash call creates a task in Claude CLI, causing screen flickering. Keep it minimal!

🚀 Auto-Activation Triggers

CRITICAL: This skill auto-activates on traditional command detection and AUTOMATICALLY replaces them.

⚙️ FEATURE TOGGLE CONTROL: Before suggesting any replacement, CHECK the

feature_config

• If

  bat: enabled

  → Suggest bat
• If

  bat: disabled

  → Use traditional cat (no suggestion)
• Same logic for eza, fd, ripgrep, watchexec

Pattern 1: File Viewing

Triggers:

cat

view file

show file

display contents

bat: enabled

bat

cat

cat

# ❌ Traditional
cat app.js

# ✅ Automatic replacement (IF bat: enabled)
bat app.js  # Syntax highlighting, line numbers

# ⬜ Fallback (IF bat: disabled)
cat app.js  # Use traditional command

Pattern 2: Directory Listing

Triggers:

ls

list files

show directory

list dir

eza: enabled

eza --long --git

ls

ls

# ❌ Traditional
ls -la app/Models/

# ✅ Automatic replacement (IF eza: enabled)
eza --long --git app/Models/  # Git status, icons, colors

# ⬜ Fallback (IF eza: enabled)
ls -la app/Models/  # Use traditional command

Pattern 3: File Search (Bash Tool Only)

Triggers:

find

search files

locate file

find file named

fd: enabled

fd

find

find

# ❌ Traditional
find . -name "*.tsx"

# ✅ Automatic replacement (IF fd: enabled, Bash tool only)
fd "\.tsx$"

# ⬜ Fallback (IF fd: disabled)
find . -name "*.tsx"

# ✅ For Claude Code tools (NOT bash)
# Use Glob tool instead

Pattern 4: Content Search

Triggers:

grep

search in files

search content

find text

❌ bash -c "grep -r 'TODO' app/"
✅ [Use Grep tool with pattern="TODO" path="app/"]

Note: ripgrep feature toggle only affects bash command suggestions, not Claude Code tools

Pattern 5: File Watching

Triggers:

watch files

auto-run

continuous testing

on file change

watchexec: enabled

watchexec

# ❌ Traditional (manual)
# Run tests manually after each change

# ✅ Automatic replacement (IF watchexec: enabled)
watchexec -e php ./vendor/bin/pest

# ⬜ Fallback (IF watchexec: disabled)
# Suggest manual approach

Pattern 6: Tree View

Triggers:

tree

show tree

directory structure

eza: enabled

eza --tree

tree

tree

# ❌ Traditional
tree -L 3

# ✅ Automatic replacement (IF eza: enabled)
eza --tree --level=3

# ⬜ Fallback (IF eza: enabled)
tree -L 3

🎯 Automatic Replacement Rules

Rule 1: Direct Command Replacement

When user says "cat app.js", Claude should:

1. Detect "cat" keyword → Auto-activate skill
2. Replace with

   bat app.js

3. Execute immediately (no suggestion, just do it)
4. Mention replacement: "Using bat for syntax highlighting"

Rule 2: Wrapper Script Usage

For explicit automation, use wrapper:

bash .claude/skills/cli-modern-tools/cli-wrapper.sh view app.js
bash .claude/skills/cli-modern-tools/cli-wrapper.sh list app/
bash .claude/skills/cli-modern-tools/cli-wrapper.sh find "*.tsx"
bash .claude/skills/cli-modern-tools/cli-wrapper.sh check

Rule 3: Fallback Safety

Always check tool availability:

command -v bat &> /dev/null && bat file.txt || cat file.txt

Rule 4: Context-Aware Replacement

• Bash Tool: Replace

  find

  with

  fd

• Claude Code Tools: Use

  Glob

  tool (not fd, not find)
• Content Search: Always use

  Grep

  tool (never bash grep/rg)

📊 Tool Comparison Matrix

cat app.js

bat app.js

ls -la

eza --long --git

find . -name "*.js"

fd "\.js$"

grep -r "TODO"

watchexec -e js npm test

🔧 Tool Details

1. bat (Better cat)

Install:

# Windows
scoop install bat

# Mac
brew install bat

# Linux
apt install bat

Usage:

# Basic file viewing with syntax highlighting
bat app/Models/User.php

# Specific line range
bat routes/api.php --line-range 1:50

# Pipe with syntax highlighting
curl http://api.example.com | bat -l json

# Multiple files
bat src/*.js

Features:

• ✅ Automatic syntax highlighting (200+ languages)
• ✅ Line numbers by default
• ✅ Git diff indicators
• ✅ Non-printable character visibility
• ✅ Automatic paging for long files

When to Use:

• ✅ Viewing code files (always prefer over cat)
• ✅ API response inspection (pipe JSON/XML)
• ✅ Log file viewing with highlighting
• ✅ Quick code review

2. eza (Better ls)

Install:

# Windows
scoop install eza

# Mac
brew install eza

# Linux
cargo install eza

Usage:

# Git-aware listing with stats
eza --long --git app/Models/

# Tree view with depth limit
eza --tree --level=3 resources/js/

# Recently modified files
eza --long --sort=modified --reverse

# With icons and colors
eza --long --icons --color=always

Features:

• ✅ Git status integration (modified, staged, untracked)
• ✅ Human-readable file sizes
• ✅ Icons for file types
• ✅ Color-coded output
• ✅ Extended attributes display

When to Use:

• ✅ Exploring git repositories
• ✅ Finding recently modified files
• ✅ Understanding directory structure
• ✅ Visual directory navigation

3. fd (Better find)

Install:

# Windows
scoop install fd

# Mac
brew install fd

# Linux
apt install fd-find

Usage:

# Find TypeScript files
fd "\.tsx$" resources/js/

# Find controller files
fd Controller.php app/Http/Controllers/

# Multiple extensions
fd -e php -e js

# Case-insensitive
fd -i readme

# Ignore .gitignore patterns
fd --no-ignore "test"

Features:

• ✅ 18x faster than find
• ✅ Smart case-insensitive search
• ✅ Respects .gitignore by default
• ✅ Simpler syntax than find
• ✅ Parallel execution

When to Use (in Bash tool only):

• ✅ Quick file discovery by name/pattern
• ❌ NOT for Claude Code tool use (use Glob tool instead)

Important: When using Claude Code tools (not bash), always prefer Glob tool over fd.

4. Grep Tool (NOT bash grep/ripgrep)

Critical Rule: In Claude Code, ALWAYS use Grep tool, NEVER bash grep or ripgrep.

Why:

• ✅ Optimized permissions and access
• ✅ Token-efficient output
• ✅ Proper error handling
• ✅ Integrated with Claude Code

Usage:

[Use Grep tool with pattern="TODO" path="app/"]
[Use Grep tool with pattern="function" type="ts"]

When to Use:

• ✅ ANY content search operation in Claude Code
• ✅ Finding code patterns
• ✅ Searching for TODOs, FIXMEs
• ✅ Cross-file text search

5. watchexec (File Watching Automation)

Install:

# Windows
scoop install watchexec

# Mac
brew install watchexec

# Linux
cargo install watchexec-cli

Usage:

# Auto-run PHP tests on changes
watchexec -e php -c ./vendor/bin/pest

# Auto-lint TypeScript on save
watchexec -e tsx,ts -w resources/js/ npm run lint

# Auto-migrate and verify schema
watchexec -w database/migrations/ "php artisan migrate && bash .claude/skills/sql-cli/sql-cli.sh tables"

# Multiple commands with debouncing
watchexec -w src/ "npm run build && npm run test"

Features:

• ✅ Intelligent file watching
• ✅ Debouncing (prevents multiple rapid runs)
• ✅ Cross-platform support
• ✅ Pattern-based filtering
• ✅ Clear screen between runs

When to Use:

• ✅ Continuous testing during development
• ✅ Auto-formatting on save
• ✅ Live documentation generation
• ✅ Database migration monitoring

🎬 Workflow Examples

Example 1: Code Review Workflow

Traditional Approach:

cat app/Models/User.php          # No syntax highlighting
ls -la app/Models/               # No git status
find app/ -name "*Controller*"   # Slow, complex syntax

Modern Approach:

bat app/Models/User.php                    # ✅ Syntax highlighted
eza --long --git app/Models/               # ✅ Git status visible
fd Controller app/Http/Controllers/        # ✅ 18x faster

Savings: 50% faster, significantly better UX

Example 2: Development Automation

Traditional Approach:

# Manually re-run tests after each change
./vendor/bin/pest
# ... edit file ...
./vendor/bin/pest
# ... edit file ...
./vendor/bin/pest

Modern Approach:

# Set up once, runs automatically
watchexec -e php -c -w tests/,app/ ./vendor/bin/pest
# ... edit file ... tests run automatically
# ... edit file ... tests run automatically

Savings: Infinite time saved through automation

Example 3: API Response Inspection

Traditional Approach:

curl http://api.example.com/users | cat
# Output: {"users":[{"id":1,"name":"John"}]}
# Hard to read, no formatting

Modern Approach:

curl http://api.example.com/users | bat -l json
# Output: Syntax-highlighted, formatted JSON

Savings: Instant readability

📈 Performance Benchmarks

File Search (10,000 files in directory)

find . -name "*.js"

fd "\.js$"

Directory Listing (500 files)

ls -la

eza --long --git

File Viewing

cat

bat

🔄 Auto-Suggestion Logic

When User Uses Traditional Command

Pattern: User mentions

cat <file>

Claude detects "cat" keyword
→ Auto-activate cli-modern-tools skill
→ Suggest: "I'll use bat instead for syntax highlighting"
→ Execute: bat <file>

Pattern: User mentions

ls

ls -la

Claude detects "ls" keyword
→ Auto-activate cli-modern-tools skill
→ Suggest: "I'll use eza with git status"
→ Execute: eza --long --git

Pattern: User mentions

find . -name

Claude detects "find" keyword
→ Auto-activate cli-modern-tools skill
→ Check context: Bash tool or Claude tool?
→ If Bash tool: Suggest fd
→ If Claude tool: Use Glob tool

⚠️ Important Rules

✅ DO Use Modern Tools When:

• User mentions traditional command names
• Better UX significantly helps user
• Tools are available on system
• Speed improvement matters (large directories/files)

❌ DON'T Use When:

• Tool not available (fallback to traditional)
• POSIX compliance required (portable scripts)
• Non-development environment
• One-off operation where setup overhead > benefit

🔍 Tool Availability Check Pattern:

# Check if modern tool available, fallback to traditional
command -v bat &> /dev/null && bat file.txt || cat file.txt
command -v eza &> /dev/null && eza -la || ls -la
command -v fd &> /dev/null && fd pattern || find . -name pattern

🎯 Integration with Other Skills

Works Well With:

• markdown-helper: Use bat to view markdown with highlighting before parsing
• sql-cli: Use bat to syntax-highlight SQL query results
• watchexec: Auto-run markdown-helper on file changes

Example Combined Workflow:

# Watch markdown files, auto-lint on changes
watchexec -e md "node ~/.claude/skills/markdown-helper/md-helper.js lint *.md"

# View SQL results with syntax highlighting
bash .claude/skills/sql-cli/sql-cli.sh query "SELECT * FROM users LIMIT 10" | bat -l sql

📦 Installation Guide

Windows (Scoop)

# Install Scoop if not installed
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
irm get.scoop.sh | iex

# Install tools
scoop install bat eza fd watchexec

Mac (Homebrew)

# Install tools
brew install bat eza fd ripgrep watchexec

Linux (APT)

# Install tools
sudo apt install bat fd-find ripgrep
cargo install eza watchexec-cli

🎓 Quick Reference

bat app.js

cat app.js

eza --long --git

ls -la

fd "pattern"

find . -name "pattern"

grep -r

rg

watchexec -e php ./vendor/bin/pest

curl ... | bat -l json

curl ... | cat

eza --sort=modified --reverse

ls -lt

📊 Token & Time Savings

Typical Development Day (10 operations)

Traditional Approach:

• 10x

  cat

  commands: No highlighting, harder to read
• 10x

  ls -la

  : No git status, manual checking
• 5x

  find

  commands: 9 seconds total
• Manual test re-runs: 10 minutes context switching

Modern Approach:

• 10x

  bat

  commands: Instant code comprehension
• 10x

  eza --long --git

  : Instant git status awareness
• 5x

  fd

  commands: 0.5 seconds total

• watchexec

  automation: 0 context switching

Daily Savings:

• Time: ~15 minutes/day = 1.25 hours/week
• Cognitive Load: Significantly reduced through better UX
• Speed: 50-90% faster file operations

🐛 Troubleshooting

"Command not found: bat"

Solution: Install bat using package manager for your OS

"Command not found: eza"

Solution: Install eza using Cargo or package manager

"Command not found: fd"

Solution: Install fd (may be named

fd-find

bat shows

cat

behavior

Solution: On some Linux systems, bat is installed as

batcat

alias bat='batcat'  # Add to ~/.bashrc

📝 Summary

This skill provides:

• ✅ 50%+ speed improvements for file operations
• ✅ Automatic modern tool suggestions when detecting traditional commands
• ✅ Better UX through syntax highlighting, git integration, icons
• ✅ Automation via watchexec for continuous workflows
• ✅ Cross-platform support (Windows, Mac, Linux)
• ✅ Fallback safety to traditional tools when modern tools unavailable

Use modern CLI tools for all file operations in development workflows!