Hands-on AI Coding Tools: Why I Kept Claude Code + Vibe and Dumped Cursor and Continue.dev

April 24, 2026

I spent a week testing every AI coding tool that promised to replace my terminal-based workflow, only to realize most can’t handle real work without cloud dependency or IDE bloat.

Quick Take

Agent mode is non-negotiable for Sovereign AI, Continue.dev’s lack of multi-step tool calling made it useless for anything beyond autocomplete.

Local inference isn’t optional, Cursor’s cloud-only model leaked code and violated privacy guarantees.

The only combo that survived real tasks? Claude Code for complex reasoning and Mistral Small 4 via Vibe for local, private edits.

Why Cursor and Continue.dev Failed Me

Cursor’s biggest selling point is its agent mode, but it’s built on a proprietary VS Code fork that forces you to send code to Anthropic’s servers. That’s a non-starter for a privacy-first setup running a DGX Spark with 128GB unified memory. No ARM64 build exists, and the cloud dependency contradicts the Sovereign AI principle.

# Attempting to run Cursor on ARM64 DGX Spark
$ uname -m
aarch64
$ ./cursor --version
Error: Unsupported architecture (ARM64 not supported)

Continue.dev looked promising as an open-source VS Code extension with local inference support, but it’s stuck in autocomplete mode. It can’t autonomously create files, run shell commands, or handle multi-step tasks—it’s just a smarter tab-completion engine. The DGX Spark’s terminal workflow doesn’t need an IDE, and VS Code’s complexity adds friction where none is needed.

// .continue/config.json
{
  "models": [
    {
      "title": "Local Mistral",
      "provider": "ollama",
      "model": "mistral:latest",
      "apiKey": "ollama"
    }
  ],
  "contextProviders": ["fileSystem"]
}

The fundamental issue became clear when I tried to automate a dependency update:

# Expected behavior: Continue.dev should handle multi-step updates
$ npm outdated
Package  Current  Wanted  Latest  Location
react     17.0.2  18.2.0  18.2.0  ./frontend
$ npm update react
# Continue.dev fails to chain these commands

Why Claude Code + Vibe Won

Claude Code handles complex reasoning and multi-step tasks better than any other tool I tested. It reads files, follows dependencies, and executes commands without losing context. The only catch is it’s cloud-based, so sensitive work stays with Anthropic.

# Running Claude Code on a complex refactor
$ claude --version
Claude Code v1.2.3
$ claude --dir ./src --task "Refactor user authentication to use JWT"
[14:23:22] Reading project files...
[14:23:25] Analyzing dependencies...
[14:23:30] Generating migration plan...
[14:23:35] Executing changes...

Vibe, running Mistral Small 4 (119B) via SGLang on the DGX Spark, provides local inference with privacy guarantees. The alternating-roles bug, where Mistral Small 4 would forget context between tool calls, was fixed in Vibe’s v4.1 patch with a three-pass architecture:

# Vibe v4.1 architecture fix (simplified)
class ContextTracker:
    def __init__(self):
        self.passes = 3  # Read → Analyze → Verify
        self.memory = {}

    def process(self, task):
        for pass_num in range(self.passes):
            if pass_num == 1:  # Analysis pass
                self.memory['context'] = self.read_file(task.target)
        return self.execute(task)

It’s reliable for simple edits, routine file operations, and shell commands:

# Local file edit with Vibe
$ vibe --model mistral-small-4 --file ./config.yaml --task "Update timeout to 30s"
[14:25:01] Reading config.yaml...
[14:25:03] Applying changes...
[14:25:05] Verifying syntax...
[14:25:07] Success: config.yaml updated

The combination works because they complement each other. Vibe handles local, private tasks like updating a config file or committing changes. Claude Code takes over for architecture decisions, debugging, and tasks requiring deep reasoning.

# Workflow example combining both tools
$ git status
On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
        modified:   config.yaml

$ vibe --task "Commit config changes"
[14:26:12] Committing changes...
[14:26:15] Success: config.yaml committed

$ claude --task "Debug authentication failure"
[14:27:01] Analyzing logs...
[14:27:15] Identifying root cause...
[14:27:30] Generating fix...

Where Vibe Still Falls Short

Mistral Small 4’s reasoning gap became obvious when I asked it to add a link to /about#my-stack in the home page. Here’s what happened:

