People keep asking which one to pick, PaellaDoc or Cursor, and the question is built on a wrong assumption. They are not the same kind of tool. Cursor is the editor where you sit and write code with AI next to you. PaellaDoc is the layer above the editor: it runs coding agents on tasks, checks whether their output is actually right, turns the work into product artifacts, and keeps all your repos in one place. You can use both at once. In fact you can open the work an agent produced in Cursor and keep editing it there.
What Cursor does
Cursor is an AI-native code editor, a fork of VS Code, and a very good one. You write and edit code inside it with AI in the loop the whole time: inline edits where you select code and tell it what to change, a chat panel that knows your file, tab completion that guesses the next edit, and an agent mode that can make multi-file changes for you. The inner loop, the moment-to-moment feel of writing code with a model helping, is what Cursor is about and it is excellent at it. Adoption is enormous and the polish shows. If your day is spent in a file, hands on the code, Cursor is one of the best places to be.
PaellaDoc does not try to be that. We are not building an editor and you should not drop Cursor to use us.
What PaellaDoc does
PaellaDoc runs coding agents for you. You give it a task, it spins up an agent (Claude Code, Codex, Kimi, any CLI agent) in an isolated git worktree on your machine, model-agnostic, on your own subscription. While Cursor is where a person edits code, PaellaDoc is where agents do runs of work and you decide what counts as finished.
The piece that matters most is the gate. Before an agent starts, you write acceptance criteria. When the agent says it is done, PaellaDoc does not believe it. It runs the code against those criteria on the real diff. A build that compiles green is not “done”. The feature has to actually do what you said it should do, or the gate stays red. That is the whole point of the thing.
Around that, PaellaDoc gives you a control room for all your repos (in the AI era you have a hundred of them on your machine, scattered, and nobody opens them), a no-coder mode that builds a product from a plain description for someone who cannot read a diff, reverse intake that reads an existing repo and reconstructs the product context, and Telegram control so you can start a run or approve a step from your phone.
The key difference: editor vs the layer above
Cursor answers “how do I write this code faster”. PaellaDoc answers “did the agent build the right thing, and is it product yet”. Those are different jobs at different altitudes.
In Cursor you are the one moving through the file. You read every change, you accept or reject it, you are the verification. That works because you are right there. PaellaDoc exists for the moment when you are not right there: the agent ran on its own, in its own worktree, maybe three agents on three tasks, and something has to decide whether the output is correct without a human reading every line. That something is the gate, and it runs your criteria against the real code, not a vibe check.
So it is not either/or. Cursor is your editor. PaellaDoc is the orchestration plus verification plus product layer on top. Open the work in Cursor when you want to get your hands dirty. Let the gate catch what looking at a green build never would.
Why the gate exists
We ran a public benchmark, 210 runs. A raw agent’s output passed the build but was genuinely wrong about 40% of the time. And the strongest frontier model, at maximum effort, failed a hard task on 2 out of 3 runs, different runs each time, so you could not even predict it. A green build is not a correct feature, and “the tests are green” tells you less than people assume when the agent wrote the tests too. The gate is our answer to that number. It runs your criteria, on the diff, every time, instead of trusting that compiling means working.
Code, or product
There is a second thing Cursor does not try to do, and it is the part we care about most. The code an agent writes is an output. The product is the thing around it: the PRD, the epics, the user stories, the acceptance criteria, the reasons. In Cursor that context lives in your head and in scattered chats. In PaellaDoc it becomes versioned, comparable .paella artifacts that sit in your repo and travel with it.
That is driven by an open SDK and four kinds of community pack: method packs (the methodology), stack packs (your tech stack), design packs (theming and design tokens), validator packs (the gates themselves). You pick the packs, the work comes out as product, not just a diff that happened to land. You make product, not just code.
PaellaDoc does not replace your editor
To be clear, because this is the whole framing: PaellaDoc does not replace Cursor and is not trying to. It runs above it. The natural setup is Cursor as the place you write and edit, PaellaDoc as the layer that runs agents, gates their output, and keeps your product and your repos organized. When you want to take an agent’s work into a file by hand, open it in Cursor. We are happy to be the floor under your editor, not a swap for it.
What we share
Both run AI on real code on your machine. Both have an agent mode that makes multi-file changes. Both are model-flexible to a degree. And we will say the plain thing: Cursor is far more mature, far better funded, vastly more polished, and used by orders of magnitude more people. The editing experience is years ahead of anything we do at the file level, because we do not do that level at all. PaellaDoc is early and built by one person. Where Cursor is ahead, it is clearly ahead.
| Capability | Cursor | PaellaDoc |
|---|---|---|
| AI inline editing in a file | Yes | No, open in Cursor |
| Tab completion / inner loop | Yes | No |
| Agent mode (multi-file changes) | Yes | Yes |
| Runs agents in isolated git worktrees | No | Yes |
| Execution gate: output run vs criteria you wrote first | No | Yes |
| Versioned product artifacts (.paella: PRD, stories, criteria) | No | Yes |
| Open SDK + community packs (method/stack/design/validator) | No | Yes |
| Reverse intake of an existing repo | Partial (context) | Yes (product context) |
| Multi-repo control room | No | Yes |
| No-coder mode (product from a description) | No | Yes |
| Telegram remote control | No | Yes |
| Maturity, polish, funding, adoption | Ahead | Early, solo founder |
Who each is for
Use Cursor if your day is hands-on the code and you want the best moment-to-moment experience writing and editing with AI. That is the job it is built for and it does it better than almost anything. If all you need is a great editor with a model in it, you do not need us.
Reach for PaellaDoc when the question stops being “write this faster” and becomes “run agents on tasks, prove the output is right before it ships, and make the work into product I can version and reuse”. When you have a hundred repos and no idea what is in them, when you want a gate that runs your criteria instead of trusting a green build, when someone who cannot read a diff needs to ship a product, that is our job. And you keep Cursor open the whole time.
PaellaDoc is not a better Cursor. It is a different layer doing a different job, and the cleanest setup uses both. Cursor is where you write the code. PaellaDoc decides whether it was the right code and turns it into product. See the rest of the comparisons if you want the wider picture.