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, and local-first control, then gives the AI the same live context you have: editor, shell, git, tests, traces, and project rules.

Try demo GitHub Contribute

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.

Live path

Run the real demo fixture.

The demo feels like a tiny AI-era Emacs/Vim loop: 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. — Six-second contributor demo: modal buffer, leader command, failed test, AI proposal, verifier pass, trace saved.

Open shell

Press SPC t t and run the failing fixture test.

Ask CodeClaw

Press SPC a f to generate a fix from the last failed shell run.

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 produces bounded proposals and trace files instead of silent repository rewrites.

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.

Improve command discovery

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

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.

Now
Make the core loop sharp

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

Improve motions, selections, buffers, command palette, git UI, shell panes, and project navigation.
Later
Make AI programmable

Treat AI actions as first-class commands with rules, memory, verification, review, and inspectable traces.