Vibe read the wrong anchor (#my-stack instead of #stack), replaced the entire index.astro file with static HTML (377 lines → 58 lines), reported success without building, and broke the site. The root cause wasn’t Vibe’s patch, it was Mistral Small 4’s inability to track context between tool calls. It forgot file contents, hallucinated commit confirmations, and oversimplified tasks when given write_file commands.

<!-- Before (index.astro) -->
<a href="/about#stack">My Stack</a>

<!-- After Vibe's edit -->
<a href="/about#my-stack">My Stack</a>
<!-- Entire file replaced with static HTML -->

The fix? A strict workflow in VIBE.md:

## Vibe Workflow Rules

1. **Read First**: Always read target files before editing
   ```bash
   $ vibe --task "Read index.astro"

Verify Anchors: Check anchor existence

$ grep -n "#stack" index.astro
42:  <a href="/about#stack">My Stack</a>

Minimal Edits: Use apply_patch instead of write_file

{
  "task": "Update link anchor",
  "commands": [
    {"type": "read_resource", "path": "index.astro"},
    {"type": "apply_patch", "path": "index.astro", "diff": "42c42\n<   <a href=\"/about#stack\">My Stack</a>\n---\n>   <a href=\"/about#my-stack\">My Stack</a>"}
  ]
}

Build and Test: Always verify changes
```
$ npm run build
$ npm run test
```

Commit: Only commit after verification

$ git add index.astro
$ git commit -m "Fix: Update link anchor to #stack"

Confirm: Double-check the commit
```
$ git show --stat
```


This prevents the worst failures, but Mistral Small 4 still forgets rules mid-task. The realistic division of labor is:

- **Simple edits, builds, and commits** → Vibe
- **Multi-step tasks with dependencies** → Claude Code
- **Architecture and debugging** → Claude Code
- **Sensitive data** → Vibe

```bash
# Example of a task that should NOT go to Vibe
$ claude --task "Refactor authentication middleware across 15 files"
# Vibe would fail on this due to context tracking limitations

What’s Next for This Setup

The plan is to keep this combo until one of three things happens:

Continue.dev adds multi-step tool calling Current roadmap shows no ETA for agent mode:

// .continue/roadmap.json
{
  "features": [
    {"name": "Multi-step tool calling", "status": "backlog", "priority": "low"},
    {"name": "Shell command execution", "status": "planned", "priority": "medium"}
  ]
}

Cursor releases a true offline mode with local model support Current offline mode still requires cloud fallback:

# Cursor offline mode limitations
$ cursor --offline --model local:mistral
Error: Local model support not yet implemented

A new tool emerges that combines:
- Local inference
- Agent mode
- Open-source licensing
- Native ARM64 support

Until then, Claude Code + Vibe is the only stack that meets the Sovereign AI requirements without sacrificing functionality.

What I Actually Use
Claude Code: Cloud-based agent for complex reasoning and multi-step tasks where Mistral Small 4 fails.
$ claude --version
Claude Code v1.2.3
Vibe: Local Mistral Small 4 via SGLang for private, simple edits and routine file operations.
$ vibe --model mistral-small-4 --version
Vibe v4.1.2 (SGLang backend)
DGX Spark (GB10, ARM64, 128GB unified memory): The hardware that makes local AI inference possible without cloud dependency.
$ nvidia-smi
NVIDIA-SMI 535.129.03  Driver Version: 535.129.03
GPU  GB10 (ARM64)  128GB VRAM

Additional Caveats and Gotchas

Vibe’s patch version dependency: The three-pass architecture fix only works in v4.1+:

$ pip install vibe-coding==4.1.2
ERROR: Package 'vibe-coding' requires Python >=3.10

SGLang backend limitations: Mistral Small 4’s context window struggles with large files:

$ vibe --file ./large-monolith.js --task "Refactor"
[15:42:11] Warning: File exceeds context window (2048 tokens)

ARM64 performance issues: Some Python packages lack native ARM64 wheels:

$ pip install torch
ERROR: No matching distribution found for torch

Claude Code’s cloud dependency: Even simple tasks require internet:

$ claude --task "List files"
[16:01:22] Error: Network connection required

Vibe’s patch application failures: When Mistral Small 4 misapplies patches:

$ vibe --task "Update package.json version"
[16:15:03] Applied patch with errors
[16:15:05] File corrupted: package.json

DGX Spark thermal throttling: Sustained AI workloads trigger thermal protection:
```
$ sudo nvpmodel -q
GPU current temp: 87°C (throttling at 85°C)
```

Model version mismatches: Vibe’s default model may not match your local setup:

$ vibe --list-models
Available models:
- mistral-small-4 (default)
- codestral-latest
- llama3-instruct

File permission issues: Local edits may create permission problems:

$ vibe --file /etc/nginx/sites-available/default --task "Update server_name"
[17:22:10] Error: Permission denied