Skillget

my-ai-tools

skill
SUMMARY

Comprehensive configuration management for AI coding tools - Replicate my complete setup for Claude Code, OpenCode, Amp, Codex and Claude Code Switch with custom configurations, MCP servers, plugins, and commands.

README.md

Welcome to my-ai-tools 👋

GitHub stars
GitHub license
PRs Welcome

Comprehensive configuration management for AI coding tools - Replicate my complete setup for Claude Code, OpenCode, Amp, Kilo CLI, Codex, Gemini CLI, Pi, GitHub Copilot CLI, Cursor Agent CLI and CCS with custom configurations, MCP servers, skills, plugins, and commands.

📖 View Documentation Website - Interactive landing page with full documentation and search.

✨ Features

  • 🚀 One-line installer - Get started in seconds
  • 🔄 Bidirectional sync - Install configs or export your current setup
  • 🤖 Multiple AI tools - Claude Code, OpenCode, Amp, CCS, and more
  • 🔌 MCP Server integration - Context7, Sequential-thinking, qmd
  • 🎯 Custom agents & skills - Pre-configured for maximum productivity
  • 🤝 Agent Teams - Coordinate specialized agents for complex workflows (code review, testing, docs)
  • 📦 Plugin support - Official and community plugins
  • 🛡️ Git Guard Hook - Prevents dangerous git commands (force push, hard reset, etc.)

🎬 Demo

IT Man Channel

IT Man - My AI Setup in 2026

📋 Prerequisites

  • Bun or Node.js LTS - Runtime for tools and scripts
  • Git - Version control
  • Claude Code subscription or use CCS with affordable providers (GLM, MiniMax)

🚀 Quick Start

One-Line Installer (Recommended)

Install directly without cloning the repository:

curl -fsSL https://ai-tools.itman.fyi/install.sh | bash

Security Note: Review the script before running:

curl -fsSL https://ai-tools.itman.fyi/install.sh -o install.sh
cat install.sh  # Review the script
bash install.sh

Options:

# Preview changes without making them
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --dry-run

# Backup existing configs before installing
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --backup

# Skip backup prompt
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --no-backup

Manual Installation

Clone the repository and run the installer:

git clone https://github.com/jellydn/my-ai-tools.git
cd my-ai-tools
./cli.sh

Options:

  • --dry-run - Preview changes without making them
  • --backup - Backup existing configs before installing
  • --no-backup - Skip backup prompt

🔄 Bidirectional Config Sync

Forward: Install to Home (cli.sh)

Copy configurations from this repository to your home directory (~/.claude/, ~/.config/opencode/, etc.):

./cli.sh [--dry-run] [--backup] [--no-backup]

Reverse: Generate from Home (generate.sh)

Export your current configurations back to this repository for version control:

./generate.sh [--dry-run]

Tip: Use generate.sh after customizing your local setup to save changes back to this repo.

🤖 Claude Code

Primary AI coding assistant with extensive customization.

Installation

curl -fsSL https://claude.ai/install.sh | bash

MCP Servers Setup

Automatic Setup (Recommended)

Run the setup script to configure MCP servers:

./cli.sh

The script will prompt you to install each MCP server:

  • context7 - Documentation lookup for any library
  • sequential-thinking - Multi-step reasoning for complex analysis
  • qmd - Quick Markdown Search with AI-powered knowledge management

Manual Setup

For Claude Desktop

Add to ~/.claude/mcp-servers.json:

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "qmd": {
      "command": "qmd",
      "args": ["mcp"]
    }
  }
}
For Claude Code

Use the CLI (installed globally for all projects):

claude mcp add --scope user --transport stdio context7 -- npx -y @upstash/context7-mcp@latest
claude mcp add --scope user --transport stdio sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking
claude mcp add --scope user --transport stdio qmd -- qmd mcp

MCP Scopes:

  • --scope user (global): Available across all projects
  • --scope local (default): Only in current project directory
  • --scope project: Stored in .mcp.json for team sharing

Managing MCP Servers

