Welcome to my-ai-tools 👋

Comprehensive configuration management for AI coding tools - Replicate my complete setup for Claude Code, OpenCode, Amp, Kilo CLI, Codex, Devin CLI, Kimi Code, Gemini CLI, Antigravity CLI, Pi, Oh My Pi, GitHub Copilot CLI, Cursor Agent CLI, Factory Droid, Cline, Grok CLI, MiMo-Code, Qoder CLI, Kiro CLI, Hunk, Codiff, ctx, Open Code Review, CCS, and Reasonix 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, Devin, Kimi Code, Gemini, Antigravity, Grok, MiMo-Code, Qoder CLI, Kiro CLI, Hunk, Codiff, ctx, Open Code Review, Reasonix, and more
• 🔌 MCP Server integration - Context7, Sequential-thinking, qmd, codebase-memory-mcp, agentmemory, sem, ctx
• 🎯 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.)

🖥️ Devin CLI (Optional)

Cognition AI's autonomous coding agent with deep cloud integration. Homepage | Docs

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

./cli.sh

{
    "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": []
        },
        "react-grab-mcp": {
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"]
        },
        "logpilot": {
            "command": "logpilot",
            "args": ["mcp-server"]
        },
        "agentmemory": {
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        },
        "sem": {
            "command": "sem-mcp",
            "args": []
        },
        "ctx": {
            "command": "ctx",
            "args": ["mcp", "serve"]
        },
        "codebase-memory-mcp": {
            "command": "codebase-memory-mcp",
            "args": []
        }
    }
}

# Start Devin CLI
devin

# Run with a specific task
devin -- "check out this code and suggest a feasible, helpful feature"

⭐ Top 5 Skills

The most-used skills across Claude Code, OpenCode, and other AI tools:

🧭 Fusion Orchestration

Inspired by opencode-fusion and complementary evidence-gating ideas from Gentle AI, the orchestrating-fusion skill separates senior planning and review from lower-cost mechanical implementation. The installer provides native fusion-lead and fusion-executor roles for active tools and shares the portable workflow with every assistant through ~/.agents/skills/.

The lead hands off exact skill paths plus OBJECTIVE / FILES / INTERFACES / CONSTRAINTS / VERIFICATION. The executor returns an evidence envelope covering changes, verification, skills loaded, risks, questions, and key learnings. The lead reads artifacts back, permits one targeted correction, and stops rather than entering an unbounded fix loop. Durable PRDs or plans remain opt-in when they materially reduce ambiguity.

🔌 MCP Servers & Plugins Overview

📋 MCP Server Details

🎬 Demo

📋 Prerequisites

All Platforms

• Bash 3.0+ - Shell interpreter for cli.sh and generate.sh (the scripts use bash-only syntax — process substitution, arrays, pattern-parameter expansion — that sh/dash cannot parse; the entry-point scripts source lib/require_bash.sh which auto-relaunches under bash if invoked via sh/dash — see Shell Interpreter below)
• 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:

bash 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

# Non-interactive mode (auto-approve, only processes your active tools)
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --yes

# One-step Gemini→Antigravity CLI migration
curl -fsSL https://ai-tools.itman.fyi/install.sh | bash -s -- --migrate-gemini

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
• -y / --yes - Non-interactive mode; only installs/configures your active tool set (amp, codex, ctx, cursor, kilo, opencode, open_code_review, pi, omp, antigravity, ai-switcher, claude, reasonix). Shared infra (plugins, skills, global tools) still installed. Auto-activated in CI/piped input.
• --migrate-gemini - One-step Gemini→Antigravity CLI migration

🔄 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] [-y|--yes] [--migrate-gemini]

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.

🤖 Chat with the repo

The landing page includes a repository assistant that answers questions from the indexed README, docs, configs, and scripts.

To run it locally:

cp .env.example .env
# Add OPENAI_API_KEY, OPENAI_BASE_URL, OPENAI_MODEL, and OPENAI_EMBEDDING_MODEL to .env
npm install
npm run index          # build data/index.json (server mode)
npm run index:browser  # build public/index-browser.json (browser mode)
source .env            # load OPENAI_BASE_URL for server mode
npm run dev            # serve http://localhost:3000

