A lean 2026 Cursor setup for solo developers: which tier to pay for, a 3-rule .cursor/rules starter, Tab vs Agent vs Plan Mode, and solo review discipline.

Originally published at heycc.cn. This is a mirrored copy — the canonical version is kept up to date at the source.

Cursor for Solo Developers: A Lean 2026 Setup for Small Projects

When you work alone, the AI agent is your only teammate. There is no reviewer to catch the subtly wrong line, no architect to veto a bad pattern, no one but you to notice that a passing test does not mean the code is right. Cursor in 2026 ships changes fast enough to outrun one person's attention — which is exactly why a solo developer needs a deliberate setup, not the default one. A team can absorb a sloppy agent because four other people read the PR. You can't. Every guardrail in this guide is chosen to replace a teammate you don't have.

The scope here (current as of 2026-06-28) is narrow on purpose: a single developer on small-to-medium projects who wants to move quickly without accumulating a mess. Four decisions, in order: which tier to actually pay for, a minimal .cursor/rules starter you can drop in today, how to choose between Tab, Agent, and Plan Mode, and the review discipline that keeps the speed from biting you. No team features, no enterprise SSO — just the lean kit that earns its place for one person.

Free vs Pro for solo use in 2026

Cursor's individual pricing has two tiers that matter for most solo work, plus two that almost certainly do not. The dollar amounts below are the stable part; the usage language is vendor shorthand for credit metering that shifts month to month, so confirm the per-cell mechanics at cursor.com/pricing before you buy.

The free Hobby plan is genuinely usable and needs no credit card. Its real ceiling is not inline completion — Tab is the feature you'll lean on constantly, and on a paid plan Cursor's in-house Tab model runs effectively unlimited. The wall you actually hit on Hobby is Agent requests against frontier models: the limited request budget runs down once you start handing whole tasks to Claude, GPT, or Gemini inside the agent. On a small project you can code for a while on Tab plus the lighter built-in models before that budget bites. Cursor does not publish an exact request count for this ceiling — as of 2026-07-02, cursor.com/pricing still describes it only as "Limited Agent requests," with no number attached. Treat "limited" as a wall you will hit on any real task, not a budget you can plan around.

Pro at $20/month lifts that Agent ceiling — extended Agent limits, access to frontier models, MCPs/skills/hooks, cloud agents, and Bugbot on usage-based billing. The single change most solo developers feel is that they stop rationing agent runs: the days you want the agent to grind through a refactor stop ending in a "you've reached your limit" wall. Pro+ ($60) and Ultra ($200) scale usage to roughly 3x and 20x respectively — real value for someone running agents continuously, but overkill for typical one-person projects. Cursor's annual billing is commonly reported to save around 20% on paid tiers (confirm the current figure on the pricing page), and the Teams plan is out of scope for a solo dev.

Verdict: start free to learn the tool, and upgrade to Pro the week your agent runs first start hitting the request limit mid-task. That limit — not Tab, which is effectively unlimited even before you pay — is what tips the decision for a solo developer who has started trusting the agent with real work. For how Cursor stacks up against other tools at this price, see our best AI coding assistants 2026 comparison.

A minimal .cursor/rules starter for one-person projects

Rules are how you stop repeating yourself to the agent. They live in the .cursor/rules directory as version-controlled .mdc files. A critical gotcha: a plain .md file dropped there is silently ignored, because it lacks the frontmatter the rules system reads to decide when to load it — the symptom is an agent that confidently ignores conventions you "wrote down." The frontmatter exposes three fields — description, globs, and alwaysApply — which combine into four activation modes:

For a solo project, you do not need a sprawling ruleset — and a solo project is exactly where a sprawling one rots fastest, because no one but you will ever prune it. Three small rules cover most of the value.

1. An always-on project rule describing your stack and hard constraints. Keep it short — Cursor's own guidance is to keep each rule to a few hundred lines or fewer and split anything larger into composable files — and remember an always-applied rule is sent on every request, so it directly costs context budget on calls that don't even need it:

---
alwaysApply: true
---
- Stack: TypeScript, React 19, Vite, Vitest.
- No new runtime dependencies without flagging it first.
- Prefer pure functions; colocate tests as *.test.ts next to source.
- Match existing patterns in @src/lib/ rather than inventing new ones.

That last line is the solo-specific one. With no senior dev to enforce house style in review, a rule that points the agent at your existing code (@src/lib/) is what keeps a one-person codebase from drifting into four different ways of doing the same thing.

2. A glob-scoped rule that loads only when relevant files are in play, so it costs nothing the rest of the time:

---
globs: ["**/*.test.ts", "**/*.test.tsx"]
---
- Use Vitest with `describe`/`it`. Test behavior, not implementation.
- Cover the error path and at least one edge case, not just the happy path.

The "error path and one edge case" line earns its place for a solo dev specifically: it's the cheapest available substitute for the second pair of eyes that would otherwise ask "what happens when this fails?" in review.

3. An intelligently-applied rule for a niche the agent reaches for occasionally — say, your API conventions — with a description only, letting the agent pull it in when it judges the task relevant.

Two practices keep this from rotting. Reference real files with @filename.ts syntax instead of pasting code into the rule, so the rule can never go stale against the source — pasted snippets are the single most common reason a solo ruleset starts lying to the agent. And split anything large into composable pieces rather than one mega-rule. You do not have to hand-author the frontmatter: in the Agent, type /create-rule and describe what you want; Cursor creates the .mdc file with the correct frontmatter for you. For a deeper treatment, see our Cursor rules guide.

