Comparison
Frontman vs Cursor
Your Whole Team Can Ship UI Changes — Not Just Engineers
If you have a design system and a growing product team, you know the bottleneck: every spacing tweak, copy change, or component adjustment becomes a ticket for engineering. Designers spec it, PMs prioritize it, and developers implement it days later. The feedback loop is slow and expensive.
Frontman is an open-source AI agent that lives in your browser, right alongside your running app. Designers and PMs click elements, describe changes in plain English, and Frontman edits the actual source files — producing real code diffs engineers can review. No IDE required. It integrates with your framework (Next.js, Astro, or Vite) as a plugin and uses a browser-side MCP server to see live DOM, computed styles, and rendered components.
Cursor is a commercial AI-powered IDE based on VS Code. It's excellent for engineers — tab completion, agentic coding, multi-file refactoring, terminal integration. But it requires IDE proficiency and doesn't natively see what your app renders in the browser.
The core difference: Cursor makes engineers faster in the IDE. Frontman lets your whole team — designers, PMs, and engineers — iterate on UI together in the browser. Many teams use both.
Disclosure: This page is published by the Frontman team. We've done our best to present Frontman and Cursor accurately and fairly, but we are naturally biased toward our own product. We encourage you to try both tools and decide for yourself.
How Frontman and Cursor Work
Feature Comparison
| Feature | Frontman | Cursor |
|---|---|---|
| Designer/PM friendly | Click elements, describe changes — no IDE needed | Requires IDE proficiency |
| Works in the browser | Opens alongside your running app | VS Code fork — desktop IDE |
| Click-to-select elements | Visual component selection | Must describe or find in file tree |
| Sees live DOM & styles | Browser-side MCP server inspects the live page | File-only context by default |
| Sees computed CSS | Runtime values, not class names | Reads source files; can extend via MCP |
| Hot reload feedback loop | Instant in browser | Can trigger builds via agent, doesn't see browser result |
| Framework-aware | Deep plugin integration with Next.js, Astro, Vite | MCP servers, .cursorrules, project context |
| File-based editing | Edits source files — real code, not overrides | Full file system access |
| Autocomplete | | Tab completion, inline suggestions |
| Multi-file refactoring | Can edit multiple files, but not its primary workflow | Cross-file edits, Composer, agent mode |
| Terminal integration | | Built-in terminal, agent mode, cloud agents |
| Backend coding | Can read/write any project file, but frontend-focused | Any language, any framework |
| Open source | Apache 2.0 / AGPL-3.0 | Proprietary |
| BYOK (bring your own key) | OpenRouter, Anthropic, OpenAI | API key mode, bring your own models |
| Self-hostable | | |
Designer/PM friendly
Works in the browser
Click-to-select elements
Sees live DOM & styles
Sees computed CSS
Hot reload feedback loop
Framework-aware
File-based editing
Autocomplete
Multi-file refactoring
Terminal integration
Backend coding
Open source
BYOK (bring your own key)
Self-hostable
What Cursor Does Well
Cursor makes developers faster if you already live in an IDE. It's popular for good reason.
Autocomplete is best-in-class. Tab completion understands your codebase, predicts multi-line edits, and learns from your patterns. For raw typing speed, nothing in this comparison comes close.
Agent mode is powerful. Cursor's agent can plan multi-step changes, run terminal commands, interpret output, and iterate on errors — all within the IDE. Cloud agents and background agents let work continue asynchronously. Frontman's AI agent is focused on browser-visible changes, not general-purpose coding workflows.
Multi-file refactoring works. Cursor's Composer and agent mode can rename a prop across 15 files, update imports, and fix type errors in one pass. Frontman can edit multiple files, but it's not its primary workflow.
Backend and general-purpose coding. Cursor handles Python, Go, Rust, SQL, infrastructure-as-code — any language, any project. Frontman is frontend-focused. It can read and write any project file, but its strengths are in visual editing where browser context matters.
Terminal integration. Cursor's terminal agent can run commands, read output, and fix errors automatically. Frontman has no terminal — it captures console logs and build errors from the dev server, but cannot run arbitrary commands.
Cursor supports MCP servers, allowing it to connect to external tools, databases, APIs, and even browser automation. Combined with .cursorrules for project-specific context, this makes Cursor highly customizable.
Cursor has millions of users, extensive documentation, and a mature extension ecosystem inherited from VS Code.
Where Frontman Is Different
Your whole team can touch the UI. Designers click the element that needs work, describe the change in plain English, and Frontman edits the actual source files. PMs can adjust copy, spacing, or component props without filing a ticket. Engineers review the diff like any other PR. Everyone works from the same running app — no Figma-to-code translation step, no "can you move this 4px to the left" Slack threads.
It sees what the browser sees. Cursor reads your JSX files, but by default it has never seen what they render. It doesn't know that your hero section overflows at 768px, that the computed font size is 18px not 16px, or that a sibling component's margin is pushing your layout. Frontman integrates with your framework as a plugin and runs a browser-side MCP server that inspects live DOM, computed CSS, viewport layout, and rendered component hierarchy. When you click an element, Frontman resolves the source location via source maps and knows exactly which file, component, and line rendered it.
Click-to-edit workflow. Instead of describing which file to open, you click the element you want to change. The AI already knows the component, its source location, its styles, and its context in the rendered page. "Make this card's shadow more subtle" works because Frontman can see the card.
Hot reload closes the feedback loop. Frontman edits actual source files, and the framework's built-in HMR handles live reloading automatically. Edit, see result, edit again happens in the browser without switching windows. A designer can iterate through three variations in the time it takes to write one Jira ticket.
Real code, not overrides. Every change Frontman makes is a source file edit — the same code your engineers write by hand. No visual-editor CSS overrides, no separate layer to maintain. Changes go through your existing review process and ship like any other commit. Your design system stays clean.
Open source and BYOK. Frontman is free while in beta, with per-seat team pricing coming soon. The client libraries are Apache 2.0 and the server is AGPL-3.0 — self-hosting will always be an option. You bring your own API keys to Anthropic, OpenAI, or OpenRouter — or sign in with your Claude or ChatGPT subscription via OAuth.
Who Should Use Cursor
Cursor is the better choice for engineers who want AI in their IDE. Specifically:
- Backend developers working in Python, Go, Rust, or any non-frontend language
- Large codebase refactoring — renaming across dozens of files, updating APIs, migrating patterns
- Agentic coding workflows — if you want the AI to plan, execute, and iterate across files and terminal
- Autocomplete-dependent workflows — if inline suggestions are core to how you code
- Full-stack work where you move between frontend and backend in the same session
- Teams standardized on VS Code — Cursor inherits the entire VS Code extension ecosystem
Who Should Use Frontman
Frontman is built for product teams where UI iteration is a bottleneck — not just individual developers. Specifically:
- Design system teams at growing startups — your system is live, your components are real, and you need designers and engineers iterating on them together without a Figma-to-ticket-to-PR bottleneck
- Designers who want to iterate directly on the product — click elements in the running app, describe changes, and see results instantly. No IDE, no terminal, no waiting for engineering capacity
- PMs who ship small UI changes themselves — update copy, adjust spacing, tweak component props. Every change is a real code diff your engineers can review
- Engineering leads reducing design-to-code handoff friction — fewer "make it match the Figma" tickets, more direct iteration on the actual product
- Teams using Next.js, Astro, or Vite — deep framework plugin integration means Frontman understands your component structure, not just file contents
- Companies with security or compliance requirements — open source (Apache 2.0 / AGPL-3.0), self-hostable, BYOK. Free during beta with team pricing coming soon
Many teams use both tools. Engineers use Cursor for backend work, refactoring, and general-purpose coding. The broader product team uses Frontman for visual iteration in the browser.
For a deeper technical comparison including Claude Code, read our full comparison of Frontman, Cursor, and Claude Code. Also see: Frontman vs Stagewise for a comparison with another browser-based tool.
Pricing Comparison
Frontman
Open source, BYOK
- Unlimited usage, no caps or credits
- Bring your own API keys (Claude, ChatGPT, OpenRouter)
- Or sign in with Claude/ChatGPT subscription via OAuth
- Apache 2.0 (client) / AGPL-3.0 (server)
- You pay your LLM provider directly
Cursor
Freemium, proprietary
- Hobby: Free — limited agent + tab completions
- Pro: $20/mo — extended agent, unlimited tabs
- Pro+: $60/mo — 3x usage on all models
- Ultra: $200/mo — 20x usage, priority access
- Teams: $40/user/mo — shared usage, SSO
- API key mode available (full BYOK)
Cursor Alternatives
If Cursor isn't the right fit, here are other tools worth evaluating — and how they compare to Frontman.
Frontman
Open-source AI agent in your browser. Designers and PMs click elements, describe changes, ship real code.
Frontman vs Claude Code
Terminal-based AI coding agent from Anthropic. Powerful for backend and full-stack work.
Frontman vs GitHub Copilot
AI pair programmer in VS Code and JetBrains. Autocomplete-focused with chat and agent features.
Frontman vs Windsurf
AI-native IDE with Cascade agent for multi-step coding workflows.
Frontman vs Stagewise
Browser-based visual editing toolbar. Lightweight, frontend-focused.
Frequently Asked Questions
Can our designers actually use Frontman without learning an IDE? +
Yes. Frontman runs in the browser alongside your running app — no VS Code, no terminal. Designers click elements they want to change, describe the update in plain English, and see results via hot reload. Every change produces a real source file edit that engineers can review as a normal pull request. The interface is the browser they already know.
Will this break our design system or create code engineers have to clean up? +
No. Frontman edits the same source files your engineers write — real component code, not CSS overrides or a separate layer. Changes go through your existing code review process. Because Frontman integrates as a framework plugin (Next.js, Astro, or Vite), it understands your component structure and source maps. Engineers review and merge like any other PR.
Can Frontman replace Cursor for our engineering team? +
For frontend visual editing — clicking elements, adjusting layout, fixing CSS — yes. For agentic coding workflows, autocomplete, terminal integration, or large codebase refactoring, no. They serve different roles on the team. Many teams use Cursor for backend and general-purpose engineering, and Frontman for cross-functional UI iteration where designers and PMs are involved.
Does Frontman work alongside Cursor? +
Yes. Engineers use Cursor as their IDE for backend and general coding. Designers and PMs use Frontman in the browser for visual changes. Both edit the same source files. Changes from either tool are reflected through normal file watching and hot reload.
What does Frontman see that Cursor doesn't? +
Frontman integrates with your framework as a plugin and runs a browser-side MCP server that inspects the live DOM tree, computed CSS styles (not just class names), viewport layout and spacing, and can take screenshots and emulate different devices. The framework plugin captures console logs, build errors, and resolves source locations via source maps. Cursor reads your source files and doesn't natively see what they render — though it can connect to browser tools via MCP servers, that requires additional setup.
How does pricing work for a team with designers, PMs, and engineers? +
Frontman is free while in beta. We plan to introduce per-seat team pricing — details are coming soon. The client libraries are Apache 2.0 and the server is AGPL-3.0, so self-hosting will always be an option. You bring your own API keys to Anthropic, OpenAI, or OpenRouter, or sign in with your Claude or ChatGPT subscription via OAuth.
Try Frontman
One command. No account. No credit card. No prompt limits.
$ npx @frontman-ai/nextjs install Next.js $ npx @frontman-ai/vite install Vite (React, Vue, Svelte, SolidJS) $ astro add @frontman-ai/astro Astro