The assistant only answers from the retrieved repository excerpts, cites the source file paths, and says "This is not documented in the repository." when the context is insufficient.

The landing page also has a browser mode that runs the embedding and an instruction-tuned model (Qwen2.5-Coder-0.5B-Instruct) in the browser via WebGPU. Browser mode downloads the ~9 MB index and the ~300 MB model on the user's device.

🐚 Shell Interpreter

cli.sh and generate.sh use bash-only syntax (process substitution, arrays, pattern-parameter expansion) and require bash. Both scripts source lib/require_bash.sh as their first non-shebang line; that shim is intentionally POSIX-compatible so sh/dash can source it and transparently re-launch the script under bash before lib/common.sh is reached. Prefer one of these invocations for clarity:

./cli.sh                # Uses the #!/bin/bash shebang (recommended)
bash cli.sh             # Explicit bash
bash generate.sh        # Explicit bash for the reverse-sync script

If bash is not on PATH, the guard falls back to a clear error: Error: cli.sh requires bash, but bash was not found in PATH. See lib/require_bash.sh for the canonical guard implementation.

🪟 Windows Installation

The installer supports Windows via PowerShell or Git Bash.

Prerequisites for Windows

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

2. 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:

```powershell

```

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
• agentmemory - "Persistent memory" per the tool's branding; we use it session-only (qmd is the durable KB; see ~/.ai-tools/MEMORY.md)
• fff - Fast file search with built-in memory for AI agents
• react-grab-mcp - React component extraction and analysis
• logpilot - AI-powered log analysis and tmux session monitoring

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"]
        },
        "agentmemory": {
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        },
        "fff": {
            "type": "stdio",
            "command": "fff-mcp",
            "args": []
        },
        "react-grab-mcp": {
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"]
        },
        "logpilot": {
            "command": "logpilot",
            "args": ["mcp-server"]
        }
    }
}

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 agentmemory -- npx -y @agentmemory/mcp
claude mcp add --scope user --transport stdio fff -- fff-mcp  # Requires: curl -fsSL https://dmtrkovalenko.dev/install-fff-mcp.sh | bash
claude mcp add --scope user --transport stdio logpilot -- logpilot mcp-server  # Requires: cargo install logpilot
claude mcp add --scope user --transport stdio sem -- sem-mcp  # Requires: cargo install --git https://github.com/Ataraxy-Labs/sem sem-mcp

Auto-Install: ./cli.sh automatically installs Rust via rustup when these cargo-dependent MCP servers are selected, so you don't need to install Rust manually beforehand (manual claude mcp add still requires a pre-installed Rust toolchain).

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

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

claude plugin marketplace add JuliusBrussee/caveman
claude plugin install caveman@caveman