# List all configured servers
claude mcp list

# Remove an MCP server
claude mcp remove context7

# Get details for a specific server
claude mcp get qmd

Knowledge Management

Replace deprecated claude-mem with qmd-based knowledge system:

  • Project-specific knowledge bases in ~/.ai-knowledges/
  • AI-powered search via qmd MCP server
  • No repository pollution
  • See qmd Knowledge Management Guide

Plugins

Prerequisites

Before installing plugins, ensure:

  1. Claude Code subscription - Active subscription with plugin support
  2. Plugin marketplace access - Verify marketplace is enabled for your repository
  3. Network connectivity - Required for downloading marketplace plugins

To check marketplace availability:

# Verify Claude CLI supports plugins
claude plugin list

# If the above fails, check your Claude Code installation and subscription

Installation

The setup script (./cli.sh) automatically checks marketplace availability before installing plugins. If marketplace is unavailable, it will offer to install local plugins only.

Automated installation (recommended):

./cli.sh  # Includes marketplace check and fallback to local plugins

Manual installation (requires marketplace access):

# First, add the official marketplace
claude plugin marketplace add anthropics/claude-plugins-official

# Official plugins
claude plugin install typescript-lsp@claude-plugins-official
claude plugin install pyright-lsp@claude-plugins-official
claude plugin install context7@claude-plugins-official
claude plugin install frontend-design@claude-plugins-official
claude plugin install learning-output-style@claude-plugins-official
claude plugin install swift-lsp@claude-plugins-official
claude plugin install lua-lsp@claude-plugins-official
claude plugin install code-simplifier@claude-plugins-official
claude plugin install rust-analyzer-lsp@claude-plugins-official
claude plugin install claude-md-management@claude-plugins-official

# Community plugins (add marketplace first)
# Plugin installation format: plugin-name@marketplace-name
# Example: The repository 'backnotprop/plannotator' registers as marketplace 'plannotator',
#          then you install plugin 'plannotator' from that marketplace
claude plugin marketplace add backnotprop/plannotator
claude plugin install plannotator@plannotator

claude plugin marketplace add jarrodwatts/claude-hud
claude plugin install claude-hud@claude-hud

claude plugin marketplace add max-sixty/worktrunk
claude plugin install worktrunk@worktrunk

# Install skills from this repository (jellydn/my-ai-tools)
# Recommended: Install all skills at once using npx skills add
npx skills add jellydn/my-ai-tools --yes --global --agent claude-code

# Or install interactively (select which skills to install)
npx skills add jellydn/my-ai-tools --global --agent claude-code

# Available skills: prd, ralph, qmd-knowledge, codemap, adr, handoffs, pickup, pr-review, slop, tdd
# Skills are installed to ~/.agents/skills/ with symlinks in ~/.claude/skills/

Troubleshooting

Skills installation issues?

If you encounter issues:

  1. Check npx availability: Ensure Node.js and npx are installed (npx --version)
  2. Use local skills: The setup script automatically falls back to local skills from skills/ folder
  3. Manual installation: Copy skill folders directly to ~/.claude/skills/
  4. Interactive mode: Run without --yes flag to select specific skills

Common issues:

  • "npx not found" → Install Node.js to use remote skill installation, or use local skills via ./cli.sh
  • "Permission denied" → Try running without sudo, or use --global flag
  • "Skills already installed" → Remove existing skills first with npx skills remove --global

Plugin List

Plugin Description Source
typescript-lsp TypeScript language server Official
pyright-lsp Python language server Official
context7 Documentation lookup Official
frontend-design UI/UX design assistance Official
learning-output-style Interactive learning mode Official
swift-lsp Swift language support Official
lua-lsp Lua language support Official
code-simplifier Code simplification Official
rust-analyzer-lsp Rust language support Official
claude-md-management Markdown management Official
plannotator Plan annotation tool Community
prd Product Requirements Documents Local Marketplace
ralph PRD to JSON converter Local Marketplace
qmd-knowledge Project knowledge management Local Marketplace
codemap Parallel codebase analysis Local Marketplace
claude-hud Status line with usage monitoring Community
worktrunk Work management Community

