Cursor has gone from a niche editor that a handful of Silicon Valley engineers tweeted about in 2023 to one of the most talked-about pieces of business software on the planet. UK founders and agency owners who have never thought of themselves as developers are suddenly asking whether they should be using it. This guide is the long, honest version of the answer — what Cursor is, how it actually works, who it is for, how to set it up, what it costs, where it genuinely shines, where it stumbles, and how it compares to Claude and to the other AI editors fighting for the same space.
I am not a Cursor reseller. I run Claudable, a UK training business that teaches teams to use Claude. That is a bias I will own up to throughout. Where Cursor is better than Claude for a given job, I will say so. Where it is not, I will say that too. If you want the short version — a punchy comparison of the two — the Related: short head-to-head comparison of Claude vs Cursor page is the piece to read first. This one is the long form.
Who this guide is for. UK technical founders, product managers, agency directors, and non-engineer operators who have heard "we should look at Cursor" in a meeting and want a grown-up overview before buying licences for the whole team.
What Cursor is, in one paragraph
Cursor is an AI-native code editor built by Anysphere, an American startup founded in 2022 and funded by, among others, Andreessen Horowitz and the OpenAI Startup Fund. Technically, it is a fork of Microsoft's Visual Studio Code — the open-source editor most of the world's developers already use — with a set of AI features bolted into the core of the product rather than added as an extension. Under the bonnet it calls out to the big foundation models (Claude from Anthropic, GPT from OpenAI, Gemini from Google) depending on what you ask. The product you are paying for is not the model; it is the editor that stitches those models into your real codebase, your files, your terminal and your Git history.
A brief history, and why everyone is talking about it now
Cursor launched quietly in early 2023. For the first year it was treated as a curiosity — a clever side project that offered better autocomplete than GitHub Copilot. Two things changed that. First, in 2024 Anthropic's Claude 3.5 Sonnet turned out to be unusually good at writing production code, and Cursor was quicker than any other editor to expose it well. Second, Cursor shipped the Composer and later the Agent features, which moved the product from "better autocomplete" to "write a brief, review a plan, let the editor edit twelve files for you." By mid-2025 the company was reportedly turning over hundreds of millions in annual recurring revenue. By 2026 it is not an exaggeration to say that Cursor has reshaped what people expect a code editor to do.
That is the context. The reason UK business owners are asking about it is simple: when your developers suddenly ship twice as fast, or when a product manager shows up on Monday with a working prototype she built over the weekend, the thing she used probably had a cursor in the corner.
How Cursor actually works: the four features you need to know
1. Cmd-K (inline edit)
Select a chunk of code, press Cmd-K (Ctrl-K on Windows), and type a natural-language instruction: "add error handling for the case where the API returns 429", "rewrite this in TypeScript", "convert this React class component to hooks". Cursor shows a diff, you accept or reject. This is the feature you will use most often. It is Cursor's answer to "I know what I want to change, and roughly how, but I cannot be bothered to type all of it."
2. Cmd-L (chat with your code)
Press Cmd-L to open the chat sidebar. You can paste code, @-mention files, folders or your whole codebase, and ask questions — "what does this function do?", "where is the stripe webhook handled?", "why is this test failing?" This is the feature that makes a legacy codebase legible to someone who did not write it. For UK agencies inheriting client projects, it is the single biggest unlock.
3. Composer (multi-file edits)
Composer takes a brief that spans multiple files — "add a new API endpoint for cancelling a subscription, wire it into the dashboard, and update the tests" — and proposes a coordinated change across all of them. You review the diff file by file. Composer is where Cursor stops feeling like an assistant and starts feeling like a junior developer who reads the brief and comes back with a draft.
4. Agent mode
Agent mode (sometimes called Background Agent) goes further still. It can run commands in the terminal, read test output, iterate on failing tests, and keep going until a task is done. You hand it a goal; it drives the keyboard. This is the most powerful and the most dangerous feature. Powerful because it compresses an afternoon's work into a coffee break. Dangerous because an Agent that can run rm can run rm on the wrong thing. Treat it with the respect you would give a new hire with full production access.
Honest take. Cmd-K and Cmd-L together will deliver 80% of Cursor's value for most UK teams. Composer and Agent are the headline features, but they reward disciplined prompting and good Git hygiene. Start with the first two and earn your way to the latter two.
Cursor pricing in 2026 (and what the plans actually give you)
Cursor's pricing is in US dollars. At current rates these translate to roughly the figures below, but the pound-dollar exchange rate matters and you should check Anysphere's site for the current number before you commit the team.
- Hobby (free). Limited use of Cursor Tab, a small monthly quota of premium model requests, and no access to Privacy Mode as a guaranteed default. Good for evaluating. Not enough for daily work on a real codebase.
- Pro — around £16 per user per month ($20). Generous allowance of premium model requests (including Claude and GPT), unlimited slower-queue requests, Privacy Mode available on request. This is the plan most individual UK developers end up on.
- Business — around £32 per user per month ($40). Everything in Pro, plus Privacy Mode enforced by default, SSO/SAML, an admin console, centralised billing, and usage analytics. This is the plan small UK agencies and in-house product teams should be on.
- Enterprise. Custom pricing, annual commitments, procurement-friendly contracts and DPAs, dedicated support. Relevant for regulated sectors and larger organisations.
Compared to the salary of a UK mid-level developer, £16 to £32 a month is noise. The honest question is not "is it worth the money" but "is the team disciplined enough to use it well."
Who Cursor is actually for in a UK SMB context
Developers (obviously)
Any UK team shipping software should be running Cursor, Copilot or an equivalent. The productivity delta on greenfield work, test writing and refactoring is real. There is no longer a defensible argument for junior developers typing every line by hand.
Technical founders
The founder-who-codes archetype is Cursor's sweet spot. If you are shipping your own MVP, debugging your own Stripe integration, and reviewing your own PRs, Cursor compresses your week by a meaningful amount.
Product managers and designers
This is where Cursor starts to blur the lines. A PM who can read a bit of code can use Cursor to make copy tweaks, update feature flags, or build a throwaway prototype to argue a point in a design review. A designer can edit CSS with confidence. This is new, and it matters.
UK agencies building client sites
Agencies shipping WordPress, Webflow, Shopify and bespoke Next.js sites get particular leverage from Cursor. The Composer and Agent make it realistic to spin up a client prototype in a day and iterate with the client in the room. Agencies we have talked to in Manchester and Bristol are quietly raising day rates on the back of this.
Non-technical operators
Honest answer: Cursor is not the right starting point. If your work is emails, reports, briefs, proposals and summarising calls, use Claude Cowork or ChatGPT instead. Cursor assumes files, folders and Git. Someone who has never opened a code editor will not get value from it in a reasonable timeframe, no matter how good the AI is underneath.
Setting Cursor up for the first time: a practical walk-through
Allow yourself 30 minutes for a proper first-time setup. Rushing this is the single biggest reason teams abandon Cursor in week two.
- Download and install. Go to cursor.com, download the Mac, Windows or Linux build, and install it. If you already use VS Code, Cursor will offer to import your settings, keybindings and extensions on first launch. Accept — it will save you an hour.
- Sign in and choose a plan. Start on the free tier to confirm it works. Upgrade to Pro once you have run Cmd-K and Cmd-L half a dozen times and seen the hit rate.
- Enable Privacy Mode. Settings → Privacy. On Business this is the default. On Pro you have to tick the box. Do so before you open any client code.
- Pick a default model. The current sensible default for most work is Claude Sonnet. GPT-5 and Gemini are both viable. You can switch on a per-prompt basis.
- Open your repository. File → Open Folder, point it at the root of a real project. Cursor will index it in the background — this takes a few minutes the first time and is what makes Cmd-L able to answer questions about "the whole codebase."
- Write a
.cursorrulesfile. This is a plain-text file at the root of the repo that tells Cursor how your team writes code: the stack, the naming conventions, the testing style, the things to avoid. A good.cursorrulesfile is the single highest-leverage investment you can make in Cursor as a team. - Try Cmd-K once, Cmd-L once, Composer once. Pick a tiny real task — renaming a function, adding a log line, writing a unit test. Resist the urge to use Agent mode on day one.
Ten real use cases, with prompts to copy
Below are ten things Cursor is genuinely good at in a UK business context, each with a prompt you can paste as a starting point. Swap the bracketed bits for your specifics.
1. Explain a legacy codebase you have just inherited
@codebase I have just inherited this project. Give me a plain-English tour:
- What is this application and what does it do?
- Which files are the real entry points and which are generated or dead code?
- What external services does it talk to (APIs, databases, queues)?
- What is the riskiest part of the code — the part most likely to break if I change it?
Keep the whole answer under 400 words.2. Write a missing unit test
Write a unit test for this function using [Jest / Vitest / PyTest]. Cover the happy path, one edge case for empty input, and one for a thrown error. Match the style of the existing tests in the /tests folder.3. Add error handling to an existing endpoint
Add proper error handling to this endpoint. Catch network errors, validation errors and auth errors separately. Log structured errors with the request id. Return the HTTP status code that matches each case. Do not change the happy-path response shape.4. Refactor a long component into smaller pieces
This React component is 400 lines and does three things: fetching the order, rendering the summary, and handling the refund flow. Split it into three components in the same folder, keep the public props the same, and update the imports in the one place this component is used.5. Generate a one-off data-cleaning script
Write a Node.js script that reads /data/customers.csv, deduplicates rows by email (keeping the most recent signup_date), normalises the phone number column to E.164 for +44 numbers, and writes the result to /data/customers-clean.csv. Print the number of rows removed.6. Draft a new API endpoint end-to-end
Add a POST /api/subscriptions/cancel endpoint. It should accept a subscription id, call the existing Stripe wrapper in /lib/stripe.ts, update the subscription row in the database, send the "cancellation received" email via the existing mailer, and return a 200 with the cancelled subscription. Add a test that covers the happy path.7. Translate a Figma spec into real markup
Here is the Figma export of the new pricing section. Build it as a React component using the Tailwind classes already used elsewhere in /components/marketing. Keep the breakpoints consistent with the rest of the site. Write semantic HTML (use a proper h2, not a div).8. Investigate a failing test
The test "cancels subscription and emails customer" is failing with the error below. Walk me through:
1. What the test is actually asserting
2. The most likely cause of the failure
3. The smallest change that fixes it without masking a real bug
[paste the error output]9. Write the Git commit message you have been avoiding
Here is the diff of my staged changes. Write a Conventional Commits message with a short subject line (under 60 chars) and a two-sentence body explaining the "why". Flag any unrelated change that should be committed separately.
[paste git diff --cached]10. Document a module for the next developer
Add a README.md to /lib/billing explaining: what this module is responsible for, its public functions with one-line descriptions, the external services it depends on, and the one thing a new developer will trip over if they are not careful. British English, no emojis.Five prompts that make Cursor shine
Beyond the specific use cases above, these five generic patterns will get the best out of the tool regardless of what you are building.
- "Propose a plan before you edit." Prepending this to any Composer prompt turns Cursor from an eager editor into a deliberate one. You review the plan, approve it, and then it edits.
- "Use the style already in the codebase." This one sentence stops Cursor writing idiomatic-but-wrong code that does not match your conventions.
- "Explain the trade-offs." Ask Cursor to lay out two or three approaches with pros and cons before picking one. Treats the AI as a colleague, not a vending machine.
- "Write the test first." Flipping the order forces Cursor to think about the interface before the implementation. The result is better code and better tests.
- "Keep going until the tests pass, then stop." The clearest success criterion you can give an Agent. Stops it inventing extra features you did not ask for.
Common beginner mistakes
Having watched a lot of UK teams onboard Cursor, the same mistakes recur.
Treating it like autocomplete. Cursor's Tab completion is good, but Cmd-K and Cmd-L are where the real time saving lives. Teams that never move past Tab get 10% of the value and quietly cancel the subscription in month three.
Skipping the .cursorrules file. Without it, Cursor writes technically-correct code that does not match your conventions. With it, code looks like your team wrote it. This is a 20-minute job that pays back daily.
Letting Agent mode run on a dirty working tree. If you have uncommitted changes and let Agent loose, you may lose them. Rule: commit first, agent second.
Pasting real credentials into prompts. No, the API key does not need to be in the prompt. Use environment variables and tell Cursor they exist.
Trusting the diff without reading it. Cursor is good. It is not infallible. Review every diff before accepting it, especially multi-file ones. This is not pessimism; it is good engineering practice for any change.
Switching models without a reason. Pick a default (Claude Sonnet is a sensible one in 2026) and only switch when a specific task calls for something else. Constantly changing model is a tell for prompt problems, not model problems.
Cursor vs Claude: which for which job
This is the question I get asked most often, and the answer is annoyingly nuanced because the two overlap. The short version: use Claude for thinking, writing, planning and reviewing; use Cursor for editing, shipping and running code.
- Specifying a feature before you build it. Claude wins. The conversation interface is better for iterating on a brief than an editor is.
- Writing the actual code. Cursor wins. It has the whole codebase in context and can edit multiple files.
- Reviewing a pull request you did not write. Both are good; Claude is slightly better at the "explain this in plain English for the whole team" bit.
- Writing non-code deliverables (blog posts, proposals, emails, SOPs). Claude, every time. Cursor is wasted on prose.
- Debugging a gnarly production incident. Cursor, because it can see the code, the terminal and the logs in one place.
- Teaching a non-technical colleague to use AI well. Claude, by a mile. The onboarding is dramatically gentler.
Most UK technical teams end up paying for both. That is fine. The combined cost is still less than one afternoon of a contractor's time.
Cursor vs the other AI editors
Cursor vs GitHub Copilot
Copilot is the elder statesman of this category. It is cheaper (around £8 per user per month for Business), lives inside the editors your team already uses, and has excellent autocomplete and chat. Where Cursor pulls ahead is Composer, Agent, and the "whole-codebase" feel that comes from being a dedicated editor. If your team is deeply embedded in the GitHub ecosystem and you mostly want autocomplete, Copilot is fine. If you want the agentic multi-file workflow, Cursor is ahead.
Cursor vs Windsurf
Windsurf (formerly Codeium) is Cursor's closest competitor — another AI-native VS Code fork with a comparable feature set and a strong Cascade agent. In 2026 the gap between them is small and changes month to month. For most UK teams the choice comes down to UX preference and who has shipped the latest feature. Try both for a week each. Honest take: Cursor's documentation and community are a little more mature right now; Windsurf's agent is sometimes crisper. Neither is a mistake.
Cursor vs Codeium (standalone extension)
Codeium's standalone extension is the free-tier alternative that lives in VS Code. It is a sensible choice for solo developers who cannot justify the cost, or for teams on strict budgets. The feature gap versus Cursor is real but shrinking.
Cursor vs Claude Code (the CLI)
Worth naming for completeness. Claude Code is Anthropic's command-line coding agent — no editor, just a terminal. For engineers who live in Vim or Neovim, it is excellent. For everyone else, Cursor is more approachable. The two can coexist, and plenty of people use both.
Cursor's biggest weakness for non-devs: the UI assumes you know Git. If “commit, branch, merge, stash” mean nothing to you, Cursor will feel hostile even when the AI is being helpful. That is not a prompt problem; it is a tool-fit problem.
UK GDPR, privacy and what to tell your DPO
Cursor is a US-based product. Code you send to it is processed by Anysphere and, downstream, by Anthropic, OpenAI or Google depending on the model. For UK businesses that is a GDPR question worth taking seriously — especially for agencies handling client code, and for anyone touching PII or regulated data.
The practical guidance:
- Enable Privacy Mode. On the Business plan it is on by default. On Pro, switch it on. In this mode, Anysphere does not store your prompts or completions, and does not train on your code.
- Review the DPA. Anysphere publishes a Data Processing Agreement. Your DPO should read it before the team rolls out. Appoint one person on your side to own the relationship.
- Treat Cursor like any other US SaaS. The international data transfer rules that apply to Slack, HubSpot and Google Workspace also apply here. Your existing framework for those tools covers Cursor.
- Do not paste secrets. API keys, customer records, access tokens — keep them in environment variables and tell the model they exist. This is good practice regardless of the AI tool.
- Think carefully about regulated sectors. If you are in financial services, healthcare or defence, talk to legal before rolling Cursor out on production codebases. In many cases the answer is yes with controls; in some it is no without an enterprise contract.
Enterprise and team considerations
If you are rolling Cursor out to more than three or four people, treat it as a team tool, not a developer toy.
Standardise the .cursorrules file. One per repo, committed to Git, reviewed like any other code. Without this, every developer gets a slightly different Cursor.
Use the Business plan admin console. SSO, centralised billing, usage visibility. The Pro-plan-with-reimbursement-receipts approach falls over at about ten users.
Decide on a review policy for Agent-generated PRs. Our strong recommendation: AI-written changes need the same review as human ones, and the PR description should note that Cursor was involved. This is about auditability, not shame.
Budget for prompt training. Giving the team Cursor without teaching them to prompt well is the most common way to waste the money. One two-hour workshop per team gets you most of the way there.
When NOT to use Cursor
Skip Cursor, or at least delay adopting it, if any of the following is true:
- Nobody on the team writes code. Buy Claude Cowork or ChatGPT instead.
- Your code is covered by a contract that bans third-party model access without explicit written approval, and you do not have that approval.
- Your team is already highly productive in JetBrains IDEs or Neovim and would lose more to the switch than they would gain. A well-configured Copilot or Claude Code CLI may serve you better.
- You are in a sector where any cloud-based AI tool is a compliance problem (some parts of defence, some health boards, parts of central government).
- Your team is early and still figuring out what you are building. Cursor accelerates whatever you point it at, which is bad news when you are pointing it at the wrong thing. Figure out the "what" before you optimise the "how."
The 30-day trial plan for a UK team
If the above sounds like it applies to you, here is a defensible rollout that gets you a real answer without blowing the budget.
- Week 1. Two volunteers install Cursor Pro, migrate their VS Code settings, and work normally. No Agent mode. Track how often Cmd-K and Cmd-L save them time.
- Week 2. The same two volunteers write a
.cursorrulesfile for your main repo and run Composer on one real feature each. Review the PRs together. - Week 3. Three more developers join. Run a one-hour internal session where the original two demo their workflow. Collect prompts in a shared doc.
- Week 4. Decide. If the team is faster and happier, upgrade to Business, enable SSO, and roll out to everyone. If not, downgrade and try again in six months — the tools are moving fast.
Where Claudable fits
Our core training is Claude Cowork for non-developer teams — marketing, operations, finance, legal, client services. That is still the biggest unlock for most UK SMBs. But in 2026 we also run bespoke sessions for technical teams and agencies covering Cursor setup, prompting discipline, Agent-mode workflows, and how Cursor fits alongside Claude for planning and review. If you have a team of five to fifty and you want a tailored agenda, a 30-minute call is usually enough to shape it.
The honest summary of this entire guide: Cursor is a genuinely great tool, and it is not a replacement for Claude. UK teams that are serious about AI in 2026 end up using both — Claude for the thinking and writing, Cursor for the building. If you remember nothing else from this piece, remember that.