# 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, code-quality-review, commit-atomic, draft-pull-request, docs-update, llm-wiki, plannotator-setup-goal, portless-local, security-audit, tmux, blindspot-pass, implementation-logger, quiz-me, spec-interview, capability-experiments, code-review, context-discovery, doc-search, git-context, orchestrating-fusion
# 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

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
• /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
• code-review - Two-axis diff review (Conventions + Intent) with parallel sub-agents — checks bash idioms, Tidy First practices, and whether the change does what it claims
• codemap - Parallel codebase analysis producing structured documentation
• commit-atomic - Atomic commits by logically grouping changes with commitizen convention (no git add -A)
• draft-pull-request - Create draft pull requests using gh CLI with what/why/how template
• handoffs - Create handoff plans for continuing work (provides /handoffs command)
• llm-wiki - Build and maintain a persistent, compounding knowledge wiki from raw sources (Karpathy's LLM Wiki pattern)
• pickup - Resume work from previous handoff sessions (provides /pickup command)
• plannotator-setup-goal - Turn an idea into a structured goal package via Plannotator-gated discovery, fact sheet, and plan
• docs-update - Automated documentation synchronization with code changes (Mintlify, Docusaurus, GitBook, Fumadocs, etc.)
• portless-local - Named .localhost URLs for local development - replaces port numbers with stable URLs
• 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
• security-audit - Structured security audit workflow using OWASP Top 10, ASVS, and DevSecOps controls
• slop - AI slop detection and removal
• tdd - Test-Driven Development workflows
• code-quality-review - Extremely strict maintainability and structural code quality reviews
• tmux - Remote control tmux sessions for interactive CLIs (python, node, gdb, etc.)

Projects Built with AI

Real-world projects built using these AI tools:

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

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 factory-ai/factory-plugins --skill no-use-effect --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-with-docs --global --agent claude-code
npx skills add mattpocock/skills --skill improve-codebase-architecture --global --agent claude-code
npx skills add privatenumber/mac-ocr --skill mac-ocr --global --agent claude-code
npx skills add mitsuhiko/agent-stuff --global --agent claude-code
npx skills add github/gh-stack --global --agent claude-code
npx skills add openclaw/agent-skills --skill autoreview --global --agent claude-code
npx skills add modem-dev/hunk --skill hunk-review --global --agent claude-code
npx skills add av/facts --global --agent claude-code
npx skills add GoogleChrome/modern-web-guidance --skill modern-web-guidance --global --agent claude-code
npx skills add openai/codex --skill babysit-pr --global --agent claude-code
npx skills add mvanhorn/last30days-skill --global --agent claude-code
npx skills add shadcn/improve --global --agent claude-code
npx skills add Gentleman-Programming/engram --skill engram-memory --global --agent claude-code
npx skills add ctxrs/ctx --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
• CLAUDE.md - Token-efficient global instructions with conditional, on-demand guidance
• 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
• Efficient Model Routing: The managed defaults use Sonnet at medium effort for daily work and an Opus advisor for difficult decisions. Run /advisor or /effort to override them when a task needs a different trade-off.
• Token-Efficient Context: The global CLAUDE.md keeps supplemental guidance conditional instead of using eager @ imports. Keep prompts narrowly scoped, inspect loaded context with /context, limit shell output, and use /clear between unrelated tasks.
• Session Management: Monitor context usage with claude-hud. Create a plan with /handoffs and resume with /pickup when approaching the 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.
• OpenRouter Provider: To route Claude Code through OpenRouter instead of Anthropic directly, add these to ~/.claude/settings.json under "env": json { "env": { "ANTHROPIC_BASE_URL": "https://openrouter.ai/api", "ANTHROPIC_API_KEY": "your-openrouter-api-key", "ANTHROPIC_DEFAULT_OPUS_MODEL": "openrouter/owl-alpha", "ANTHROPIC_DEFAULT_SONNET_MODEL": "openrouter/owl-alpha", "ANTHROPIC_DEFAULT_HAIKU_MODEL": "openrouter/owl-alpha" } } This repo's configs/claude/settings.json intentionally does not hardcode provider credentials, so you can choose your preferred provider via environment variables. See OpenRouter free models for no-cost options.

🎨 OpenCode (Optional)

OpenAI-powered AI coding assistant. Homepage

OpenCode 2 is available as a beta alongside OpenCode 1. It installs as the separate opencode2 command and reads the same global configuration directory, ~/.config/opencode/. Existing V1 configuration is translated in memory, but V1 plugins do not work with V2; keep OpenCode 1 available until any plugins you rely on have been ported. See the OpenCode 2 migration guide.

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

npm install -g @opencode-ai/cli@next
# Or with Bun (the beta package needs its native postinstall trusted):
bun install -g --trust @opencode-ai/cli@next
# Or with pnpm (allow the native postinstall explicitly):
pnpm add -g --allow-build=@opencode-ai/cli @opencode-ai/cli@next
# Or with Yarn:
yarn global add @opencode-ai/cli@next

opencode2

{
    "$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
        },
        "fff": {
            "type": "local",
            "command": ["fff-mcp"],
            "enabled": true
        },
        "sequential-thinking": {
            "type": "local",
            "command": [
                "npx",
                "-y",
                "@modelcontextprotocol/server-sequential-thinking"
            ],
            "enabled": true
        },
        "react-grab-mcp": {
            "type": "local",
            "command": ["npx", "-y", "@react-grab/mcp", "--stdio"],
            "enabled": true
        },
        "logpilot": {
            "type": "local",
            "command": ["logpilot", "mcp-server"],
            "enabled": true
        },
        "agentmemory": {
            "type": "local",
            "command": ["npx", "-y", "@agentmemory/mcp"],
            "enabled": true
        }
    },
    "agent": {
        "build": {
            "permission": {
                "bash": {
                    "git push": "ask",
                    "qmd": "allow",
                    "qmd query": "allow",
                    "qmd get": "allow",
                    "qmd search": "allow",
                    "$HOME/.config/opencode/skills/qmd-knowledge/scripts/record.sh": "allow",
                    "$HOME/.claude/skills/qmd-knowledge/scripts/record.sh": "allow"
                }
            }
        }
    },
    "plugin": ["@plannotator/opencode@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"]
        }
    }
}

