CC CodeClaws

Vim and Emacs ideas, rebuilt around AI

An AI-native modal editor for the terminal.

CodeClaws takes the durable ideas behind Vim and Emacs — modes, buffers, leader keys, panes, programmable commands — runs locally by default, or via any OpenAI-compatible API, and gives the AI the same live context you have: editor, shell, git, tests, traces, and project rules.

Install Try demo GitHub
Editing
Modal buffers and leader keys
System
Programmable terminal UI
AI
Session-aware command layer
Animated CodeClaws demo showing a modal buffer, leader-key AI commands, a failed shell test, a CodeClaw fix proposal, and a saved trace.

Get qe

Install on macOS or Linux.

Prebuilt v0.1.1 packages ship the editor binary and Rust sidecar. You still need Node.js 22+ on your PATH. Supported: macOS (Apple Silicon and Intel) and Linux x86_64.

Homebrew

macOSLinux

Tap kroq86/qe and install the formula.

brew tap kroq86/qe
brew install qe

Install script

macOSLinux

Downloads the release tarball for your OS/arch into /usr/local by default.

curl -fsSL https://raw.githubusercontent.com/kroq86/ide/main/install.sh | sh

Custom prefix: sh -s -- --prefix ~/.local (pipe the script into sh).

APT

DebianUbuntu

.deb packages are published to the GitHub Pages apt repo on each stable release.

echo "deb [trusted=yes] https://kroq86.github.io/ide/ stable main" | sudo tee /etc/apt/sources.list.d/qe.list
sudo apt update
sudo apt install qe

From source

macOSLinux

Clone, build, and link the CLI — same path as contributors running the demo fixture.

git clone https://github.com/kroq86/ide.git
cd ide
npm install
npm run build
npm link
qe README.md

After install, run qe path/to/file. See the demo walkthrough or the v0.1.1 release assets.

Live path

Run the real demo fixture.

After installing qe, or from a dev checkout below: open a buffer, use leader keys, run a failing command, ask the AI command layer for a fix, and inspect the written trace. 

npm --prefix app install
npm run build:native
bash scripts/dev.sh examples/broken-counter/src/counter.ts
CodeClaws animated demo loop from failed test to AI fix proposal and trace.
Contributor demo: modal buffer, leader command, failed test, AI proposal, verifier pass, trace saved.
01

Open shell

Press SPC t t and run the failing fixture test.

02

Ask CodeClaw

Press SPC a f to generate a fix from the last failed shell run. (CodeClaw is the AI fix layer built into CodeClaws.)

03

Inspect trace

Press SPC a t to review the summarized trace written under .codeclaw/.

The idea

Vim gave us modal control. Emacs gave us a programmable environment. CodeClaws adds session-aware AI.

Modal by default

Normal, insert, visual, command, and search modes make editing deliberate and fast in the terminal.

Programmable like Emacs

Commands, panels, shell runs, git state, and AI flows are composable pieces of one environment.

Session context

The assistant sees current buffer, shell failures, output tails, git diff, and project rules.

Verifiable AI

CodeClaw — the editor's AI fix layer — produces bounded proposals and trace files instead of silent repository rewrites.

Multi-provider

Switch between local Ollama models and cloud APIs (OpenAI, Groq) at runtime with SPC a m.

Contributor entry points

Small tasks that make the project easier to join.

The best first contributions make the editor feel more like the AI version of Vim/Emacs: stronger motions, better command discovery, cleaner panes, reliable traces, and a demo people can trust.

Docs

Record the broken-counter demo

Add a short terminal recording or screenshots showing the failing test, CodeClaw proposal, and trace viewer.

Test

Expand protocol smoke coverage

Add a focused test for snapshot edits, cursor movement, and the native sidecar fallback path.

UI

Improve command discovery

Polish which-key, command palette, and mode feedback so new users can learn the system by doing.

AI

Add example project rules

Create a small .codeclaw/ fixture with verifier rules and expected trace output.

Find issues Read the source

Roadmap

Build the AI-native line from Vim and Emacs.

  1. Now

    Make the core loop sharp

    Modal editing, leader keys, shell failure capture, CodeClaw fix, and trace viewing should feel immediate.

  2. Next

    Complete the editing layer

    Motions, selections, multi-buffer, command palette, git UI, shell panes, and project navigation.

  3. Later

    AI as a first-class substrate

    Make the existing AI layer composable and extensible: programmable rules, agent memory, verification hooks, and inspectable traces across providers.