Key Marketplace Plugins

codemap - Orchestrates parallel codebase analysis producing 7 structured documents in .planning/codebase/:

  • STACK.md - Technologies, dependencies, configuration
  • INTEGRATIONS.md - 3rd party APIs, databases, auth
  • ARCHITECTURE.md - System patterns, layers, data flow
  • STRUCTURE.md - Directory layout, key locations
  • CONVENTIONS.md - Code style, patterns, error handling
  • TESTING.md - Framework, structure, mocking, coverage
  • CONCERNS.md - Tech debt, bugs, security issues

prd - Generate Product Requirements Documents

ralph - Convert PRDs to JSON for autonomous agent execution

qmd-knowledge - Project-specific knowledge management (guide)

Hooks & Status Line

Configure in ~/.claude/settings.json:

PostToolUse Hooks

Auto-format after file edits:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.(ts|tsx|js|jsx)$'; then biome check --write \"$file_path\"; fi; }"
          },
          {
            "type": "command",
            "command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.go$ ]]; then gofmt -w \"$( jq -r .tool_input.file_path )\"; fi"
          },
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.(md|mdx)$'; then npx prettier --write \"$file_path\"; fi; }"
          },
          {
            "type": "command",
            "command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.py$ ]]; then ruff format \"$( jq -r .tool_input.file_path )\"; fi"
          },
          {
            "type": "command",
            "command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.rs$ ]]; then rustfmt \"$( jq -r .tool_input.file_path )\"; fi"
          },
          {
            "type": "command",
            "command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.sh$ ]]; then shfmt -w \"$( jq -r .tool_input.file_path )\"; fi"
          },
          {
            "type": "command",
            "command": "if [[ \"$( jq -r .tool_input.file_path )\" =~ \\.lua$ ]]; then stylua \"$( jq -r .tool_input.file_path )\"; fi"
          }
        ]
      }
    ]
  }
}

Supported Formatters:

  • biome - TypeScript/JavaScript files (.ts, .tsx, .js, .jsx) - includes linting
  • gofmt - Go files (.go)
  • prettier - Markdown files (.md, .mdx)
  • ruff - Python files (.py) - modern, fast formatter
  • rustfmt - Rust files (.rs)
  • shfmt - Shell scripts (.sh)
  • stylua - Lua files (.lua)

Installation: The setup script (./cli.sh) automatically checks and installs these tools with mise priority:

  • jq - JSON parsing (required)
  • biome - JavaScript/TypeScript formatting
  • gofmt - Go formatting (requires Go installation)
  • prettier - Markdown formatting (used via npx)
  • ruff - Python formatting (installed via mise, pipx, or pip)
  • rustfmt - Rust formatting (installed via mise or rustup)
  • shfmt - Shell script formatting (installed via mise, brew, or go install)
  • stylua - Lua formatting (installed via mise, brew, or cargo)

PreToolUse Hooks

Git Guard Hook

Prevents dangerous git commands from being executed:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bun ~/.claude/hooks/index.ts PreToolUse"
          }
        ]
      }
    ]
  }
}

Blocked commands:

  • git push --force / -f (without lease protection)
  • git reset --hard (destroys uncommitted changes)
  • git clean -fd (removes untracked files)
  • git branch -D (force delete branch)
  • git rebase -i (interactive rebase)
  • git checkout --force / -f (force checkout)
  • git stash drop/clear (removes stashes)
  • And more...

The implementation can be found in configs/claude/hooks/index.ts and configs/claude/hooks/git-guard.ts.

WebSearch Transformer