🚀 Command Code (Optional)

AI coding assistant that continuously learns your taste of writing code. Homepage

npm install -g command-code

./cli.sh

{
    "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": {
            "command": "fff-mcp",
            "args": []
        },
        "react-grab-mcp": {
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"]
        },
        "logpilot": {
            "command": "logpilot",
            "args": ["mcp-server"]
        },
        "agentmemory": {
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        }
    }
}

Located in @configs/commandcode/agents/:

- `ai-slop-remover` - Remove AI-generated boilerplate
- `review` - Code review

### ⌨️ Custom Commands

Located in @configs/commandcode/commands/:

- `simplify` - Simplify over-engineered code
- `pr-review` - Pull request review workflows

### 📖 Agent Guidelines

Installed to `~/.commandcode/AGENTS.md` with instructions for:

- Session management with tmux
- Using fff MCP for file search
- Following best practices from `~/.ai-tools/best-practices.md`
- qmd knowledge management integration
- Git safety guidelines

</details>

---

## 🎯 Amp (Optional)

AI coding assistant by Modular. [Homepage](https://ampcode.com)

<details>
<summary><strong>Installation & Configuration</strong></summary>

### Installation

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

{
    "amp.dangerouslyAllowAll": true,
    "amp.experimental.autoHandoff": { "context": 90 },
    "amp.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": []
        },
        "react-grab-mcp": {
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"]
        },
        "logpilot": {
            "command": "logpilot",
            "args": ["mcp-server"]
        },
        "agentmemory": {
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        }
    },
    "amp.terminal.theme": "kanagawa"
}

🔄 CCS - Claude Code Switch (Optional)

Universal AI profile manager for Claude Code. Homepage | Documentation

npm install -g @kaitranntt/ccs

🤖 OpenAI Codex CLI (Optional)

OpenAI's command-line coding assistant. Homepage

npm install -g @openai/codex

[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" ]

[mcp_servers.logpilot]
command = "logpilot"
args = ["mcp-server"]

[mcp_servers.node_repl]
args = []
command = "/Applications/Codex.app/Contents/Resources/node_repl"
startup_timeout_sec = 120

[mcp_servers.node_repl.env]
CODEX_HOME = "$HOME/.codex"
NODE_REPL_NODE_PATH = "/Applications/Codex.app/Contents/Resources/node"

# Start Codex CLI
codex

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

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

🔷 Google Gemini CLI (Deprecated for Google One / unpaid tiers)

⚠️ DEPRECATION NOTICE — June 18, 2026 Gemini CLI will stop serving requests to Google One and unpaid (free) tiers on June 18, 2026. API-key-based workflows are not affected.

👉 Migrate now: Antigravity CLI | Migration guide 👉 This repo's Antigravity setup: see the Antigravity CLI section below.

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

Archival note: This repository still keeps Gemini CLI configs for existing installations, API-key workflows, and migration/export compatibility. The section is maintained for reference but new users should use Antigravity CLI instead.

npm install -g @google/gemini-cli

brew install gemini-cli

gemini
# Follow the browser authentication flow

export GEMINI_API_KEY="YOUR_API_KEY"
gemini

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

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

{
    "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": []
        },
        "react-grab-mcp": {
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"]
        },
        "logpilot": {
            "command": "logpilot",
            "args": ["mcp-server"]
        },
        "agentmemory": {
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        }
    },
    "experimental": {
        "enableAgents": true
    }
}

🛸 Antigravity CLI (Optional)

Google's Antigravity CLI for terminal-first agent workflows. This repository installs Antigravity as a first-class tool and stages migrated Gemini CLI configuration under ~/.gemini/antigravity-cli/. Antigravity is the migration target for Google One and unpaid-tier Gemini CLI users.