Choosing a mode: Tab, Agent, or Plan

Cursor gives you three distinct ways to work, and picking the wrong one is where solo developers lose the most time — there's no one to say "you should have planned that first" until the diff is already a mess.

Tab is the lightweight default. It suggests the next few lines as you type and keeps you in the loop on every edit. It is the right tool for familiar patterns and for staying hands-on — you are still doing the thinking and steering line by line.

Agent mode reads and edits files, runs terminal commands, and iterates across multiple files until a task is done. It is the right tool when you have a clear, bounded task and want it executed rather than suggested.

Plan Mode is the one solo developers underuse. Entered with Shift+Tab from the chat input (and suggested automatically for complex tasks), it produces a detailed implementation plan before writing any code: the agent asks clarifying questions, researches your codebase, and generates a reviewable plan you can edit — via chat or as a markdown file — before clicking to build.

Use this quick decision rule:

Cursor explicitly recommends Plan Mode for complex features with multiple valid approaches, tasks that touch many files or systems, and unclear requirements that need exploration first. As a solo dev, the plan is your missing design reviewer: reading and editing a plan is the cheapest moment to catch a wrong direction — far cheaper than reviewing a 600-line diff after the fact, when sunk-cost bias is already pushing you to accept it. A workable rule of thumb: if the agent's intended approach can't be summarized in one sentence before it starts, the task belongs in Plan Mode. For more on agent workflows, see our Cursor agent mode guide.

The review discipline that keeps the speed from biting you

This is the half of the setup most solo developers skip, and it's the half that decides whether the speed compounds or comes due with interest. The tooling above lets the agent move fast; the discipline below is what keeps "fast" from quietly meaning "wrong, but committed." On a team this is the PR process. Alone, you have to build it into your own loop deliberately, because nothing in the tool forces it.

Four habits do most of the work:

1. Read every diff before accepting — out loud, in your head, line by line. The agent's most dangerous output is not the broken code (tests catch that) but the plausible code: a swapped comparison operator, a dropped await, an off-by-one that the happy-path test sails right past. Accepting a diff you didn't read is the solo equivalent of merging your own PR with "LGTM" and no reviewer.
2. Commit small and commit often. Keep each agent task to a commit you'd be comfortable reverting whole. A 40-line commit you can read and reason about beats a 600-line commit you rubber-stamp. Small commits are also your undo button when the agent's third iteration is worse than its first.
3. Make the agent prove it, not just claim it. "Tests pass" from the agent is a claim, not evidence. Have it run the test command and paste real output, or run it yourself. The agent will cheerfully tell you a thing works; your job is to make it show the green run.
4. Let Bugbot or a frontier model be your second reviewer. On Pro, Bugbot reviewing your own commit is the closest thing to a colleague's second read you get as a solo dev. Even without it, a cheap habit is to open a fresh chat and ask a frontier model to "review this diff for bugs and edge cases" — a clean-context model with no stake in the code it just wrote catches things the writing agent rationalized away.

The throughline: every guardrail here is a stand-in for a teammate. Rules replace the style enforcer, Plan Mode replaces the design reviewer, the diff-reading and second-model pass replace the code reviewer. None of it slows you down meaningfully — reading a 40-line diff costs seconds — and all of it is cheaper than debugging code you never actually read.

Lean context beats more context

One last principle that ties the setup together: the instinct to throw the whole codebase at the model is wrong. Send the model only what it truly needs, in the sparsest form. Cursor simplified the @ system precisely because the agent now gathers most context automatically — the remaining @ types where your direction adds value are @Files, @Folders, @Code, @Docs, and @Past Chats. Use @filename to point at a specific file rather than dumping a folder, and lean on glob-scoped rules so conventions load only when the relevant files are in play. For a solo developer, lean context isn't just about token cost — it's about keeping the agent's attention on the one thing you're changing, so its output stays reviewable by one person in one sitting.

Where the numbers and behaviors come from

The four-tier pricing, the "Limited Agent requests" and "Limited Tab completions" labels on Hobby, and the Pro feature list all trace to Cursor's pricing page as it stood on 2026-06-28. That page publishes no numeric Tab cap, so any "completions per month" figure floating around elsewhere belongs to a different product's free tier rather than Cursor's. The one thing to verify before you pay: the Pro+ (~3x) and Ultra (~20x) usage multipliers and the ~20% annual discount come from the vendor and the sibling pricing comparison, but the live page does not always print exact multipliers — read them as directional. The /create-rule command, the four .mdc activation modes, and the "few hundred lines or fewer" length guidance are straight from Cursor's Rules documentation; the Tab/Agent/Plan behaviors track the Agent and Plan Mode pages.

Sources

• Cursor pricing — Hobby/Pro/Pro+/Ultra tiers, "limited Tab completions" and "limited Agent requests" wording, Pro feature list.
• Cursor Rules documentation — .mdc frontmatter, the four activation modes, /create-rule, and the "few hundred lines or fewer" guidance.
• Cursor Plan Mode documentation — Shift+Tab entry, when Cursor recommends Plan Mode, editable markdown plans.
• Cursor Agent / Tab overview — Tab, Agent, and the in-house completion model behavior.