Welcome to my-ai-tools 👋

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, Factory Droid 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

📋 Prerequisites

All Platforms

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

Windows-Specific

Git for Windows - Required for Git Bash support
- Download: https://git-scm.com/download/win
- Make sure to select "Git from the command line and also from 3rd-party software" during installation
PowerShell 5.1+ - For the PowerShell installer
jq - Will be auto-installed via winget if available, or download from GitHub releases

🚀 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.

🪟 Windows Installation

The installer supports Windows via PowerShell or Git Bash.

Prerequisites for Windows

Git for Windows - Includes Git Bash (required for running shell scripts)
- Download from: https://git-scm.com/download/win
- During installation, choose "Use Git and optional Unix tools from the Command Prompt" to add Git Bash to PATH
jq (JSON processor) - Auto-installed via winget if available
- Manual install: winget install -e --id jqlang.jq

Option 1: PowerShell (Recommended for Windows)

# Run directly from the published URL
irm https://ai-tools.itman.fyi/install.ps1 | iex

# To pass options, download first, then run the local file:
irm https://ai-tools.itman.fyi/install.ps1 -OutFile install.ps1
.\install.ps1 -DryRun

Local execution:

# Clone and run locally
git clone https://github.com/jellydn/my-ai-tools.git
cd my-ai-tools
.\install.ps1

Option 2: Git Bash

# Open Git Bash (from right-click menu or Start menu)
git clone https://github.com/jellydn/my-ai-tools.git
cd my-ai-tools
bash ./cli.sh

Note: If bash is not recognized in PowerShell, add Git to your PATH:
[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Program Files\Git\bin", "User")

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
fff - Fast file search with built-in memory for AI agents
chrome-devtools - Chrome DevTools integration for browser automation
react-grab-mcp - React component extraction and analysis

Manual Setup

For Claude Code

Configuration in ~/.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"]
    },
    "fff": {
      "type": "stdio",
      "command": "fff-mcp",
      "args": []
    }
  }
}

Or 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
claude mcp add --scope user --transport stdio fff -- fff-mcp  # Requires: curl -fsSL https://dmtrkovalenko.dev/install-fff-mcp.sh | bash

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:

Claude Code subscription - Active subscription with plugin support
Plugin marketplace access - Verify marketplace is enabled for your repository
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

claude plugin marketplace add openai/codex-plugin-cc
claude plugin install codex@openai-codex

# 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:

Check npx availability: Ensure Node.js and npx are installed (npx --version)
Use local skills: The setup script automatically falls back to local skills from skills/ folder
Manual installation: Copy skill folders directly to ~/.claude/skills/
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
`codex`	Codex code review & task delegation	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\"'"
  }
}

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]`.
Matt Pocock	mattpocock/skills	Community skills by Matt Pocock. Includes `grill-me` for stress-testing plans via relentless Q&A, and more workflow-enhancing skills for AI-assisted development.
Mitsuhiko	mitsuhiko/agent-stuff	Skills and extensions by Armin Ronacher. Includes tmux session control, GitHub CLI, web browser automation, Sentry integration, mermaid diagrams, and more.
Git Stacked PRs	github/gh-stack	GitHub CLI extension for managing stacked branches and pull requests. Create, push, rebase, sync, and navigate stacks of dependent PRs for incremental code review workflows.

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
npx skills add mattpocock/skills --skill grill-me --global --agent claude-code
npx skills add mitsuhiko/agent-stuff --global --agent claude-code
npx skills add github/gh-stack --global --agent claude-code

Configuration Files

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

settings.json - Main Claude Code settings
mcp-servers.json - MCP server configurations
commands/ - Custom slash commands
agents/ - Custom agent definitions

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
    },
    "chrome-devtools": {
      "type": "local",
      "command": ["npx", "-y", "chrome-devtools-mcp@latest"],
      "enabled": true
    },
    "fff": {
      "type": "local",
      "command": ["fff-mcp"],
      "enabled": true
    },
    "sequential-thinking": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-sequential-thinking"],
      "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:

@plannotator/opencode - Interactive code planning and annotation
@mohak34/opencode-notifier - Sound and system notifications for events (permission requests, completion, errors, questions)

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"]
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "qmd": {
      "command": "qmd",
      "args": ["mcp"]
    },
    "fff": {
      "command": "fff-mcp",
      "args": []
    },
    "react-grab-mcp": {
      "command": "npx",
      "args": ["-y", "@react-grab/mcp", "--stdio"]
    }
  },
  "amp.terminal.theme": "kanagawa"
}

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:

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

Quick Start

Open Dashboard:

ccs config
# Opens http://localhost:3000

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)

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/:

config.toml - Main TOML configuration with MCP servers
AGENTS.md - Agent guidelines

MCP Servers

[mcp_servers.context7]
command = "npx"
args = [ "-y", "@upstash/context7-mcp" ]

[mcp_servers.sequential-thinking]
command = "npx"
args = [ "-y", "@modelcontextprotocol/server-sequential-thinking" ]

[mcp_servers.qmd]
command = "qmd"
args = [ "mcp" ]

[mcp_servers.fff]
command = "fff-mcp"
args = []

[mcp_servers.react-grab-mcp]
command = "npx"
args = [ "-y", "@react-grab/mcp", "--stdio" ]

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"]
    },
    "fff": {
      "command": "fff-mcp",
      "args": []
    }
  },
  "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:

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

MCP Servers

{
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "enabled": true
    },
    "qmd": {
      "type": "local",
      "command": ["qmd", "mcp"],
      "enabled": true
    },
    "fff": {
      "type": "local",
      "command": ["fff-mcp"],
      "enabled": true
    },
    "sequential-thinking": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-sequential-thinking"],
      "enabled": true
    }
  }
}

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/:

settings.json - Global settings with package registrations

Key Settings:

Default Model: accounts/fireworks/routers/kimi-k2p5-turbo (via Fireworks)
Default Provider: fireworks
Default Thinking Level: medium
Theme: dracula
Permission Level: high
Quiet Startup: Enabled (skips changelog on launch)
Hide Thinking Block: Disabled (shows thinking process)

Pi Packages

Pi uses a package-based extension system (not MCP). Install packages with:

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

Then register them in .pi/settings.json:

{
  "packages": [
    "npm:@plannotator/pi-extension",
    "npm:pi-subagents",
    "https://github.com/davebcn87/pi-autoresearch",
    "git:github.com/jellydn/pi-fireworks-provider",
    "npm:pi-hooks",
    "git:github.com/SamuelLHuber/pi-fff",
    "npm:pi-annotate",
    "npm:pi-mcp-adapter",
    "npm:pi-simplify",
    "npm:@devkade/pi-plan",
    "npm:pi-manage-todo-list",
    "npm:pi-btw"
  ]
}

Package Overview:

Package	Description
`@plannotator/pi-extension`	Interactive plan review with visual annotation
`pi-subagents`	Delegate tasks to subagents with chains, parallel execution, and TUI
`pi-autoresearch`	Autonomous experiment loop for optimization targets
`pi-fireworks-provider`	Fireworks AI provider for Kimi and other models
`pi-hooks`	Collection of extensions (checkpoint, lsp, permission, ralph-loop, repeat)
`pi-fff`	FFF-powered fuzzy file and content search
`pi-annotate`	Visual annotation tool with inline note cards
`pi-mcp-adapter`	MCP (Model Context Protocol) adapter for Pi
`pi-simplify`	Reviews changed code for clarity, consistency, and maintainability
`@devkade/pi-plan`	Read-only planning mode with approval-based execution
`pi-manage-todo-list`	GitHub Copilot-style todo list management tool
`pi-btw`	Parallel side conversations with `/btw` command

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

MCP Servers

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

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

🏭 Factory Droid (Optional)

Factory's AI coding agent — end-to-end feature development from your terminal. Homepage | Docs

Installation & Configuration

Installation

npm install -g @factory/cli

After installation, navigate to your project and start the droid CLI:

cd /path/to/your/project
droid

BYOK Setup (Bring Your Own Key)

Factory Droid supports using your own AI provider API keys. See the BYOK documentation for supported providers and configuration.

Set your API key via environment variable:

export FACTORY_API_KEY=your_api_key_here

Or use the interactive login:

droid /login

Configuration

Factory Droid configs are stored in configs/factory/ and installed to ~/.factory/:

AGENTS.md - Global agent guidelines
mcp.json - MCP server configurations
settings.json - Factory Droid settings
droids/ - Optional user-created directory for custom droid definitions

MCP Servers

{
  "mcpServers": {
    "context7": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    },
    "sequential-thinking": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "chrome-devtools": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "chrome-devtools-mcp@latest"]
    },
    "fff": {
      "type": "stdio",
      "command": "fff-mcp",
      "args": []
    },
    "qmd": {
      "type": "stdio",
      "command": "qmd",
      "args": ["mcp"]
    },
    "react-grab-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@react-grab/mcp", "--stdio"]
    }
  }
}

Usage

# Start interactive mode
droid

# Start with an initial prompt
droid "review app.tsx"

# Run non-interactively
droid exec "analyze this file"

# Resume last session
droid --resume

# Check for updates
droid update

🔄 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.

cmux

cmux - Ghostty-based macOS terminal with vertical tabs and notifications for AI coding agents.

Conductor

Conductor - Orchestrate parallel AI coding agents to work on multiple tasks simultaneously.

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

React Tools

For React developers:

React Grab - MCP server for extracting and analyzing React components (@react-grab/mcp)
React Scan - Detect performance issues in your React app automatically

📚 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

Claude Code Documentation - Official docs
OpenCode Documentation - Guide with agents and skills
MCP Servers Directory - Model Context Protocol servers
Context7 Documentation - Library documentation lookup
CCS Documentation - Claude Code Switch
Claude Code Showcase - Community examples
Everything Claude Code - Production configs
Claude Code Best Practice - Best practices and tips for Claude Code
Why I switched to Claude Code 2.0
Llama.cpp Setup with Claude/Codex CLI - Local model setup guide

👤 Author

Dung Huynh

Website: productsway.com
YouTube: IT Man Channel
GitHub: @jellydn

⭐ Show your support

Give a ⭐️ if this project helped you!

📝 Contributing

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

Made with ❤️ by Dung Huynh

Name		Name	Last commit message	Last commit date
Latest commit History 133 Commits
.changeset		.changeset
.claude-plugin		.claude-plugin
.github/workflows		.github/workflows
.planning/codebase		.planning/codebase
configs		configs
docs		docs
lib		lib
skills		skills
tests		tests
.gitignore		.gitignore
.nojekyll		.nojekyll
.pre-commit-config.yaml		.pre-commit-config.yaml
AGENTS.md		AGENTS.md
CNAME		CNAME
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
MEMORY.md		MEMORY.md
README.md		README.md
TESTING.md		TESTING.md
cli.sh		cli.sh
generate.sh		generate.sh
index.html		index.html
install.ps1		install.ps1
install.sh		install.sh
renovate.json		renovate.json

Folders and files

Latest commit

History

Repository files navigation

Welcome to my-ai-tools 👋

✨ Features

🎬 Demo

📋 Prerequisites

All Platforms

Windows-Specific

🚀 Quick Start

One-Line Installer (Recommended)

Manual Installation

🔄 Bidirectional Config Sync

Forward: Install to Home (cli.sh)

Reverse: Generate from Home (generate.sh)

🪟 Windows Installation

Prerequisites for Windows

Option 1: PowerShell (Recommended for Windows)

Option 2: Git Bash

Installation

MCP Servers Setup

Automatic Setup (Recommended)

Manual Setup

For Claude Code

Managing MCP Servers

Knowledge Management

Plugins

Prerequisites

Installation

Troubleshooting

Plugin List

Key Marketplace Plugins

Hooks & Status Line

PostToolUse Hooks

PreToolUse Hooks

Git Guard Hook

WebSearch Transformer

Status Line

Custom Commands, Agents & Skills

Custom Commands

Custom Agents

Skills

Projects Built with AI

Recommended Community Skills

Configuration Files

Tips & Tricks

🎨 OpenCode (Optional)

Installation

Configuration

Plugins

Custom Agents

Custom Commands

🎯 Amp (Optional)

Installation

Configuration

Skills

🔄 CCS - Claude Code Switch (Optional)

Installation

What It Does

Quick Start

Configuration

🤖 OpenAI Codex CLI (Optional)

Installation

Configuration

MCP Servers

Usage

🔷 Google Gemini CLI (Optional)

Installation

Authentication

Configuration

Key Features

Usage

Custom Commands

MCP Servers

🎯 Kilo CLI (Optional)

Installation

Configuration

MCP Servers

Key Features

Forward: Install to Home (`cli.sh`)

Reverse: Generate from Home (`generate.sh`)

Packages