# Mac/Linux
curl -fsSL https://antigravity.google/cli/install.sh | bash

# Windows PowerShell
irm https://antigravity.google/cli/install.ps1 | iex

./cli.sh

agy plugin import gemini

# Start Antigravity CLI
agy

# Manage plugins, MCP, skills, and settings from inside the TUI
/mcp
/skills
/config

ccs agy

🎯 Kilo CLI (Optional)

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

npm install -g @kilocode/cli

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

🌙 Kimi Code (Optional)

Moonshot AI's terminal-native coding agent. Homepage

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

# Start Kimi Code
kimi

🥧 Pi (Optional)

AI coding agent built for agentic coding workflows. Homepage

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

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

{
    "packages": [
        {
            "source": "npm:@plannotator/pi-extension",
            "skills": []
        },
        "https://github.com/davebcn87/pi-autoresearch",
        "npm:@ff-labs/pi-fff",
        "npm:pi-mcp-adapter",
        "npm:pi-simplify",
        "npm:pi-btw",
        "npm:pi-code-previews",
        "npm:pi-codex-goal",
        "npm:pi-commandcode-provider",
        "npm:pi-footer",
        "npm:pi-tps-meter",
        "npm:@juicesharp/rpiv-advisor",
        "npm:pi-web-access",
        "npm:pi-clinepass-provider",
        "npm:@juicesharp/rpiv-ask-user-question",
        "npm:@yofriadi/pi-antigravity-oauth",
        "npm:@juicesharp/rpiv-todo",
        "npm:pi-qwencloud-provider",
        "npm:pi-cursor-sdk"
    ]
}

npm install -g pi-antigravity-rotator
pi-antigravity-rotator login
pi-antigravity-rotator start

# 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

npm install -g @github/copilot

{
    "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"]
        },
        "react-grab-mcp": {
            "type": "local",
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"],
            "env": {},
            "tools": ["*"]
        },
        "logpilot": {
            "type": "local",
            "command": "logpilot",
            "args": ["mcp-server"]
        },
        "agentmemory": {
            "type": "local",
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        }
    }
}

# 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

Shell Command: Install 'cursor' command in PATH

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

# Open a project in Cursor
cursor .

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

# Check the CLI version
cursor --version

⚡ Conductor (Optional)

Orchestrate parallel AI coding agents (Claude Code, Codex, Cursor, OpenCode) in isolated workspaces. Docs

brew install conductorbuild/tap/conductor

"$schema" = "https://conductor.build/schemas/settings.repo.schema.json"

[scripts]
setup = "prek install"

"$schema" = "https://conductor.build/schemas/settings.schema.json"
claude_provider = "custom"
enterprise_data_privacy = true

[git]
archive_on_merge = true
branch_prefix_type = "github_username"
delete_branch_on_archive = false

[models]
default = "auto"
default_plan_mode = true
review = "opencode:clinepass/cline-pass/glm-5.2"
visible_provider_models = "{\"claude\":[],\"codex\":[],\"cursor\":[],\"opencode\":[\"opencode:openrouter/tencent/hy3:free\",\"opencode:opencode/deepseek-v4-flash-free\",\"opencode:opencode/hy3-free\",\"opencode:clinepass/cline-pass/deepseek-v4-flash\",\"opencode:clinepass/cline-pass/deepseek-v4-pro\",\"opencode:clinepass/cline-pass/glm-5.2\",\"opencode:alibaba-token-plan/qwen3.8-max-preview\"],\"pi\":[]}"

[models.codex]
default_thinking_level = "high"
personality = "pragmatic"
review_thinking_level = "xhigh"

# Open Conductor app
open -a Conductor

# Create a new workspace with a task
conductor start "Implement user authentication"

# List active workspaces
conductor list

# Open workspace in Cursor
conductor open --cursor

🏭 Factory Droid (Optional)

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

npm install -g @factory/cli

cd /path/to/your/project
droid

export FACTORY_API_KEY=your_api_key_here

droid /login

