---
title: "How to Migrate from Claude Code to oh-my-pi (omp)"
date: 2026-10-12
topic: AI
kind: Tutorial
author: Wes Copeland
url: https://wescopeland.dev/writing/migrate-from-claude-code-to-omp/
summary: "Everything you need to know to move from running Claude Code inside a terminal to using omp, including what you gain, what you lose, and how to set up permissions."
---

# How to Migrate from Claude Code to oh-my-pi (omp)

By [Wes Copeland](https://wescopeland.dev/about/index.md) · Oct 12, 2026 · 10 min · 2,119 words

I've settled on [oh-my-pi](https://github.com/can1357/oh-my-pi) (omp) as my daily coding harness. It's the best terminal coding agent I've used, and anyone doing serious engineering work should give it a try.

If you haven't heard of it, omp is an open-source coding harness for the terminal, made by [Stencil](https://stencil.so/). It works with basically every AI provider and subscription, including your Claude Max and Codex subs.

If you'd like a guided migration, paste this into a fresh Claude Code session:

```text
I'm switching from Claude Code to omp (oh-my-pi), an open-source coding agent for the terminal. Its docs are at https://github.com/can1357/oh-my-pi/tree/main/docs. Help me migrate. Don't change any files until I say so.

1. Look at my Claude Code setup: ~/.claude/ (CLAUDE.md, settings.json, skills, commands, agents, plugins), the MCP servers in ~/.claude.json, and any CLAUDE.md, CLAUDE.local.md or .claude/ folder in this project.
2. Skim my recent sessions in ~/.claude/projects/ to learn how I work: the models I pick, the commands and skills I use most, and the things I keep repeating.
3. Read omp's docs. Work out what carries over as-is, what needs converting (settings.json hooks, permission rules, .claude/agents/*.md, auto memory), and which omp features I'd get the most out of.
4. Give me a checklist. Put the next action first. Number the steps, one action per step. Mark the optional ones. End with the single next thing I should do.
5. Walk me through it one step at a time. Wait for me to finish each step before giving me the next one.
```

## Why I switched

I'm a coding agent power user. For months, I bounced between Claude Code, Codex, Cursor CLI, Devin CLI, OpenCode, and Antigravity - whichever one was appropriate for the task at hand. That got old fast, so I went looking for a harness that could do everything I needed all under one roof.

omp does that. It runs all my subscriptions and models from a single terminal, and it's genuinely hackable in ways most others aren't.

It also has a few things the other harnesses either don't have or don't do well: detailed analytics across every provider and model, novel compaction techniques, cache warming for long sessions, load balancing across multiple subscriptions to the same provider, and deep customizability to match your given working preferences.

## Install and log in

Install omp with one command:

```bash
# macOS and Linux
curl -fsSL https://omp.sh/install | sh

# Windows (PowerShell)
irm https://omp.sh/install.ps1 | iex
```

Run `omp` once it's installed. It drops you straight into an onboarding wizard where you can log in with your Claude Max subscription.

![omp setup, step 1 of 5: a list of providers to sign in to, with Anthropic (Claude Pro/Max) highlighted](https://wescopeland.dev/writing/migrate-from-claude-code-to-omp/setup-providers.webp)

omp opens a claude.ai login page in your browser. Approve it and you're all set. If omp asks for an authorization code, copy it from the browser and paste it into the terminal.

![Signing in to Anthropic: omp shows a claude.ai login link and waits for the authorization code](https://wescopeland.dev/writing/migrate-from-claude-code-to-omp/setup-anthropic-login.webp)

> [!WARNING]
> Anthropic's [terms](https://code.claude.com/docs/en/legal-and-compliance) say that Claude subscription logins are meant for Claude Code and Anthropic's own apps, and omp identifies itself as Claude Code when you log in this way. However, on October 7, 2026, Anthropic provided a [significant update](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan) stating "you can still use ... third-party apps with your subscription limits." If you're not comfortable with that, log in with an Anthropic API key instead.

You'll also pick a default model, a glyph mode, a composer shape, and a theme.

![Setup step 2 of 5: picking a default model from a list of Claude models, with Claude Opus 5.5 highlighted](https://wescopeland.dev/writing/migrate-from-claude-code-to-omp/setup-default-model.webp)

For your glyph mode, I strongly recommend a Nerd Font. If you don't have one, [FiraCode Nerd Font](https://www.nerdfonts.com/font-downloads) is a good pick, and it makes omp's UI much easier to read.

![Setup step 3 of 5: glyph mode, with sample icons in Nerd Font, Unicode and ASCII to compare](https://wescopeland.dev/writing/migrate-from-claude-code-to-omp/setup-glyph-mode.webp)

Any composer shape will work fine, but the Claude Code shape will look most familiar.

![Setup step 4 of 5: composer shape, with Claude Code highlighted above a live preview of the prompt](https://wescopeland.dev/writing/migrate-from-claude-code-to-omp/setup-composer-shape.webp)

The last step is picking a theme. I use Titanium, which is the default for dark terminals.

## Permissions

Know this before you use omp for real: its default operating mode is YOLO mode (AKA: `--dangerously-skip-permissions`). Claude Code's auto mode doesn't go that far. In YOLO mode, nothing checks a bash command before omp runs it. omp does know about a handful of catastrophic commands, like `rm -rf /` and fork bombs, but YOLO mode skips that check too.

omp has three approval modes:

| Mode | Runs without asking | Asks first |
|---|---|---|
| `always-ask` | Reads | Edits and commands |
| `write` | Reads and edits | Commands |
| `yolo` (default) | Everything | Nothing |

If you want Claude Code's old behavior, where it asked before every edit and command, pick `always-ask`. If you'd rather let it edit files freely but still check with you before running commands (similar to Claude Code's accept-edits mode), go with `write`.

```yaml title="~/.omp/agent/config.yml"
tools:
  approvalMode: always-ask
```

You can also set the mode for a single session by starting omp with `omp --approval-mode always-ask`.

No matter which mode you choose, you can block specific commands you never want omp to run. omp checks your `bash.patterns` rules in order and uses the first one that matches, and you can use `*` as a wildcard:

```yaml title="~/.omp/agent/config.yml"
tools:
  approval:
    eval: prompt
bash:
  patterns:
    - match: "rm -rf *"
      approval: deny
    - match: "git push*"
      approval: prompt
```

A `deny` rule applies in every mode, including YOLO mode, and it'll catch a command even when you chain it with `&&`, `;` or `|`.

That `eval: prompt` line matters. omp's eval tool runs Python and JavaScript, and those scripts can start their own shell without going through your `bash.patterns` rules. `eval: prompt` makes omp ask before it runs one.

One important caveat: subagents _always_ run in YOLO mode. Your `deny` rules still apply to them, but a `prompt` rule is refused, since a subagent can't stop midstream and ask you for permission to do something.

If you want something closer to Claude Code's auto mode, there's a community plugin called [guard](https://github.com/casonadams/omp-plugins) that has a model review each command before it runs:

```bash
omp plugin install guard@casonadams-plugins
```

## What carries over

`omp` reads any _CLAUDE.md_ and _AGENTS.md_ file in your project, including the ones in parent folders up to your repo root. It skips _CLAUDE.local.md_ and _AGENTS.override.md_ by default, but you can add them to your config:

```yaml title="~/.omp/agent/config.yml"
contextFiles:
  extra: [CLAUDE.local.md, AGENTS.override.md]
```

If you've been using Claude Code for a while, you've probably accumulated quite a bit in your _~/.claude_ directory. omp ignores it by default, but you can opt in with `enabledProviders`:

```yaml title="~/.omp/agent/config.yml"
enabledProviders: [claude]
```

This keeps your user-level _CLAUDE.md_, skills, slash commands, MCP servers, and Claude plugins working. omp picks up project-level _.claude_ directories either way. If you also have an _~/.omp/agent/AGENTS.md_ file, omp uses it instead of your _~/.claude/CLAUDE.md_.

The one thing that won't carry over is Claude Code's auto-memory. Claude Code stores memory in _~/.claude/projects/<project>/memory_, and even though omp has a memory feature, it's disabled by default. If you have anything in there worth keeping, move it into your _CLAUDE.md_ (or just ask omp to do it).

If you have any long-running sessions in Claude Code, you can resume them in omp. Run `omp --from-claude` and it will open a menu letting you import the Claude Code session into omp (it's similar to `claude --resume`). You can also do this if you're already in a session by running `/resume @claude`.

A few things won't work 1:1:

- _.claude/agents_: omp loads subagents from _.omp/agents_ or _~/.omp/agent/agents_ and the frontmatter is slightly different.
- Hooks from _settings.json_: instead of shell commands, omp uses TS/JS files that go in _~/.omp/agent/hooks/pre_ or _~/.omp/agent/hooks/post_.
- Permission rules: omp has its own system for granular permissions (covered above).

That said, you can ask omp to port all of these for you.

## Make it feel like Claude Code

Most of this is covered in the onboarding wizard, but if you need to do it manually:

```yaml title="~/.omp/agent/config.yml"
composer:
  shape: claude
symbolPreset: nerd
```

Most keyboard shortcuts should work how you expect, except for these two:

| Key | Claude Code | omp |
|---|---|---|
| Shift+Tab | Cycle permission modes | Cycle thinking level |
| Alt+Shift+P | | Toggle plan mode |

You can find all the keyboard shortcuts, as well as instructions for changing them, in the omp [keybindings docs](https://github.com/can1357/oh-my-pi/blob/main/docs/keybindings.md).

## Claude Code to omp equivalents

Most slash commands have the same name (`/resume`, `/clear`, `/compact`, `/btw`, `/review`, `/export`, and so on), but a few are different:

| Claude Code | omp |
|---|---|
| `/rewind` | `/rewind` (conversation only, not files) |
| `/cd` | `/move` |
| `/cost`, `/usage` | `omp stats`, `omp usage` |
| `/plugin` | `/marketplace`, `/plugins` |
| `--worktree` | `/wt`, `omp worktree` |
| Remote Control | `/collab` |
| Messaging your other sessions | [agent-bus](https://github.com/danbarua/agent-bus) |

## Model roles

Claude Code gives you one model at a time. omp lets you assign different models to different roles. You set the model for each role once, and that's the model that will be used for that role going forward.

Here's what my `modelRoles` config looks like at the time of this writing:

```yaml title="~/.omp/agent/config.yml"
modelRoles:
  default: anthropic/claude-sonnet-5-5:high
  plan: anthropic/claude-opus-5-5:high
  task: anthropic/claude-opus-5-5:medium
  slow: anthropic/claude-opus-5-5:high
  advisor: anthropic/claude-opus-5-5:medium
  smol: anthropic/claude-haiku-5-5:medium
  tiny: anthropic/claude-haiku-5-5:low
  commit: anthropic/claude-haiku-5-5:low
  web: openai-codex/gpt-5.6-luna
  judge: typesafe/jev-latest:auto
```

| Role | What it's for | What I use |
|---|---|---|
| `default` | Your main conversation | Sonnet 5.5 |
| `plan` | Plan mode | Opus 5.5 |
| `task` | Subagents | Opus 5.5 |
| `slow` | Deep reasoning | Opus 5.5 |
| `advisor` | Reviews each turn in the background | Opus 5.5 |
| `smol` | Quick, cheap tasks | Haiku 5.5 |
| `tiny` | Session titles | Haiku 5.5 |
| `commit` | Commit messages | Haiku 5.5 |
| `web` | Web search | GPT-5.6 Luna |
| `judge` | Quick classification calls that save tokens in the long run, like ranking results for omp's `find` search tool | TypeSafe's jev |

The `:high`, `:medium`, or `:low` suffix sets the effort level for that model. You can change it any time from the model picker (Alt+M).

Notice how I'm not limited to just one provider. I use GPT for web searches (since I have a ChatGPT subscription) and TypeSafe's model for the judge role as a classifier.

You can also configure fallback chains per role, so that if one model errors or has a rate limit, omp will try the next.

```yaml title="~/.omp/agent/config.yml"
retry:
  fallbackChains:
    default:
      - opencode-go/muse-spark-1.3-contributor:low
    plan:
      - opencode-go/muse-spark-1.3-contributor:medium
    slow:
      - opencode-go/muse-spark-1.3-contributor:medium
    web:
      - anthropic/claude-opus-5-5
      - web/duckduckgo
      - web/startpage
```

## What you can do in omp that you can't in Claude Code

**[Prewalk](https://stencil.so/blog/prewalk)**: let an expensive model work until it begins editing files, then immediately hand off to your `smol` model to follow the pattern. Stencil found this retains 92-97% of the frontier model's pass rate at roughly half the cost. Enable it with `--prewalk`.

**[Snapcompact](https://stencil.so/blog/snapcompact)**: instead of summarizing the conversation when the context fills up, omp renders it as images in a pixel font. Models with vision (eg: Claude) can read these almost verbatim, often at 1/3 the token cost. Since it's done locally, you don't even need to make a model call for compaction. By default, omp will try to compact with the provider first. If you want to prefer snapcompact, add the following to your config file:

```yaml title="~/.omp/agent/config.yml"
compaction:
  methodOrder: [snapcompact, remote, handoff, shake, soft]
```

**Cache warming**: right before your prompt cache expires, omp will resend your last request with a one-token output limit. This keeps your cache alive through short breaks so your next message doesn't pay the full token price to rebuild it. omp is smart enough to only do this when the savings of this feature outweighs the cost of the cachebust and refresh, and it stops keeping the cache warm after thirty minutes of inactivity. This functionality is enabled by default.

**`/omfg`**: did the agent just do something you _never_ want to see again? Run `/omfg` and omp will create a rule based on the conversation that will interrupt and re-attempt the next time the agent tries the same thing.

**`omp stats`**: a local dashboard to view usage, cost, and analytics across all providers and models.

**Use multiple accounts for a given provider.** Log in with two or more Claude Max (or other) accounts, and omp will automatically load balance usage between them.

## What you can do in Claude Code that you can't (yet) in omp

Most of what's missing is proprietary cloud functionality that runs on Anthropic's servers:

- Cloud session management, routines, Projects, the Claude mobile app. You can open a session in your browser with `/collab`, but you won't get push notifications.
- The code review GitHub app, `/ultrareview`, and `@claude` in GitHub/GitLab/Slack. omp has `/review`, which runs locally.

Some local features Claude Code has that omp doesn't yet:

- `/rewind`: in omp, this will only rewind the conversation, not the files. You should probably commit often if you frequently use this feature.
- Sandboxing for bash commands: in omp you can set approval rules to control what it's allowed to run, but it will have full access to your machine for anything it's allowed to run.
- Artifacts, scheduling. There are community projects like [open-artifacts](https://github.com/coda0HQ/open-artifacts). If your editor supports ACP, you can use `omp acp`. There are also community plugins for VS Code and JetBrains.

If there's a feature you need that omp doesn't have, one power move to try is to just ask omp itself to build a plugin for it. I've had pretty decent success with this.

## Should you use omp instead of Claude Code?

I don't have a benchmark. I just really enjoy using it.

If you're a terminal user with subscriptions to multiple AI providers, or if you like tinkering with your tooling, I think you'll enjoy omp. If you're heavily relying on Claude Code's cloud features, or you're uncomfortable with how omp logs in to your Claude subscription, then you might want to hold off.

Either way, it's quick to try. Paste the prompt at the top of this post into Claude Code and see what it says.