Switched from Tabnine to Cursor, here is why I'm going back for local models.

Hey folks,

I've been living in the CI/CD and K8s observability trenches for a while now, and my editor's AI companion is a critical piece of that workflow. For the last six months, I made the jump from my long-time buddy Tabnine to Cursor, drawn in by the promise of deeper agentic workflows and tighter integration. I've been using it daily for everything from writing complex GitHub Actions workflows and tuning Prometheus queries to debugging Helm chart templating errors. And while Cursor is genuinely impressive—its codebase-aware features are stellar for navigating our monorepo—I've recently decided to shift my primary setup *back* to Tabnine. But it's not a full retreat; it's a strategic repositioning. Here's my detailed breakdown.

**Why I initially switched to Cursor:**
* **Project-level context:** The ability to have the AI understand multiple files for a task, like tracing a variable through a pipeline config, a Dockerfile, and a deployment script, was a game-changer.
* **Agent mode for tedious tasks:** Letting it run loose to fix an entire set of linter errors across a directory or generate a suite of monitoring alerts based on a spec saved me hours.
* **The chat interface** felt more powerful for complex, iterative debugging of a flaky test or a convoluted `kubectl` command chain.

**The friction points that emerged (my "why" for going back):**
This is the core of it. For my daily *local* coding—the quick completions, the inline suggestions, the muscle-memory-driven flow—I started feeling a lag, both in latency and context.

1. **Latency & Dependency on the Network:** When I'm in the zone, crafting a new Grafana dashboard JSON model or writing a Python script for log parsing, I need near-instantaneous suggestions. Even minor network hiccups introduced a cognitive drag. With Tabnine's local models, the completions feel like a part of the editor itself.
2. **Context Switching Cost:** With Cursor, I felt compelled to "use it properly"—opening the chat, framing the problem with `/docs`. For small, routine things (completing a common `awk` one-liner for log filtering, or writing a standard `kustomization.yaml`), this became overkill. Tabnine's suggestions pop up right where I'm typing, with zero ceremony.
3. **Pricing & Predictability:** My usage is bursty. During a major incident or a release automation overhaul, I might generate thousands of lines of code and config. Other times, it's quiet. Tabnine's unlimited local model use gives me cost predictability, which as someone who also manages cloud budgets, I deeply appreciate.

**My new hybrid workflow strategy:**

So, I'm not *abandoning* Cursor. I'm redefining its role. My plan is now this:

* **Tabnine (Local/Small Models):** My **primary daily driver** for inline completion. It's always on, providing that frictionless, low-latency assist for 80% of my coding tasks. Its understanding of YAML, JSON, and Go (for our operators) is more than sufficient for boilerplate and common patterns.
```yaml
# Tabnine just effortlessly completes these kinds of repetitive K8s spec blocks
- name: {{ include "app.fullname" . }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: {{ .Values.image.pullPolicy }}
ports:
- name: http
containerPort: 8080
protocol: TCP
```

* **Cursor (Cloud/Agent Mode):** My **specialist tool**. I'll keep a subscription for when I need that deeper project intelligence. I'll open it specifically for:
* Major refactors of our Jenkinsfile libraries.
* Analyzing error logs across multiple services to propose a root cause.
* Writing a completely new Terraform module from a rough sketch.
* Using the agent to run a one-off script to clean up or reorganize a directory structure.

The warmth and depth of Cursor's chat for complex problems is unmatched. But for the daily grind of writing configs, scripts, and even application code, the speed and predictability of a good local model win out for me. It feels like having a brilliant consultant (Cursor) on retainer for big projects, but a incredibly efficient pair-programmer (Tabnine) sitting right beside me for every single line.

Has anyone else settled into a similar split-brain approach? I'm curious how others balance these tools in their SRE/DevOps workflows.

—jr