{
    "customModels": [
        {
            "model": "minimax-m2.5:cloud",
            "id": "custom:minimax-m2.5:cloud-0",
            "baseUrl": "http://127.0.0.1:11434/v1",
            "apiKey": "ollama",
            "displayName": "minimax-m2.5:cloud",
            "maxOutputTokens": 128000,
            "provider": "generic-chat-completion-api"
        },
        {
            "model": "glm-4.7",
            "id": "custom:GLM-4.7-[Z.AI-Coding-Plan]-0",
            "baseUrl": "https://api.z.ai/api/coding/paas/v4",
            "displayName": "GLM-4.7 [Z.AI Coding Plan]",
            "maxOutputTokens": 131072,
            "provider": "generic-chat-completion-api"
        }
    ]
}

{
    "mcpServers": {
        "context7": {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@upstash/context7-mcp@latest"]
        },
        "sequential-thinking": {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
        },
        "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"]
        },
        "logpilot": {
            "type": "stdio",
            "command": "logpilot",
            "args": ["mcp-server"]
        },
        "agentmemory": {
            "type": "stdio",
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        }
    }
}

# 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

💻 Cline (Optional)

AI coding assistant that runs in your terminal — built for high-performance agentic coding with support for multiple providers. Homepage | Docs

npm install -g cline

cline
# Follow the browser authentication flow

export FIREWORKS_API_KEY="your_key_here"
export OPENAI_API_KEY="your_key_here"

{
    "mcpServers": {
        "context7": {
            "alwaysAllow": [],
            "url": "https://mcp.context7.com/mcp"
        },
        "sequential-thinking": {
            "alwaysAllow": [],
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
        },
        "qmd": {
            "alwaysAllow": [],
            "command": "qmd",
            "args": ["mcp"]
        },
        "fff": {
            "alwaysAllow": [],
            "command": "fff-mcp",
            "args": []
        },
        "react-grab-mcp": {
            "alwaysAllow": [],
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"]
        },
        "logpilot": {
            "alwaysAllow": [],
            "command": "logpilot",
            "args": ["mcp-server"]
        },
        "agentmemory": {
            "alwaysAllow": [],
            "command": "npx",
            "args": ["-y", "@agentmemory/mcp"]
        }
    }
}

# Start Cline interactive mode
cline

# Run a specific task
cline "Refactor this component to use TypeScript"

# Use with specific model
cline --model accounts/fireworks/routers/kimi-k2p5-turbo

# List available commands
cline --help

🤖 Grok CLI (Optional)

xAI's AI coding assistant for the terminal. Homepage | Docs

npm install -g @xai-official/grok

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

./cli.sh

