Source: https://learn.nodegx.io/advanced/other-ai-tools
Summary: How to connect NodeGX to an AI coding tool other than Claude Code, such as Kimi Code or Cline, and what to know if you do.

# Other AI coding tools

NodeGX works with any AI coding tool that can use MCP servers, not only Claude Code. An MCP server is a small program that gives an AI tool extra tools; NodeGX's is the one that lets an AI list, create and build your projects. You connect it with **Copy the command instead**.

This guide uses Claude Code because that's what I use, and for most people it's the right choice. This page is for when it isn't.

## Copy the command

1. Open NodeGX. On the start screen, find the box **Build it by describing it**.
2. Next to **Connect Claude Code**, click **Copy the command instead**. The button says **Copied**.
3. Paste it into your AI tool, and send:

```text
Please add this MCP server so you can use NodeGX.
```

4. Start a new conversation in your tool (or restart it) so it picks up the new server.
5. Check it works:

```text
Can you see NodeGX? Please list my NodeGX projects.
```

Once you have projects, the box is still on the **Projects** tab, as a smaller row.

## What the command is

The copied line is written for Claude Code's terminal tool, so it starts with `claude mcp add`. On a Mac it looks like this, with your own paths where the `<…>` are:

```bash
claude mcp add --scope user nodegx -e ELECTRON_RUN_AS_NODE=1 -e NODEGX_USER_PREFERENCES=/Users/you/Library/Application Support/NodeGX/PREFERENCES.md -- "<path to the NodeGX app>" "<path to NodeGX's MCP server file>" --allow-writes
```

Your tool doesn't run this line. It needs the parts from it:

| Part | In the command | What it is |
|------|----------------|------------|
| Name | `nodegx` | What the tool calls the server |
| Command | the first quoted path after `--` | The NodeGX app itself, which runs the server |
| Arguments | the second quoted path, then `--allow-writes` | The server file, and permission to change projects |
| Environment | each `-e NAME=value` | `ELECTRON_RUN_AS_NODE=1` makes the NodeGX app run as a plain program instead of as the full app. `NODEGX_USER_PREFERENCES` points at your [About you](https://learn.nodegx.io/setup/about-you) file |

Keep both environment settings. Without `ELECTRON_RUN_AS_NODE=1`, the NodeGX app starts as a full app every time your tool uses it, even though the server seems to work. Without the preferences path, your tool won't get your About you text.

::: warning A space in the path
On a Mac, the preferences path contains a space (`Application Support`), and the copied line doesn't put quotes around it. If you type or paste the settings yourself, keep the whole path together as one value, up to and including `PREFERENCES.md`.
:::

## Adding it through your tool's settings

If your tool has an MCP settings screen or file, you can add the server there instead of asking the tool to do it. Many tools use the same layout that NodeGX writes into a project's `.mcp.json`:

```json
{
  "mcpServers": {
    "nodegx": {
      "type": "stdio",
      "command": "<the NodeGX app path>",
      "args": ["<the MCP server file path>", "--allow-writes"],
      "env": {
        "ELECTRON_RUN_AS_NODE": "1",
        "NODEGX_USER_PREFERENCES": "<the preferences path>"
      }
    }
  }
}
```

Fill in the three paths from your copied command. Check your tool's own documentation for where its MCP settings live; they differ between tools and change between versions.

## What your tool gets, and what it may not

Your tool gets the same NodeGX tools Claude Code does, and every change is still checked before it's saved.

Each NodeGX project also has a `CLAUDE.md` file that tells an AI how to work on it. Claude Code reads it automatically. Other tools may not. Start each conversation with:

```text
Before you start, read CLAUDE.md in the project folder.
```

## Cline

[Cline](https://cline.bot) is an open-source extension for VS Code. It pays per request through an API, so every message costs money. You can top up credits in Cline, or use your own key from a provider such as Anthropic.

I built a lot of projects with it before I moved to Claude Code. In my own daily use, not a controlled test:

- **It was about 4x faster** to a working app.
- **It cost about 10x more.** When I moved, I shipped about the same amount of work each week for roughly a tenth of the money.

It makes sense when you have a hard deadline and the budget to match, or you want to watch every step and know enough to spot a wrong turn. Otherwise, stay with Claude Code.

**If you use it, set a spending limit first.** If you use your own API key, set a monthly limit in your provider's console and leave auto-reload off. In Cline, set a low limit per task. A stuck loop with no limit can spend real money overnight. One of my projects burned about $30 that way on a deploy that kept retrying over bad Wi-Fi.

Add "if the same thing fails three times, stop and tell me what you tried" to Cline's rules file, `.clinerules`, in the project folder. It is Cline's version of CLAUDE.md.

## Other tools

**Kimi Code**, **DeepSeek** and others come up a lot, and new ones arrive every month. I'm not going to quote their prices or features here. They change too often, and a wrong number is worse than none.

If you try one:

- Try it on a small job you've already done with Claude Code, and compare.
- Keep the method: plan before you build, one job per conversation, check the result yourself.
- **Don't run two AI tools on the same project at once.** They'll get in each other's way.

## Quick reference

- NodeGX start screen → **Copy the command instead** → paste into your tool → "Please add this MCP server so you can use NodeGX."
- New conversation (or restart the tool) after adding it.
- Keep both `-e` settings; keep the Mac preferences path in one piece.
- Tell the tool to read `CLAUDE.md` in the project folder.
- One AI tool per project at a time.