What transfers cleanly from Claude Code
If you already work in Claude Code, Gemini CLI is a shorter jump than it first appears. Both are terminal agents that read a repository, propose edits, run shell commands, and pause before anything destructive. The discipline you already have — small commits, precise prompts, reading every diff before it lands — carries over intact. What changes is the command vocabulary, the settings file, and which models sit behind the tool.
The mental model is also the same: a chat session anchored to a working directory, with tools the agent can call on your behalf. You still think in terms of context windows, tool permissions, and review loops. The only real translation work is mapping one tool's names and files onto the other.
- Project instructions: Claude Code reads CLAUDE.md; Gemini CLI reads GEMINI.md. Keep both files in the repo root and keep their guidance aligned, so the agent behaves the same whichever one you open.
- Permission gates: both tools can run shell commands and edit files, and both let you approve actions individually or trust a narrow set. Start strict and widen only when a pattern earns it.
- Session hygiene: the good habits you built for long sessions apply here too. Reset stale context, keep tasks narrow, and restate goals when you switch branches.
- Tooling around the agent: your formatter, linter, test runner, and git hooks do not care which agent is driving them.
One habit worth keeping is the pre-flight commit. Before any agent touches a working tree, make the tree clean. That single rule makes it trivial to see exactly what an agent changed and to roll back a run that goes sideways.
Install Gemini CLI and point it at the relay
Install the CLI with Node's package manager and launch it from inside your project. Once it starts, you can type a request the same way you would in Claude Code, and the agent will read files, propose a plan, and ask before editing.
The important step for anyone moving between tools is the API host and key. If you use a single relay for several agents, the host strings are the only thing you need to remember. Claude Code and Gemini CLI both take the bare host, while OpenAI-compatible SDKs add the /v1 path. So point both agents at https://api.fastapirelay.com and give each one your relay key in its own environment variable.
- Host for terminal agents: https://api.fastapirelay.com, with no path suffix.
- Host for OpenAI SDKs: https://api.fastapirelay.com/v1.
- Keys: export the relay key in the variable each tool expects, and keep it out of shell history and version control.
- Per-project setup: a small env file or direnv block per repository keeps different agents from stepping on each other.
SwiftRelay is worth setting up here because it is pay-as-you-go and billed per token, so running two or three agents does not mean buying anything extra. It speaks to Claude Code, Gemini CLI, Codex, and any OpenAI-compatible SDK, which means one account covers the whole tool shelf. New accounts get a small gift credit to burn through a first run, and inviting friends earns 14% of their top-ups.
Command vocabulary side by side
Once both tools are running, the friction is mostly naming. You already know the workflow you want; you just need the Gemini CLI spelling for it. Here is the mapping that covers most of a working session.
- Start a session: open the CLI from the repository root so the agent inherits the right working directory and project instructions.
- Slash commands: both tools use slash-prefixed commands inside the prompt for things like clearing context, loading a file, or switching modes. Learn the handful you use daily and ignore the rest.
- Plans before edits: ask for a plan first when the change spans multiple files. Approve the plan, then let it execute. This is the same rhythm you already use in Claude Code.
- File references: both agents accept explicit paths in the prompt. Pinning the exact file beats hoping the agent guesses the right module.
- Interrupt and steer: stop a run mid-flight with the interrupt binding and correct the direction instead of letting it compound a wrong assumption.
Two behaviour differences are worth watching on day one. First, always confirm which instruction file the agent loaded before trusting its answers about project conventions. Second, treat tool approval prompts as your real interface; the difference between a smooth run and a stalled one is usually a permission that was never granted.
Picking models for each lane
Having several agents on one relay means you can also route different kinds of work to different models. This is where a relay pays for itself, because the choice becomes a per-task decision rather than a per-tool commitment.
- Fast iteration and small edits: a lighter model handles typo fixes, renames, and test scaffolding without making you wait for a heavyweight pass.
- Reasoning-heavy work: architecture changes, refactors across many files, and tricky debugging deserve a stronger model for the planning stage.
- Long-context review: when you want the agent to read a large slice of the repo before answering, pick a model sized for that job rather than brute-forcing every request.
On the SwiftRelay side, options like Claude Sonnet 5 cover the everyday middle ground, while a heavier pick such as Gemini 3.1 Pro suits the deep planning lane. Because billing is per token with no subscription, switching lanes costs nothing extra. You only pay for what the run actually consumed, and a new account's gift credit lets you try both ends of the spectrum before topping up.
First-run checklist before the green light
Before you call the setup done, walk one real task through both agents and compare the results. Pick something narrow — a unit test you meant to write, a stale doc string, a lint warning — so the exercise stays short and the outcome is obvious.
- Both tools start inside the repository and report the correct working directory.
- The bare host is configured for the terminal agents, and the /v1 host is configured for any OpenAI-compatible SDK in the same workspace.
- Both instruction files exist and describe the same conventions.
- Tool permissions are set to the level you actually want before the first edit.
- A formatter and the test suite run cleanly, so agent output can be validated mechanically.
With that checklist green, keep the two tools side by side for a week and let the workflow decide the winner. Use the one whose planning and editing loop matches how you think, and keep the other loaded for tasks where its model routing is a better fit. If you want both running without juggling separate accounts or commitments, sign up for SwiftRelay and connect them to the same pay-as-you-go relay.
The final call is simple: stay with Claude Code as your daily driver if its session flow already fits your hands, and add Gemini CLI as the second seat for exploration, long-context reading, and model variety. Two agents, one relay, one bill based on tokens you actually used, and no reason to tear up a workflow that is already working.