[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"]

[mcp_servers.logpilot]
command = "logpilot"
args = ["mcp-server"]

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

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

[mcp_servers.ctx]
command = "ctx"
args = ["mcp", "serve"]

[mcp_servers.codebase-memory-mcp]
type = "stdio"
command = "codebase-memory-mcp"

[models]
default = "grok-4.5"
default_reasoning_effort = "high"

[ui]
theme = "auto"
auto_dark_theme = "rosepine-moon"
auto_light_theme = "grokday"

# Start Grok CLI
grok

# Run non-interactively (headless mode)
grok -p "Analyze the test coverage for this project"

# Use with a specific task
grok "Explain the architecture of this codebase"

🏮 MiMo-Code (Optional)

Xiaomi's open-source, terminal-native AI coding assistant with persistent memory, agentic orchestration, and self-improvement capabilities. Forked from OpenCode. Homepage | GitHub

npm install -g @mimo-ai/cli

curl -fsSL https://mimo.xiaomi.com/install | bash

./cli.sh

{
    "$schema": "https://opencode.ai/config.json",
    "mcp": {
        "context7": {
            "enabled": true,
            "type": "remote",
            "url": "https://mcp.context7.com/mcp",
        },
        "qmd": {
            "command": ["qmd", "mcp"],
            "enabled": true,
            "type": "local",
        },
        "fff": {
            "type": "local",
            "command": ["fff-mcp"],
            "enabled": true,
        },
        "sequential-thinking": {
            "type": "local",
            "command": [
                "npx",
                "-y",
                "@modelcontextprotocol/server-sequential-thinking",
            ],
            "enabled": true,
        },
        "react-grab-mcp": {
            "type": "local",
            "command": ["npx", "-y", "@react-grab/mcp", "--stdio"],
            "enabled": true,
        },

        "logpilot": {
            "type": "local",
            "command": ["logpilot", "mcp-server"],
            "enabled": true,
        },
        "agentmemory": {
            "type": "local",
            "command": ["npx", "-y", "@agentmemory/mcp"],
            "enabled": true,
        },
    },
}

# Start MiMo-Code
mimo

# Run non-interactively
mimo -p "Analyze the test coverage for this project"

# Use with a specific task
mimo "Explain the architecture of this codebase"

🚀 herdr (Optional)

Terminal-native agent multiplexer — like tmux but agent-aware. Manage workspaces, tabs, and panes, each running its own shell, agent, server, or log stream, with automatic agent status tracking and a local socket API. Homepage | Docs | GitHub

# Mac/Linux
curl -fsSL https://herdr.dev/install.sh | bash

# Windows PowerShell
irm https://herdr.dev/install.ps1 | iex

./cli.sh

herdr integration install claude    # Claude Code
herdr integration install codex     # OpenAI Codex CLI
herdr integration install copilot   # GitHub Copilot CLI
herdr integration status            # Check installed integrations

# Start herdr
herdr

# List panes in current workspace
herdr pane list

# Split a pane to the right and run a command
herdr pane split 1-2 --direction right --no-focus
herdr pane run 1-3 "npm run dev"

# Wait for an agent to finish
herdr wait agent-status 1-1 --status done --timeout 60000

# Read another pane's output
herdr pane read 1-1 --source recent --lines 50

🧠 Qoder CLI (Optional)

Qoder's agentic coding CLI. Reads AGENTS.md for context, supports MCP servers via qodercli mcp add, and ships TUI slash commands like /init, /memory, /mcp, /status, /effort. Homepage | Docs

# Mac/Linux
curl -fsSL https://qoder.com/install | bash

# Windows PowerShell
irm https://qoder.com/install.ps1 | iex

./cli.sh

{
    "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": [] },
        "react-grab-mcp": {
            "command": "npx",
            "args": ["-y", "@react-grab/mcp", "--stdio"]
        },
        "logpilot": { "command": "logpilot", "args": ["mcp-server"] },
        "agentmemory": { "command": "npx", "args": ["-y", "@agentmemory/mcp"] },
        "sem": { "command": "sem-mcp", "args": [] }
    }
}

# Start Qoder CLI
qodercli

# Non-interactive single prompt
qodercli -p "Explain the architecture of this codebase"

# Print mode for CI / automation
qodercli --print --output-format=json

# Add an MCP server (global)
qodercli mcp add context7 -- npx -y @upstash/context7-mcp@latest

# Inspect current session / model
qodercli status

🥷 Kiro CLI (Optional)

Kiro Dev's AI coding assistant with native MCP support, steering files (AGENTS.md), and ACP (Agent Client Protocol) integration. Ships with /model, /editor, /usage, and custom agents. Homepage | Docs | GitHub

# Mac/Linux
curl -fsSL https://cli.kiro.dev/install | bash

# Windows PowerShell
irm https://kiro.dev/install.ps1 | iex

./cli.sh

# Start Kiro CLI
kiro

# Non-interactive single prompt (headless mode)
kiro --print "Explain the architecture of this codebase"

# Select model
kiro /model

# Add an MCP server (global)
kiro mcp add context7 -- npx -y @upstash/context7-mcp@latest

# Check context usage
kiro /usage

🔍 Hunk (Optional)

Review-first terminal diff viewer for agent-authored changesets, with multi-file navigation, inline agent notes, watch mode, and Git, Jujutsu, and Sapling support. Homepage | Docs | GitHub

# Cross-platform (Node.js 18+)
npm install --global hunkdiff

# macOS (Homebrew core)
brew install hunk

./cli.sh

git config --global core.pager "hunk pager"

hunk diff          # Review the working tree, including untracked files
hunk diff --watch  # Reload as an agent changes the working tree
hunk show          # Review the latest commit
hunk session list  # List live review sessions for agent interaction

🎨 Codiff (Optional)

Beautiful, minimal local diff viewer with LLM-powered walkthroughs. Review Git changes, comment on PRs/MRs inline, and share walkthroughs. GitHub | Homepage

