Getting Started with Moonshot AI's Kimi Code: An Autonomous Coding Agent for Your Terminal

Moonshot AI has officially released its coding tool, Kimi Code. This isn't just another code generator; it is an AI Agent capable of autonomous planning that runs directly in your terminal.

Based on the K2.5 model, it supports multimodal input (images and video) and integrates seamlessly into mainstream editors like VSCode, Cursor, JetBrains, and Zed via the ACP (Agent Client Protocol).

For developers, Kimi Code closes the loop from "reading code" to "executing commands," covering end-to-end tasks from building and debugging to refactoring and testing.

Here is a guide to the core features, installation, and advanced usage of the Kimi Code CLI.

What is Kimi Code CLI?

Kimi Code CLI is an intelligent agent that lives in your terminal. Unlike traditional chatbots, it has operating system execution permissions. It can:

• Read and Edit Code: Directly modify source files instead of just offering suggestions.
• Execute Shell Commands: Run build scripts and test suites.
• Plan Autonomously: When encountering errors, it automatically analyzes logs and attempts fixes, forming an "Execute-Feedback-Correct" loop.

It functions both as a standalone terminal tool and as a backend service plugged into an IDE.

Installation and Environment Configuration

Kimi Code CLI depends on a Python environment (versions 3.12-3.14 are recommended).

Step 1: Prepare the Environment

To avoid messing up your system paths, it is highly recommended to use a sandboxed environment. You can use ServBay to prepare your Python environment.

Open ServBay, go to "Packages", and find and install Python 3.13 (the best compatibility version recommended for Kimi Code).

ServBay will automatically configure the environment, ensuring that your terminal calls this independent Python version with full pip package management capabilities.

Step 2: Install the uv Package Manager

Once you have the Python environment provided by ServBay, you need to install uv. It is an extremely fast Python package manager and the underlying tool recommended by Kimi Code.

Execute in your terminal:

pip install uv

Step 3: Install Kimi Code CLI

Now that the uv command is available, use it to install Kimi Code:

uv tool install --python 3.13 kimi-cli

After installation, verify success:

kimi --version

Initialization and Configuration

Type kimi in your project directory to start the interactive interface.

For first-time use, it is recommended to log in via the /login command. The system will automatically sync available model configurations. If you need to use a specific API Key, you can also manually configure the endpoint and key via /setup.

Project Indexing

When entering a new project, run /init first. This allows Kimi to analyze the project structure and generate an AGENTS.md file. Think of this file as a "Project Manual" for the AI, which significantly improves the accuracy of subsequent tasks.

Core Workflows

The Kimi Code CLI interaction uses a Shell-like hybrid mode. Press Ctrl-X to switch between Agent Mode (Conversation) and Shell Mode (Native Command Execution).

1. Feature Development and Refactoring

In Agent Mode, describe your requirements in natural language. Kimi follows a "Read → Modify → Verify" flow.

Example Prompt:

"Add a pagination feature to the user list page, showing 20 records per page. Style it referencing the existing Button component."

It will automatically search for relevant files, understand the context, modify the code, and maintain consistency with the existing code style.

2. Troubleshooting and Fixing

When encountering errors, you can paste the error log directly or ask Kimi to run test commands.

Example Prompt:

"Run npm test. If there are failed cases, please analyze the cause and fix them."

For complex logic, you can switch to a model that supports "Thinking Mode" (like k2-thinking) via /model. This allows the AI to perform deeper logical deduction before outputting a solution.

3. Automation Tasks

The CLI excels at tedious batch operations:

• "Change all var declarations to const or let in the src directory."
• "Analyze logs in the logs directory and calculate the average API response time."
• "Convert all PNGs in the images directory to JPEG."

Advanced Tips

• @ Path Completion: Type @ in the dialogue to quickly reference files in the project, e.g., "Explain the logic of @src/core/scheduler.py".
• Multimodal Input: Supports pasting images directly from the clipboard. For UI adjustment tasks, a screenshot is often more efficient than a text description.
• YOLO Mode: By default, every file modification and command execution requires user confirmation. If you are running in a Docker container or test environment, you can use the /yolo command to turn on "Bold Mode," skipping all confirmation steps for fully automated execution (Use with caution in production!).

Integration into Editors (IDE)

Kimi Code supports the ACP (Agent Client Protocol), meaning it doesn't just live in the terminal; it can also be integrated into JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm, etc.).

First, get the installation path of Kimi in the terminal:

which kimi
# Copy the output path (e.g., /Users/username/.local/bin/kimi)

Configure AI Assistant

Open the IDE's AI Chat panel (usually requires the AI Assistant plugin), click "Configure ACP agents" in the menu, and add the following configuration:

{
  "agent_servers": {
    "Kimi Code CLI": {
      "command": "/Users/YOUR_USERNAME/.local/bin/kimi", 
      "args": ["acp"],
      "env": {}
    }
  }
}

Note: The command must be the full absolute path obtained in the previous step.

Once saved, you will see "Kimi Code CLI" in the Agent selector of the AI chat.

Summary

Kimi Code doesn't have flashy gimmicks, but it solves real developer problems. You don't need to leave the terminal to let AI write code for you.

Coupled with the stable Python environment provided by ServBay, the installation process is smoother, and the AI tool runs efficiently in an isolated sandbox, avoiding interference with your main system.

Note: This tool is currently in the technical preview stage. It is recommended to try it out on non-production critical paths first.