Transform WebSearch queries:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "WebSearch",
        "hooks": [
          {
            "type": "command",
            "command": "node \"~/.ccs/hooks/websearch-transformer.cjs\"",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

Status Line

Using claude-hud plugin:

{
  "statusLine": {
    "type": "command",
    "command": "bash -c 'node \"$(ls -td ~/.claude/plugins/cache/claude-hud/claude-hud/*/ 2>/dev/null | head -1)dist/index.js\"'"
  }
}
Claude HUD Status Line

Tip: Auto-compact is disabled. Use claude-hud to monitor context usage.

Custom Commands, Agents & Skills

Custom Commands

Located in configs/claude/commands/:

  • /ccs - CCS delegation and profile management
  • /plannotator-review - Interactive code review
  • /ultrathink - Deep thinking mode

Custom Agents

Located in configs/claude/agents/:

  • ai-slop-remover - Remove AI-generated boilerplate and improve code quality
  • code-reviewer - Comprehensive code quality and security review
  • test-generator - Generate meaningful tests with edge case coverage
  • documentation-writer - Create clear, helpful documentation
  • feature-team-coordinator - Coordinate specialized agents for complex workflows

📖 Agent Teams Guide - Learn how to use Agent Teams to coordinate multiple specialized agents for complex tasks like feature development, code review, and documentation.

Skills

Local Marketplace Plugins - Installed by cli.sh from skills/:

  • adr - Architecture Decision Records
  • codemap - Parallel codebase analysis producing structured documentation
  • handoffs - Create handoff plans for continuing work (provides /handoffs command)
  • pickup - Resume work from previous handoff sessions (provides /pickup command)
  • pr-review - Pull request review workflows
  • prd - Generate Product Requirements Documents
  • qmd-knowledge - Project knowledge management
  • ralph - Convert PRDs to JSON for autonomous agent execution
  • slop - AI slop detection and removal
  • tdd - Test-Driven Development workflows

Projects Built with AI

Real-world projects built using these AI tools:

Project Description Tools Used
- Oak Lightweight macOS focus companion for deep work with notch-first UI Ralph + OpenCode + Codex GPT 5.2
- Prosody Mobile app for English speaking rhythm coaching with AI feedback Ralph + OpenCode + GLM + Amp/Codex (review)
- Keybinder macOS app for managing skhd keyboard shortcuts Claude + spec-kit
- SealCode VS Code extension for AI-powered code review Amp + Ralph
- Ralph Autonomous AI agent loop for PRD-driven development TypeScript
- AI Launcher Fast launcher for switching between AI coding assistants TypeScript
- Tiny Coding Agent Minimal coding agent focused on simplicity TypeScript
- dotenv-tui Terminal UI for managing .env files across projects Go + Bubble Tea
- tiny-cloak.nvim Neovim plugin that masks sensitive data in .env files Lua + Neovim
- tiny-term.nvim Minimal terminal plugin for Neovim 0.11+ Lua + Neovim
- Sky Alert Real-time flight monitoring Telegram bot OpenCode + GLM 4.7 + Amp + Codex CLI
- Docklight Minimal, self-hosted web UI for managing a single-node Dokku server Ralph + OpenCode
- Little Writing A handwriting tracing app for kids built with React, react-konva, and Capacitor Claude + spec-kit + GLM 5

📖 Learning Stories - Detailed notes on development approaches, key takeaways, and tools I've tried.

Recommended Community Skills

Official and community-maintained skill collections for specific frameworks:

Framework Skills Repository Description
UI/UX Design Interface Design Comprehensive guide to interface design patterns and best practices for anyone working with UI/UX development.
Expo expo/skills Official Expo skills for React Native development. Includes app creation, building, debugging, EAS updates, and config management workflows.
Next.js vercel-labs/agent-skills Vercel's agent skills for Next.js and React development. Includes project creation, component generation, and deployment workflows.
Andrej Karpathy forrestchang/andrej-karpathy-skills Community skills inspired by Andrej Karpathy's coding principles and practices for AI-focused development workflows.
Humanizer blader/humanizer Removes signs of AI-generated writing from text. Based on Wikipedia's AI writing detection guide, it detects 24 patterns to make text sound more natural and human.
Claude Skills jezweb/claude-skills 97 production-ready skills for Claude Code CLI including Cloudflare, React, AI integrations, and more. Includes context-mate for project analysis and workflow management.
Skills Discovery vercel-labs/skills/find-skills Skill discovery helper. Search and install skills from skills.sh when users ask about capabilities. Uses npx skills find [query].

Installation:

# Install skills using npx skills add
npx skills add expo/skills --global --agent claude-code
npx skills add vercel-labs/agent-skills --global --agent claude-code
npx skills add blader/humanizer --global --agent claude-code
npx skills add jezweb/claude-skills --global --agent claude-code

Configuration Files

All configuration files are located in the configs/claude/ directory:

Local marketplace plugins are in skills/.

Tips & Tricks

  • OpusPlan Mode: Use opusplan mode to plan with Opus and implement with Sonnet, then use Plannotator to review plans
  • Session Management: Disable auto-compact in settings. Monitor context usage with claude-hud. Press Ctrl+C to quit or /clear to reset between coding sessions. Create a plan with /handoffs and resume with /pickup when approaching 90% context limit on big tasks.
  • Git Worktree: Use git worktree with try CLI. For tmux users, use claude-squash to manage sessions efficiently. Use superset.sh to run multiple AI agents in parallel across worktrees
  • Neovim Integration: Check out tiny-nvim for a complete setup with sidekick.nvim or claudecode.nvim
  • Cost Optimization: Use CCS to switch between affordable providers.

🎨 OpenCode (Optional)

OpenAI-powered AI coding assistant. Homepage

Installation & Configuration

Installation

curl -fsSL https://opencode.ai/install | bash

Configuration

Copy configs/opencode/opencode.json to ~/.config/opencode/:

{
  "$schema": "https://opencode.ai/config.json",
  "instructions": ["~/.ai-tools/best-practices.md", "~/.ai-tools/MEMORY.md"],
  "theme": "kanagawa",
  "default_agent": "plan",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "enabled": true
    },
    "qmd": {
      "type": "local",
      "command": ["qmd", "mcp"],
      "enabled": true
    }
  },
  "agent": {
    "build": {
      "permission": {
        "bash": {
          "git push": "ask",
          "qmd": "allow",
          "qmd query": "allow",
          "qmd get": "allow",
          "qmd search": "allow",
          "$HOME/.config/opencode/skill/qmd-knowledge/scripts/record.sh": "allow",
          "$HOME/.claude/skills/qmd-knowledge/scripts/record.sh": "allow"
        }
      }
    }
  },
  "plugin": [
    "@plannotator/opencode@latest",
    "@mohak34/opencode-notifier@latest"
  ],
  "formatter": {
    "biome": {
      "command": ["biome", "check", "--write", "$FILE"],
      "extensions": [".ts", ".tsx", ".js", ".jsx"]
    },
    "gofmt": {
      "command": ["gofmt", "-w", "$FILE"],
      "extensions": [".go"]
    },
    "prettier": {
      "command": ["npx", "prettier", "--write", "$FILE"],
      "extensions": [".md", ".mdx"]
    },
    "ruff": {
      "command": ["ruff", "format", "$FILE"],
      "extensions": [".py"]
    },
    "rustfmt": {
      "command": ["rustfmt", "$FILE"],
      "extensions": [".rs"]
    },
    "shfmt": {
      "command": ["shfmt", "-w", "$FILE"],
      "extensions": [".sh"]
    },
    "stylua": {
      "command": ["stylua", "$FILE"],
      "extensions": [".lua"]
    }
  }
}

