Why Cursor and Claude Code Struggle to Build a Whole Internal Tool
Coding agents edit code you already have. Building an internal tool from scratch is a different job — here's why it needs a different agent.
The Short Answer
Coding agents like Cursor and Claude Code are built to edit code inside a project that already exists — a repo, a schema, a deploy pipeline someone already set up. Ask one to build a whole internal tool from a blank page, and it has to first invent all the scaffolding a real app needs (auth, a database, hosting, a deploy target) before it can even start on the feature you asked for. That’s not a bug in either tool. It’s a different job than the one they were built for. A product agent like Remy is built for that other job: it compiles a plain-language plan into a deployed, full-stack application in one step. For a team, the two aren’t rivals — Cursor and Claude Code keep doing the code-editing work they’re best at, while a product agent takes on the apps that need to be stood up from nothing.
TL;DR
- Coding agents like Cursor and Claude Code are strongest when a repo, schema, and deploy setup already exist — their whole loop assumes a codebase is there to edit.
- Starting an internal tool from zero forces a coding agent to improvise auth, a database, and hosting decisions before it even reaches the feature you actually wanted.
- A product agent compiles a plain-language plan into a full application — backend, database, auth, frontend, and a live deploy — in a single pass.
- The core difference is spec-driven compilation versus prompt-driven code generation: one keeps a plan as the source of truth, the other keeps a chat log as the only record of intent.
- When a stronger model ships, a product agent can recompile the same plan into a better app, while a coding-agent project has to be re-prompted by hand.
- Internal tools like approval flows, trackers, and dashboards are exactly the shape of app where owning a real backend from the first minute matters more than fine-grained code control.
- Coding agents remain the better tool for changing something that already works, and teams typically run both, each on the work it fits.
- Every app Remy builds ships as standard TypeScript in a git repo you own, so picking a product agent for the first build doesn’t lock anyone out of hand-editing later.
Seven tools to build an app. Or just Remy.
Editor, preview, AI agents, deploy — all in one tab. Nothing to install.
What Does a Coding Agent Actually Assume Is Already There?
Cursor, Claude Code, and Codex are strong at one specific job: sitting inside a codebase and making changes to it. Point one at a repo, describe the change, and it reads the surrounding files, makes an edit, and runs the tests. That loop is the whole product.
The assumption baked into that loop is a codebase. A schema. A framework choice already made. A deploy target someone configured last quarter. Ask a coding agent to build an internal tool from nothing, and it has to answer questions no one asked it to think about: Postgres or SQLite? Where does auth live? What’s the hosting story? Those aren’t wrong answers when a coding agent gives them — they’re just decisions a fresh project shouldn’t have to make ad hoc, and a different decision every time someone starts a new project from scratch.
That’s why the same coding agent that moves fast deep into a project can stall on day zero: there’s often nothing to edit yet. For a deeper look at where that split comes from, see Product Agent vs Coding Agent: The Category Is Splitting in Two.
What Is a Product Agent, and How Is It Different?
A product agent starts from a plan instead of a prompt. You describe what you need — an approval workflow, a vendor tracker, an onboarding portal — in plain language. Remy drafts that description into a structured spec, and you read it back, approve it, and tweak anything that’s off before a single line of code exists. (For the mechanics of how that spec format works, see What Is Spec-Driven Development? When the Spec Becomes the Source Code.)
From that spec, Remy compiles the whole application in one pass: a real backend, a serverless SQL database, authentication, a frontend, and a deploy to a live URL. Nobody picks a database engine or wires up a login flow by hand — that’s the platform underneath, not a decision made fresh on every project. Underneath, six sub-agents (Coding, Design, Roadmap, QA, Architecture, and Research) handle the parts of the build a person would otherwise juggle by hand.
The distinction that holds even as both categories keep shipping new features is spec-driven compilation versus prompt-driven code generation. App builders and coding agents alike tend to be prompt-driven code generators: you chat, they emit code, and the chat log is the only record of what you actually wanted. Remy is spec-driven compilation — the spec is the source of truth, and code is compiled output. Change the plan, hit Publish to deploy to a live URL, and the app catches up — no re-prompting your way back to where you were.
How Does Remy Stay Useful as AI Models Improve?
This part compounds. When a stronger coding model ships, a coding-agent project doesn’t automatically get better — someone has to go back and re-prompt the parts worth revisiting, one file at a time. Because the spec is the source of truth in Remy, recompiling against a newer model upgrades the app without anyone re-describing what they wanted in the first place. The plan didn’t change; the compiler underneath it did.
For a one-off script or a bug fix, that difference barely registers. For an internal tool that a team is going to run for two years, it’s the difference between an app that keeps pace with newer models and one that’s frozen at whatever a model could do the day it was built.
Which Workloads Actually Fit Which Tool?
A coding agent and a product agent are built for different jobs, and most teams end up running both side by side rather than choosing one for everything.
Coding agents fit:
- Editing a codebase that already exists and already deploys
- Small, surgical changes — a new endpoint, a bug fix, a refactor
- Projects where the engineer wants line-by-line control over every diff
Product agents fit:
- Standing up a new internal tool from a description, with no existing repo
- Apps that need real auth, a real database, and a live deploy on day one
- Teams who want the plan, not the chat history, to be the record of what the app is supposed to do
Internal tools like vendor approvals, onboarding portals, and inventory dashboards often sit squarely in the second category. They usually start from nothing, they need production-shaped infrastructure immediately, and the person building them is often not trying to hand-tune a database schema. That’s a plan-to-app problem, not a code-editing problem — though the same approach applies to plenty of full-stack apps beyond internal tools. Once that tool is live, a coding agent is often exactly what a team reaches for to make a small follow-on change — the two tools cover different stretches of the same tool’s life rather than competing for the same job. (For a sense of what a first build like this looks like in practice, Five Internal Tools You Can Ship with AI in an Afternoon walks through the shape of a handful of them.)
How Does a Product Agent Compare to a Coding Agent on a New Internal Tool?
| Coding agent (Cursor, Claude Code) | Product agent (Remy) | |
|---|---|---|
| Starting point | An existing repo and codebase | A plain-language description |
| Source of truth | The chat log and the current code | The spec, reviewed and approved by you |
| Database, auth, hosting | Decided ad hoc, per project | Included automatically on every build |
| Best job | Editing what already exists | Compiling a full app from a plan |
| When models improve | Re-prompt manually to catch up | Recompile the spec into a better app |
| Output ownership | Code you own, in the repo you already had | Standard TypeScript in a new git repo you own |
Can a Coding Agent Handle the Whole Build on Its Own?
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
It can — a coding agent is capable of producing a working internal tool if someone is willing to make every infrastructure decision along the way and keep re-prompting as things change. The tradeoff is that all of that setup work, and all of the maintenance that follows, sits on the person driving the tool. That’s a reasonable choice for a highly specific, highly customized build where line-level control matters more than speed. It’s a less efficient fit for the fifth internal tracker a team needs shipped this quarter, where the actual goal is a working app, not a bespoke stack.
If the goal is editing an app that’s already live, a coding agent is still the right tool for that job — Remy vs Cursor: When You Need a Product Agent, Not a Coding Agent and Remy vs Claude Code: One Builds Apps, One Edits Code explain that split in more detail. The two tools aren’t rungs on the same ladder; they’re suited to different moments in an app’s life, and it’s common for the same team to keep both in rotation.
What Is Remy?
Remy builds and runs the software your team would otherwise rent. Describe what you need, and it ships as standard TypeScript in a git repo you own.
Unlike coding agents like Cursor or Claude Code — which edit code in a project you already own — or prototyping platforms like Lovable or Bolt — which generate a frontend you keep re-prompting — Remy builds the whole application, runs it, and hands you the repo. A project from idea to deployed app typically runs $100-500 in tokens, on a plan that’s $99/mo ($79 annual). Try Remy to see it compile a spec into a live app. For a fuller breakdown of the category split, see What Is a Product Agent? The AI That Ships a Whole App, Not Code.
FAQ
Can Cursor or Claude Code build a whole internal tool from scratch? Yes, but someone has to make every infrastructure decision along the way — database, auth, hosting — before the actual feature work starts, and keep re-prompting as the project grows.
What’s the actual difference between a coding agent and a product agent? A coding agent edits code inside a project that already exists. A product agent compiles a plain-language plan into a complete, deployed application in one step.
Do I need an existing codebase to use Cursor or Claude Code effectively? Not strictly, but that’s the workflow both tools are optimized for — reading and editing files in a project that’s already set up.
Is a product agent just a coding agent with extra steps? No. The spec is the source of truth in a product agent; in a coding agent workflow, the chat log is the only record of intent, and there’s no plan to recompile later.
What kinds of apps are best suited to a product agent instead of a coding agent? Apps starting from zero that need real auth, a real database, and a live deploy right away — internal tools like approval workflows, trackers, and dashboards are a common example, though the same approach fits a broad range of full-stack apps.
If I build with Remy, can I still hand-edit the code later? Yes — every app is standard TypeScript in a git repo you own. The way to keep the app in sync going forward is to update the spec and recompile, which keeps the plan as the accurate record of what the app does.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
How does Remy stay useful as AI models improve? The spec is the source of truth. Recompile it and the app upgrades to whatever the underlying model can now do — no manual re-prompting required.
Do teams use Remy alongside Cursor or Claude Code, or instead of them? Both. Many teams keep coding agents for editing existing codebases and reach for a product agent when they need to stand up a new internal tool from a description, with a real backend from the first minute.
The Bottom Line
Coding agents and product agents solve different problems because they start from different places — one from a codebase, one from a plan. For a new internal tool, starting from a plan usually wins: less setup, a real backend from minute one, and an app that gets better on recompile instead of needing another round of prompts every time a model improves. None of that retires the coding agent already in a team’s toolkit — it just means the two get used for the parts of the work each one is actually built for.
Remy builds and runs the software your team would otherwise rent. Describe what you need, and it ships as standard TypeScript in a git repo you own.
