I've been using Cline for a few weeks to generate Terraform modules and GitHub Actions workflows. It feels fast, but "feels" isn't data.
Has anyone done a proper, apples-to-apples benchmark on a Mac (M-series)? I'm specifically curious about:
* Time to first token
* Time to complete a ~50-line module generation (e.g., an S3 bucket with lifecycle rules)
* Comparison against:
* Cursor's built-in agent
* Claude in Sonnet/Opus via API
* Local models (like Codestral) via Continue.dev
If you've run tests, please share:
* Your Mac specs (M1/M2/M3, RAM)
* The exact test prompt/scenario
* How you measured the time
I'll start. My rough, unscientific test on an M2 Max (64GB):
* Prompt: "Write a Terraform module for a private ECR repository with image scan on push."
* Cline took ~4 seconds to start streaming, ~12 seconds total.
* Cursor's agent took noticeably longer (~7 seconds to start).
But I need more rigorous data. Anyone?
—cp
Hi, I'm a platform engineer at a mid-sized fintech, and I currently manage our team's assisted code generation setup. We run a mix of Cursor and local models via Continue.dev in production to support our AWS (mostly Terraform) and Go services development.
Here is a breakdown from our internal evaluation a few months back, focused on the Mac (M1/M2 Pro) experience you asked about:
**Latency (Time to First Token):** Cline is consistently the quickest in our tests, typically 2-4 seconds. Cursor's agent ranges from 5-9 seconds, often feeling slower due to its initial "thinking" phase. Claude via API (Sonnet) is similar to Cursor, while local models like Codestral via Continue are near-instant but depend entirely on your local GPU memory.
**Throughput for Scaffolding:** For a 50-line Terraform module, total completion time is where the differences show. Cline and Claude Sonnet via API complete in 10-15 seconds total. Cursor often adds 3-5 seconds of overhead. Local models, if they fit in memory, can be faster but risk truncation on longer outputs without careful context window tuning.
**Deployment & Configuration Effort:** Cline and Cursor are essentially zero-config as desktop apps. Claude API requires key management and some light client setup. Local models via Continue.dev require the most effort, involving Ollama or similar, model downloads, and parameter tuning, which can take a few hours to get right.
**Honest Limitation:** Cline's speed and direct editor integration are its main wins, but its model is a smaller, fine-tuned one. For highly complex, multi-file reasoning or refactoring tasks, we still see Claude Opus or the deep analysis from Cursor's agent produce more coherent results, even if they're slower. Cline can sometimes miss broader architectural nuances.
For our team's primary use case of generating boilerplate infrastructure code and simple service scaffolds, I recommend Cline. It's the best balance of speed and accuracy for that specific, repetitive task. If you spend more time on deep refactors or need the strongest possible reasoning, I'd suggest Claude Opus via API despite the slower speed. To make a cleaner call, let us know how much of your work is net-new generation versus complex refactoring of existing code.
Stay curious.