Formatters: OpenCode automatically formats code after edits using:

  • biome for TypeScript/JavaScript files (.ts, .tsx, .js, .jsx)
  • gofmt for Go files (.go)
  • prettier for Markdown files (.md, .mdx)
  • ruff for Python files (.py)
  • rustfmt for Rust files (.rs)
  • shfmt for shell scripts (.sh)
  • stylua for Lua files (.lua)

Similar to Claude Code's PostToolUse hooks, formatters run automatically after write/edit operations.

Plugins

OpenCode supports community plugins that enhance functionality:

Plugins are automatically installed on next OpenCode launch. Configure notification behavior via ~/.config/opencode/opencode-notifier.json if desired.

Custom Agents

Located in configs/opencode/agent/:

  • ai-slop-remover - Remove AI-generated boilerplate
  • docs-writer - Generate documentation
  • review - Code review
  • security-audit - Security auditing

Custom Commands

Located in configs/opencode/command/:

  • plannotator-review - Interactive code review
  • simplify - Simplify over-engineered code for clarity and maintainability
  • batch - Run multiple tasks in parallel as worker tasks

🎯 Amp (Optional)

AI coding assistant by Modular. Homepage

Installation & Configuration

Installation

curl -fsSL https://ampcode.com/install.sh | bash

Configuration

