# AI agents in Skink: Claude Code, Gemini CLI, Codex and more

> Use Claude Code, Gemini CLI, opencode, Goose, Codex or Antigravity in Skink: ACP setup, the Ctrl+G prompt box, inline diffs, the agent panel and terminal CLIs.

Source: https://skink.cc/tools/ai-agents/

Skink does not ship its own AI. It connects to the coding agent you already use, over the [Agent Client Protocol](https://agentclientprotocol.com) (ACP). Install an agent such as Claude Code, then press Ctrl+G to ask about or rewrite the selected code, or Alt+Shift+A to chat in the agent panel.

`:agents` shows which agent Skink found.

## Two ways to use an agent

There are two ways to use an agent in Skink:

1. **Through ACP** (this page): the prompt box, inline diffs, the agent panel. Skink starts the agent in the background and shows its edits for review.
2. **As a CLI in a terminal tab**: `:term claude`, `:term gemini`, and so on. The tool runs exactly as it does in any terminal.

Both work at the same time.

## Supported agents

| Agent | `ai.agent` name | What Skink runs | What you need |
|---|---|---|---|
| Claude Code | `"claude"` | `claude-code-acp` | Node.js (Skink uses `npx`), or `npm i -g @zed-industries/claude-code-acp`. Log in once with `claude` |
| Gemini CLI | `"gemini"` | `gemini --experimental-acp` | `npm i -g @google/gemini-cli` |
| opencode | `"opencode"` | `opencode acp` | `opencode` on your `PATH` |
| Goose | `"goose"` | `goose acp` | `goose` on your `PATH` |
| Antigravity | `"antigravity"` or `"agy"` | `agy acp` | `agy` on your `PATH` |
| Codex | `"codex"` | `codex-acp` | Node.js (`npx`), or `npm i -g @zed-industries/codex-acp` |

### Agent names are loose

Case, spaces, `-` and `_` do not matter, so `"Claude Code"` and `"claude-code-acp"` both work.

## Set up an agent

1. Install an agent and log in with its own CLI. For Claude Code, install the `claude` CLI and run `claude` once. Skink reuses that login.

2. In Skink, run `:agents`. It lists every supported agent, which ones are installed, the active one and the last check.

3. Run `:agents check` to test the agent with a one-line chat in a throwaway folder. You see something like `Claude Code ✓ (model …, effort …)`, or the reason it failed.

4. Optional: pick an agent, model and effort in `:settings`. Saving a change to these runs the check again.

With the default `"ai.agent": "auto"`, Skink picks Claude Code first (its ACP adapter, or your installed `claude` through `npx`), then the first of the others it finds on your `PATH`.

## AI settings

```jsonc
{
  "ai.agent": "claude",          // or "auto", or a command: ["my-agent", "--acp"]
  "ai.model": "opus 5.5",        // "default" = whatever the agent uses
  "ai.effort": "medium",         // default, low, medium, high, max
  "ai.model.rewrite": "default", // per mode: rewrite, ask, search, implement
  "ai.effort.rewrite": "low"
}
```

- **`ai.agent`**: a known name, `"auto"`, or a command list for any program that speaks ACP on stdio.
- **`ai.model`**: a model the agent offers. Loose names work: `"opus 5.5"`, `"opus5.5"` and `"claude-opus-5-5"` all match. `:model NAME` changes it for this run only.
- **`ai.effort`**: how hard the model thinks. For Claude Code, `low` / `medium` / `high` / `max` set a thinking budget of 4k / 10k / 20k / 32k tokens. Other agents get their own reasoning-level option over ACP, if they have one.

`:settings` puts a reference of agents, models and effort levels at the top of the file.

## The prompt box (Ctrl+G)

Select some code and press Ctrl+G (or type `:ask`). With nothing selected, the code around the cursor is used.

Type what you want and press Enter.

| Key in the box | Does |
|---|---|
| Enter | Send |
| Alt+Enter | New line |
| Shift+Tab | Change mode: rewrite, implement, ask, search |
| Tab | Cycle the model |
| ↑ / ↓ | Prompt history |
| Esc | Close (while it works: cancel) |

While the agent works, the status line shows the agent, the mode, the seconds so far and what it is doing.

### Modes

- **rewrite**: change the selected code. The answer appears as a diff in the file.
- **implement**: write new code at the selection or cursor, also as a diff.
- **ask**: a question. The answer streams into a read-only tab.
- **search**: find things in the project. The hits open in a results tab, and Enter jumps to one.

Rewrite and implement answers are code. If you ask for an explanation there, the agent writes it as comments. An answer that contains no code opens in an "AI answer" tab instead of being lost.

### Chips: adding context

Type these in the box:

| Chip | Adds |
|---|---|
| `@file` | A file (fuzzy match; Tab or Enter completes) |
| `#rule` | A rule from `.skink/rules/*.md`, or from `AGENTS.md` / `AGENT.md` found walking up from the file |
| `@selection` | The current selection |
| `@diagnostics` | The file's errors and warnings |
| `@terminal` | The screen of the last terminal tab |

Slash commands in the box: `/model NAME`, `/ask`, `/search`, `/implement`, `/rewrite`.

### Accepting or rejecting the diff

For rewrite and implement, the change shows inside the file: removed lines struck through in red, added lines in green under them.

| Key | Does |
|---|---|
| y | Accept this change |
| n | Reject this change |
| u | Back to undecided |
| ↑ / ↓, ] / [, Tab | Move between changes |
| Enter | Apply (undecided changes count as accepted) |
| a or Ctrl+Enter | Accept all |
| Esc | Discard everything |

The applied result is one undo step, so Ctrl+Z takes it all back.

## The agent panel

Alt+Shift+A (or `:agent`) opens a chat with the agent, showing its messages, tool calls and plan.

Alt+Shift+T (or `:agentdock`) docks it on the right side of the window instead.

- Ctrl+G in the panel types a message, with the same chips as the prompt box.
- `:agent MESSAGE` sends a message straight from the command line.
- `:agent send` sends the selection, or the terminal's screen.
- `:agent cancel` stops the current turn. `:agent stop` ends the agent.

### Permission requests

When the agent asks for permission (to run a command, say), a dialog appears. ↑ / ↓ and Enter, or 1–9, answer it. Esc rejects.

### Send errors to the agent

Alt+Shift+E (`:agent errors` or `:senderrors`) sends the errors to the agent:

- In a terminal tab: the last command and its output.
- Elsewhere: the errors and warnings of the open files (or, if there are none, the last terminal command).

With a shell that sends OSC 133 prompt marks, it sends exactly the last command's output. See [Terminal tabs](https://skink.cc/tools/terminal-tabs/).

### Edits are staged, not written

Files the agent writes are never written to disk directly. They are staged, and when the agent's turn ends they open in the refactor preview: files and hunks with checkboxes and a side-by-side diff.

Check what you want, press Enter to apply, Esc to cancel. `:review` reopens the preview. Keys are in [Refactoring](https://skink.cc/code/refactoring/).

Applied files stay unsaved, so you get one more look before Ctrl+S.

## Running any AI CLI in a terminal tab

Every AI CLI runs in a terminal tab unchanged, because terminal tabs are real terminal emulators. Run `:term claude`, `:term gemini` or `:term opencode`.

Or press Shift+F12 for a shell and start it there. F12 flips between the CLI and your file. Ctrl+click on a `file:line` the CLI prints opens it in Skink.

This is the simplest setup and needs nothing from ACP. You lose the inline diffs and staged review, since the CLI edits files itself.

Skink notices changed files: clean ones reload by themselves, and for files with unsaved edits it asks.

## When it does not work

- Run `:agents check` and read the reason.
- "No ACP agent found on PATH": install one of the agents above, or set `ai.agent`.
- Claude Code needs `npx` (Node.js) unless you install `claude-code-acp` globally.
- Agents started through `npx` download on first use, so the first start can be slow.

**Caution:**
Skink is alpha, and the AI features are the newest part. They have been tested against real agents only lightly so far. If an agent misbehaves, the terminal-tab route (`:term claude`) always works.

Inside [EveryAI](https://skink.cc/tools/everyai/), the prompt box and agent panel use EveryAI's models instead, with no setup.