# macOS (Homebrew)
brew install --cask nkzw-tech/tap/codiff

# Then run: Codiff > Install Terminal Helper (for `codiff` CLI command)

./cli.sh

# Launch Codiff
codiff

# Review current repository
codiff .

# Generate LLM walkthrough of the diff
codiff -w

# Review a GitHub PR
codiff pr 75

🔎 ctx (Optional)

Open-source local agent-history search CLI. Indexes your past coding-agent sessions into local SQLite and lets you search, inspect, and cite prior work from the terminal. Homepage | GitHub

curl -fsSL https://ctx.rs/install | sh

./cli.sh

# Initialize local index
ctx setup

# Search prior sessions
ctx search "failed migration"

ctx mcp serve

{
    "command": "ctx",
    "args": ["mcp", "serve"]
}

🔍 Open Code Review (Optional)

AI-powered code review CLI from Alibaba. Reads Git diffs, sends changed files to a configurable LLM, and generates structured review comments with line-level precision. Homepage | GitHub

npm install -g @alibaba-group/open-code-review

./cli.sh

Error: resolve LLM endpoint: no valid LLM endpoint configured

ocr config set llm.url https://api.anthropic.com/v1/messages
ocr config set llm.auth_token your-api-key-here
ocr config set llm.model claude-opus-4-6
ocr config set llm.use_anthropic true

export OCR_LLM_URL=https://api.anthropic.com/v1/messages
export OCR_LLM_TOKEN=your-api-key-here
export OCR_LLM_MODEL=claude-opus-4-6
export OCR_USE_ANTHROPIC=true

# Review all staged, unstaged, and untracked changes
ocr review

# Review branch diff
ocr review --from main --to feature-branch

# Review a specific commit
ocr review --commit abc123

# Preview which files will be reviewed (no LLM calls)
ocr review --preview

# Test LLM connectivity
ocr llm test

# Launch web viewer for review sessions
ocr viewer

# As a skill (works with Claude Code, OpenCode, etc.)
npx skills add alibaba/open-code-review --skill open-code-review

# As a Claude Code plugin
/plugin marketplace add alibaba/open-code-review
/plugin install open-code-review@open-code-review

{
    "rules": [
        {
            "path": "**/*.java",
            "rule": "Check for null safety and resource leak patterns"
        },
        {
            "path": "**/*.{ts,tsx}",
            "rule": "Verify TypeScript strict mode compliance"
        }
    ]
}

🔄 AI Launcher (Optional)

Fast launcher for switching between AI coding assistants. Homepage

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

🛠️ Companion Tools

# Inside Claude Code
/claude-hud:setup

uv tool install claude-monitor
claude-monitor --plan pro

npx skills add vercel-labs/agent-browser

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

npm install -g 9router

brew install --cask stablyai/orca/orca

📚 Best Practices

Setup includes the following shared configuration files installed by ./cli.sh:

Software Development Best Practices — configs/best-practices.md:

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

Agent Memory Guidelines — configs/agent-memory-guidelines.md (→ ~/.ai-tools/agent-memory.md):

• Auto-capture learnings, debugging discoveries, and user preferences as you work
• Persist non-trivial bug fixes immediately for future sessions
• Keep memories concise and actionable — facts and patterns over narrative

Implementation Notes — configs/implementation-notes-guidelines.md (→ ~/.ai-tools/implementation-notes.md):

• Structured workflow for AI agents to capture implementation notes
• Templates and style rules for what to record after each task
• Decision rules for routing knowledge to the right store (qmd / agentmemory / handoffs)

Best practices and memory guidelines are automatically referenced by all 15+ AI tool AGENTS.md configurations installed by this repo; implementation notes are linked from the shared memory workflow.

📖 Resources

• Claude Code Documentation - Official docs
• OpenCode Documentation - Guide with agents and skills
• Antigravity CLI Docs - Official documentation (getting started, commands, features, migration)
• 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
• Modern Web Guidance - Chrome's best practices for modern web development
• xAI CLI - Grok CLI official page
• Grok Build Docs - Getting started and configuration
• MiMo-Code - MiMo-Code repository and documentation
• 9Router - AI router with 60+ providers and 3-tier fallback

👤 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