Copy configs/amp/settings.json to ~/.config/amp/:

{
  "amp.dangerouslyAllowAll": true,
  "amp.experimental.autoHandoff": { "context": 90 },
  "amp.mcpServers": {
    "context7": {
      "url": "https://mcp.context7.com/mcp"
    },
    "chrome-devtools": {
      "command": "npx",
      "args": ["chrome-devtools-mcp@latest"]
    },
    "backlog": {
      "command": "backlog",
      "args": ["mcp", "start"]
    },
    "qmd": {
      "command": "qmd",
      "args": ["mcp"]
    }
  }
}

See configs/amp/AGENTS.md for agent guidelines.

Skills

Skill Description
plannotator-review Interactive code review via Plannotator UI

🔄 CCS - Claude Code Switch (Optional)

Universal AI profile manager for Claude Code. Homepage | Documentation

Installation & Configuration

Installation

npm install -g @kaitranntt/ccs

What It Does

CCS lets you run Claude, Gemini, GLM, and any Anthropic-compatible API - concurrently, without conflicts.

Three Main Capabilities:

  1. Multiple Claude Accounts - Run work + personal Claude subscriptions simultaneously
  2. OAuth Providers - Gemini, Codex, Antigravity, GitHub Copilot (zero API keys needed)
  3. API Profiles - GLM, Kimi, OpenRouter, or any Anthropic-compatible API

Quick Start

  1. Open Dashboard:

    ccs config
# Opens http://localhost:3000

  2. Configure Your Accounts via the visual dashboard:

    • Claude Accounts (work, personal, client)
    • OAuth Providers (one-click auth)
    • API Profiles (configure with your keys)
    • Health Monitor (real-time status)

  3. Start Using:

    ccs           # Default Claude session
ccs gemini    # Gemini (OAuth)
ccs codex     # OpenAI Codex (OAuth)
ccs glm       # GLM (API key)
ccs ollama    # Local Ollama

Configuration

CCS auto-creates config on install. Dashboard is the recommended way to manage settings.

Config location: ~/.ccs/config.yaml

See configs/ccs/config.yaml for example configuration.

🤖 OpenAI Codex CLI (Optional)

OpenAI's command-line coding assistant. Homepage

Installation & Configuration

Installation

npm install -g @openai/codex

Configuration

Located in configs/codex/:

Usage

# Start Codex CLI
codex

# Use with Ollama (local models)
codex --oss

# Use with a specific task
codex "Explain this code"

🔷 Google Gemini CLI (Optional)

Google's AI agent that brings the power of Gemini directly into your terminal. Homepage

Installation & Configuration

Installation

npm install -g @google/gemini-cli

Or using Homebrew (macOS/Linux):

brew install gemini-cli

Authentication

Gemini CLI supports multiple authentication methods:

Option 1: Login with Google (OAuth)

gemini
# Follow the browser authentication flow

Option 2: Gemini API Key

export GEMINI_API_KEY="YOUR_API_KEY"
gemini

Get your API key from Google AI Studio.

Configuration

