coco
14 KiB
title, source, author, published, created, description, tags
| title | source | author | published | created | description | tags | ||
|---|---|---|---|---|---|---|---|---|
| The Chinese AI Model That Quietly Beat Claude at Its Own Game | https://x.com/k1rallik/status/2047668768050913561 |
|
2026-04-24 | 2026-04-26 | Kimi Code is what I found after asking why my Claude Code felt slow - turns out you can replace the entire model underneath it in 30 seconds... |
|
Kimi Code is what I found after asking why my Claude Code felt slow - turns out you can replace the entire model underneath it in 30 seconds, and almost nobody knows this is even possible.
The Chinese AI that replaces it runs at 100 tokens per second with a context window big enough to swallow your entire codebase. Two lines. That's it.
What Is Kimi Code - And Why Should You Care
Let me save you the Wikipedia version.
Kimi Code is an AI coding agent from Moonshot AI - a Chinese lab that's been quietly shipping some of the most capable models of the last year. You might know their chatbot Kimi, which exploded in popularity earlier this year. Kimi Code is their developer tool - and it's a different beast entirely.
This isn't an autocomplete plugin. This isn't a chat window you tab to when you're stuck.
Kimi Code is a full autonomous agent. It reads your files, understands your project structure, writes and edits code, runs shell commands, searches the web when it needs to - and then checks its own work. You give it a task in plain English and it figures out the rest.
It runs on kimi-k2.6 - their flagship coding model - with optional thinking mode where you can literally watch the AI reason through a problem step by step before answering.
But here's the thing that actually made me write this article.
Kimi Code is fully compatible with Claude Code. Not "kind of compatible." Not "you can sort of make it work." You change two environment variables, type claude, and your exact same Claude Code setup is now running on Kimi's model. Same interface. Same commands. Different brain.
That's the trick. And almost nobody is talking about it.
Installation - Three Ways to Get Started
Way 1: CLI - Fastest Setup on Earth
One command. That's it.
# macOS / Linux
curl -LsSf https://code.kimi.com/install.sh | bash
# Windows (PowerShell)
Invoke-RestMethod https://code.kimi.com/install.ps1 | Invoke-Expression
Check it worked:
kimi --version
Now go into your project folder and launch it:
cd your-project
kimi
First time? Type /login - browser opens, you authorize with your Kimi account, done. Settings are saved automatically. Next time you just run kimi and you're straight in.
If you already have uv installed (Python package manager), you can also do:
uv tool install --python 3.13 kimi-cli
macOS heads up: First launch might be slow because of Gatekeeper security checks. Fix it by adding your terminal to System Settings - Privacy & Security - Developer Tools. One-time setup, fast forever after.
GIF
Way 2: VS Code Extension - For the GUI People
No shame in this. Open VS Code, hit Cmd+Shift+X, search "Kimi Code" by moonshot-ai, install.
A Kimi icon shows up in your Activity Bar. Click it, log in through the browser, and you've got a full AI coding panel living inside your editor. Chat, file diffs, plan review, image input - the whole thing.
Open it anytime with Cmd+Shift+K on Mac or Ctrl+Shift+K on Windows.
Way 3: Drop Kimi Into Claude Code - The Move Nobody Talks About
This is the one. If you're already a Claude Code user - stop what you're doing and try this right now.
# macOS / Linux - paste this before running claude
export ANTHROPIC_BASE_URL=https://api.kimi.com/coding/
export ANTHROPIC_API_KEY=sk-kimi-your-key-here
claude
# Windows PowerShell
$env:ANTHROPIC_BASE_URL="https://api.kimi.com/coding/"
$env:ANTHROPIC_API_KEY="sk-kimi-your-key-here"
claude
Type /status to confirm the model switched to Kimi. That's your entire migration.
Get your API key at kimi.com/code - go to Console - API Keys - Create New Key. It shows once, copy it immediately.
Want to toggle to Kimi's thinking model mid-session? Hit Tab inside Claude Code.
The Features That Actually Matter
Thinking Mode - Watch the AI Reason Out Loud
Most AI tools give you an answer. Kimi Code can show you how it got there.
Enable it at launch:
kimi --thinking
When thinking is on, every response comes with a collapsible reasoning block - like a scratchpad where the model works through the problem. You can expand it and follow the logic. For complex bugs or architectural decisions, this is genuinely useful. You're not just trusting a black box anymore.
Want thinking on by default? Add this to your config.toml:
default_thinking = true
show_thinking_stream = true
Some models like kimi-k2-thinking-turbo always run with thinking on and can't be turned off - they're built for hard problems.
YOLO Mode - Full Autopilot
By default Kimi asks you before touching any file or running any command. YOLO mode turns all that off:
# Launch directly in YOLO mode
kimi --yolo
# Or toggle it mid-session
/yolo
Yellow YOLO badge appears in the status bar. Everything runs without approval until you type /yolo again to disable.
Use it on test projects, in isolated environments, or when you've watched the agent enough to trust what it's doing. Don't use it in production on a Monday morning. You've been warned.
Plan Mode - Think Before You Act
VS Code extension only - there's a small 📋 icon left of the input box. Enable it and Kimi outputs a full step-by-step plan before doing anything. You review, edit if needed, then let it go.
For big risky tasks - refactoring a core module, updating all dependencies - this is the feature that saves you from a 2am rollback.
@ File References - Stop Copy-Pasting Code
Type @ anywhere in your message and you get autocomplete for files and folders in your project:
Check for bugs in @src/components/Button.tsx
Explain what @src/core/scheduler.py does
Why is this pattern used in @src/api/auth.ts:45-78?
Tab to autocomplete. Reference specific line ranges. Works in both CLI and VS Code.
MCP Servers - The Power-User Feature
MCP (Model Context Protocol) lets you connect external tools directly to the agent. In VS Code go to Action Menu - MCP Servers.
Pre-built ones available with one click:
- Playwright - Kimi writes code and tests it in a real browser in the same workflow
- GitHub - reads your issues, creates PRs, understands your repo history
- Context7 - pulls live documentation so the agent always has current API references
Sessions - Never Lose Your Work
kimi --continue # resume last session in this folder
kimi --session abc123 # resume a specific session by ID
/sessions # pick from a list mid-session
Context getting too long?
/compact # AI summarizes the conversation, keeps going with less tokens
/clear # wipe everything and start fresh
The status bar shows context: xx% - watch that number and hit /compact when it gets high.
Real Tasks, Real Results
Debugging - Just Paste the Error
Stop reading stack traces manually. Paste the error, describe what you were doing, and let it run:
Running npm test throws this:
TypeError: Cannot read property 'map' of undefined
at UserList.render (src/components/UserList.jsx:15:23)
Fix it.
Kimi reads the relevant files, finds the root cause, and shows you a diff before changing anything. You approve the fix or reject it.
Or go even simpler:
Run the tests. Fix any failures.
It runs. Reads the output. Finds what broke. Fixes it. Runs again to verify. You watch.
Building Features - Natural Language to Working Code
Add pagination to the user list - 20 items per page
Kimi works in a Read - Edit - Verify loop:
- Reads your existing code and figures out how the project is structured
- Writes changes that match your existing style - not generic boilerplate
- Runs your tests to make sure nothing broke
Not happy with the result?
The pagination style doesn't match the rest of the UI -
look at the Button component and follow the same patterns
It goes back, reads the Button component, adjusts. No regenerating from scratch.
Understanding a New Codebase
Every developer knows this moment - you inherit a repo and have no idea where anything is.
What's the overall architecture of this project? Where's the entry point?
How is authentication implemented? Which files are involved?
Explain what @src/core/scheduler.py does and why it exists
Five minutes instead of an hour. Ask follow-up questions like you're talking to whoever built it.
Automating the Boring Stuff
Replace all var with const or let in every .js file under src
Add JSDoc comments to every public function that doesn't have one
Update all package.json dependencies to latest, then run the tests
That last one is where it gets impressive. Updates everything, runs tests, sees what broke, fixes it, runs tests again. You get the result.
Honest Pros and Cons
No product is perfect. Here's the real picture.
What's Actually Good
Speed is noticeable. Up to 100 tokens/sec. Responses feel snappy in a way that matters during active work sessions. Not just a benchmark number.
The Claude Code integration is genuinely seamless. Two environment variables and you're running a different model in your existing setup. Zero learning curve for existing Claude Code users.
Thinking mode changes how you debug. Seeing the reasoning chain isn't just aesthetically interesting - it helps you catch when the model is going down a wrong path before it makes changes.
Context window is huge. 262,144 tokens. You can drop an entire large codebase in and it handles it.
It's included in Kimi membership. No separate charge for Kimi Code on top of your plan.
Works everywhere. CLI, VS Code, JetBrains via ACP protocol, Zed editor. Zsh plugin lets you jump in from any terminal with Ctrl-X.
What's Not So Good
Quota doesn't roll over. Resets every 7 days - use it or lose it. You need to actually build a habit around it or you're wasting your plan.
Personal use only. This is explicitly for individual developers. No team plans, no commercial products built on top of it. For that you need Moonshot AI's separate enterprise platform.
The ecosystem is still small. The docs are good. The tool is solid. But the community, tutorials, and third-party integrations are nowhere near Cursor or GitHub Copilot yet. You're an early adopter.
30-day inactivity timeout. Leave it alone for a month and your session expires. Minor annoyance, just run /login again.
Who Should Actually Use This
Use Kimi Code if:
- You're already on Claude Code and want to try a different model without changing your workflow - this is the zero-risk experiment
- You work with large codebases and need that 262k token context window
- You want to actually see how the AI reasons, not just what it outputs
- You live in the terminal and want AI there natively
Probably skip it if:
- You need it for a team or commercial product - wrong tier for that
- You're not comfortable with CLI tools at all - start with Cursor or GitHub Copilot and come back
- You need a large support community and tons of tutorials - not there yet
The Bottom Line
Kimi Code is not trying to replace everything. It's a well-built agent from a serious AI lab that does one thing particularly well - it fits into where you already are.
No new interface to learn. No migration. No commitment.
If you use Claude Code: two lines in your terminal and you can be running on Kimi K2 in the next 60 seconds. Try it on one task. See what happens.
The bar to try it is basically zero. The upside might surprise you.
Resources and links:
- Official site: kimi.com/code
- Full docs: kimi.com/code/docs/en
- GitHub (CLI): github.com/MoonshotAI/kimi-cli
- VS Code extension: search "Kimi Code" in the VS Code marketplace