Located in configs/gemini/:

  • settings.json - Main configuration with MCP servers and experimental features
  • GEMINI.md - Agent guidelines
  • AGENTS.md - Additional agent guidelines
  • agents/ - Custom agent definitions (.md format with YAML frontmatter)
    • ai-slop-remover.md - Clean up AI-generated code patterns
    • docs-writer.md - Generate comprehensive documentation
    • review.md - Code review with best practices
    • security-audit.md - Security vulnerability assessment
  • commands/ - Custom slash commands (.toml format)
    • ultrathink.toml - Deep thinking mode

Key Features

  • 🆓 Free tier: 60 requests/min and 1,000 requests/day with personal Google account
  • 🧠 Powerful models: Access to Gemini 2.5 Flash and Pro with 1M token context window
  • 🔧 Built-in tools: Google Search grounding, file operations, shell commands
  • 🔌 MCP support: Extensible via Model Context Protocol
  • 💻 Terminal-first: Designed for command-line developers

Usage

# Start Gemini CLI
gemini

# Include multiple directories
gemini --include-directories ../lib,../docs

# Use specific model
gemini -m gemini-2.5-flash

# Non-interactive mode for scripts
gemini -p "Explain the architecture of this codebase"

Custom Commands

Custom commands are stored in ~/.gemini/commands/ as TOML files. Example:

# Run the ultrathink command
/ultrathink What is the best approach to optimize this database query?

MCP Servers

Configure MCP servers in ~/.gemini/settings.json to extend functionality:

{
  "mcpServers": {
    "context7": {
      "url": "https://mcp.context7.com/mcp"
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "qmd": {
      "command": "qmd",
      "args": ["mcp"]
    }
  },
  "experimental": {
    "enableAgents": true
  }
}

Note: Custom agents in ~/.gemini/agents/ are automatically discovered when experimental.enableAgents is set to true.

🎯 Kilo CLI (Optional)

AI coding assistant built on top of OpenCode with powerful productivity features. Homepage

Installation & Configuration

Installation

npm install -g @kilocode/cli

Kilo provides both kilo and kilocode commands.

Configuration

Kilo CLI uses its own configuration directory at ~/.config/kilo/:

  • config.json - Main configuration with permissions and settings

Configuration is managed through:

  1. /connect command for provider setup (interactive)
  2. Config files directly at ~/.config/kilo/config.json
  3. kilo auth for credential management

Key Features

  • 🚀 Built on OpenCode: Full compatibility with OpenCode configuration and plugins
  • 🤖 300+ AI Models: Access to Claude, GPT, Gemini, DeepSeek, Llama, and more
  • 🥔 Giga Potato Model: Free stealth model optimized for agentic programming with vision support
  • 🔌 Plugin ecosystem: Compatible with OpenCode plugins
  • 📝 Custom agents: Same agent system as OpenCode
  • 🎨 Terminal UI: Enhanced terminal interface for productivity

Usage

# Start Kilo CLI
kilo

# Or use the kilocode alias
kilocode

# Use with specific model
kilo --model kilo/giga-potato

# Non-interactive mode
kilo run "Refactor this component to use hooks"

🥧 Pi (Optional)

AI coding agent built for agentic coding workflows. Homepage

Installation & Configuration

Installation

curl -fsSL https://pi.dev/install.sh | sh

Configuration

Pi uses ~/.pi/settings.json for global user settings and .pi/settings.json in project roots for project-level configuration.

Located in configs/pi/:

Installing Pi Packages

Pi has its own package ecosystem. Install packages with:

pi install pi-flow-enforcer
pi install pi-agent-pack

Then register them in .pi/settings.json:

{
  "packages": ["pi-flow-enforcer", "pi-agent-pack"]
}

Usage

# Start Pi
pi

# Run a task non-interactively
pi "Refactor this function to be more readable"

🐙 GitHub Copilot CLI (Optional)

GitHub Copilot in the terminal — agentic coding assistant that brings AI capabilities directly to your command line. Best Practices | Docs

Installation & Configuration

Prerequisites

Requires an active GitHub Copilot subscription and Node.js/npm.

Installation

npm install -g @github/copilot

Configuration

Copilot CLI configs are stored in configs/copilot/ and installed to the official global paths under ~/.copilot/.

  • AGENTS.md - Agent guidelines and best practices, installed to ~/.copilot/copilot-instructions.md
  • mcp-config.json - MCP server configuration, installed to ~/.copilot/mcp-config.json

Usage

# Start a Copilot CLI session
copilot

# Use plan mode for complex tasks (or press Shift+Tab to toggle)
/plan Add OAuth2 authentication with Google and GitHub providers

# Delegate tangential tasks to the cloud agent
/delegate Update documentation for the new API endpoints

# Select model based on task complexity
/model

# Work across multiple repositories
/add-dir /path/to/other-repo

🖱️ Cursor Agent CLI (Optional)

Cursor's background agent CLI — run AI-powered coding tasks directly from your terminal. Docs

Installation & Configuration

Prerequisites

Requires the Cursor desktop application to be installed.

Installation

The cursor CLI is bundled with the Cursor desktop app. After installing Cursor, add it to your PATH via the Command Palette:

Shell Command: Install 'cursor' command in PATH

Configuration

Cursor Agent CLI configs are stored in configs/cursor/ and installed to ~/.cursor/rules/.

  • AGENTS.md - Agent guidelines and best practices, installed to ~/.cursor/rules/general.mdc

Usage

# Open a project in Cursor
cursor .

# Open a specific file
cursor /path/to/file

# Check the CLI version
cursor --version

🔄 AI Launcher (Optional)

Fast launcher for switching between AI coding assistants. Homepage

Installation & Configuration

Installation

curl -fsSL https://raw.githubusercontent.com/jellydn/ai-launcher/main/install.sh | sh

Configuration

Copy configs/ai-launcher/config.json to ~/.config/ai-launcher/:

Tools:

  • claude / c - Claude CLI
  • opencode / o, oc - OpenCode
  • amp / a - Amp

Templates:

  • review - Code review
  • commit / commit-zen - Commit messages
  • ac / commit-atomic - Atomic commits
  • pr / draft-pr - Pull requests
  • types - Type safety
  • test - Tests
  • docs - Documentation
  • simplify - Code simplification

🛠️ Companion Tools

Additional Tools & Integrations

Plannotator

Plannotator - Annotate plans outside the terminal for better collaboration. (GitHub)

Claude-Mem

⚠️ DEPRECATED - Use qmd Knowledge Management instead.

qmd Knowledge Skill

qmd Knowledge Skill is an experimental memory/context management system:

  • No repository pollution (external storage)
  • AI-powered semantic search
  • Multi-project support
  • Simple & reliable

See GitHub Issue #11 for details.

Claude HUD

Claude HUD - Status line monitoring for context usage, tools, agents, and todos.

# Inside Claude Code
/claude-hud:setup

Try

Try - Fresh directories for every vibe. (Interactive Demo)

Claude Squad

Claude Squad - Manage multiple AI agents in separate workspaces with isolated git worktrees.

Spec Kit

Spec Kit - Toolkit for Spec-Driven Development. (GitHub)

Backlog.md

Backlog.md - Markdown-native task manager and Kanban visualizer. (npm)

Agent Browser

agent-browser - Headless browser automation CLI for AI agents.

npx skills add vercel-labs/agent-browser

Dev Browser

Dev Browser - Browser automation plugin with persistent page state for Claude Code.

/plugin marketplace add sawyerhood/dev-browser
/plugin install dev-browser@sawyerhood/dev-browser

📚 Best Practices

Setup includes configs/best-practices.md with comprehensive software development guidelines:

  • Kent Beck's "Tidy First?" principles
  • Kent C. Dodds' programming wisdom
  • Testing Trophy approach
  • Performance optimization patterns

Copy the file to your preferred location and reference it in your AI tools.

📖 Resources

👤 Author

Dung Huynh

⭐ Show your support

Give a ⭐️ if this project helped you!

ko-fi

📝 Contributing

Contributions, issues and feature requests are welcome! See CONTRIBUTING.md.

Made with ❤️ by Dung Huynh

Reviews (0)

No results found