Build Cursor

KINDAreplaces $20/mosaves $240/yrback to the verdict

0%0 of 20 items done

Saved on this device only. Tick prerequisites first, then work the phases in order · do not start one until the checks above it pass.

VS Code or VSCodium running Cline with your own provider keys, a project rules file that survives across sessions, a deny list that keeps the agent away from secrets, a local model for the cheap tasks, and a weekly cost report so the bill is a number you chose rather than one you discover.

estimated effort weekendthe files for this build are in the project pack

EditorVS Code, or VSCodium if you want the telemetry-free buildAgentCline, Apache 2.0, installed from the extension marketplaceFrontier modelClaude or another provider through your own API keyLocal modelOllama running a small coding modelCost controlProvider usage endpoints polled into a small local table

Before step 1

Everything below is assumed from the first step. Tick each one when you actually have it, not when you plan to.

installfree
Why Hosts the agent extension. Everything else assumes it.
Get it code.visualstudio.com for VS Code, or vscodium.com for a build with Microsoft telemetry and branding removed. Either works. open ↗
Verify The editor opens your project folder and the extension marketplace is reachable
installfree and Apache 2.0; you pay your model provider, not the extension
Why It is the agent. Continue, which older guides recommend, was acquired by Cursor and its repository has been archived and read-only since June 2026.
Get it Search for Cline in the editor's extension marketplace and install it. Open its sidebar to confirm it loaded. open ↗
Verify The Cline sidebar opens and asks for a provider
API keypay per token, typically a few cents per small task and more for long agent runs; set the provider spend limit on day one
Why Without it the agent has nothing to think with. This is also the line item that replaces the subscription.
Get it Create an account with your chosen provider, add a payment method, and create an API key in their console. Set a spending limit in the provider dashboard at the same time, before you make a single request.
Verify A first small task completes and the provider dashboard shows the usage
installfree, but it uses your own memory and battery
Why Phase 4 only. It is what makes routine tasks free and offline.
Get it Download from ollama.com, then pull a coding model sized for your memory. A seven billion parameter model wants roughly eight gigabytes free. open ↗
Verify ollama list shows the model and curl http://localhost:11434/api/tags responds
installfree
Why Product phase only. It is the machine that catches the key you were about to commit.
Get it brew install gitleaks, or download a release binary from its GitHub project, then wire it into a pre-commit hook. open ↗
Verify A deliberate commit containing a fake key is blocked

Data model

Create these before the first phase that stores anything. Changing a table later is the expensive kind of change.

- .clinerules · the project rules the agent reads every session, committed to the repository
- .clineignore · paths the agent must never read, starting with .env and any credential directory
- runs(id, started_at, task, provider, model, input_tokens, output_tokens, cost_usd) · your own record, because provider dashboards aggregate and you want per-task
- budget(month, cap_usd, spent_usd) · the number you refuse to exceed
- Keep the two dotfiles in the repository and the two tables local; the rules are shared, the spending is yours.

Environment variables

These go in a .env file the app reads at startup. The pack's .env.example is this table as a file · copy it, never commit the filled-in version.

Variable	Needed	Example	Where the value comes from
`ANTHROPIC_API_KEY`secret	optional	`sk-ant-...`	Your provider console. Prefer the editor's secret storage over an environment variable, and never a committed file.
`OLLAMA_HOST`	optional	`http://localhost:11434`	Where the local model server listens. The default is fine unless you moved it.
`AGENT_MONTHLY_CAP_USD`	required	`40`	The cap you choose. Mirror it as a hard spend limit in the provider dashboard so a runaway loop cannot outrun your own alert.
`RUN_LOG_PATH`	required	`~/.local/share/agent/runs.sqlite`	Where per-task cost rows are written. Local only; it contains your usage patterns.

The build, in order

1
Editor, agent and the first real task
An agent edits a file and runs a test in your repository, and you approved every action it took.
1. VS Code from code.visualstudio.com, or VSCodium from vscodium.com for a build without Microsoft telemetry. Install Cline from the extension marketplace inside the editor.
2. Paste the key into the extension settings. It is stored by the editor's secret storage rather than in your repository, which is where it must stay.
3. Ask for a small function plus a test in a scratch repository, then ask it to run the tests. Read what each approval prompt is actually asking before you click it.
done when · tick each as it passes
watch out
- The first instinct after ten approval prompts is to enable auto-approve for everything. Auto-approving terminal commands hands a program that reads the internet the ability to run anything as you. Approve reads freely if you like, but keep writes and commands behind a prompt until Phase 3 gives you a deny list worth trusting.
next phase
2
Project rules that survive the session
The agent starts every session knowing your conventions, so you stop repeating them.
1. Go through your last few sessions and write down what you had to say twice. That list is the rules file. Inventing rules you have not needed wastes tokens on every request.
  Files .clinerules
2. The exact test command, the exact build command, and the package manager. An agent guessing between npm and pnpm wastes a minute and a half of your attention every time.
  Files .clinerules
3. Pick one rule, run a task that would violate it, then delete the rule and run the same task. If nothing changes, the rule was decoration.
done when · tick each as it passes
watch out
- A rules file that grows to four hundred lines stops being read carefully and starts being expensive on every single request, because it is prepended to the context each time. Prune it when a rule stops being violated.
next phase
3
A deny list the agent cannot talk its way past
Secrets and generated noise are outside the agent's reach, by configuration rather than by hope.
1. Start from your .gitignore and add credential paths, then add large generated directories so indexing stays fast and cheap.
  Files .clineignore
2. Ask for an ignored file two ways: through the file tools and through a terminal command. Record what each does. Knowing the real boundary is the deliverable of this phase.
3. Use a secret manager, your operating system keychain, or a file outside the repository referenced by an absolute path. Test credentials in the working tree are fine; live ones are not.
done when · tick each as it passes
watch out
- An agent with terminal access can read an ignored file with cat even when the extension will not open it for indexing. The ignore list reduces accidental exposure, it does not contain a determined tool call. That is exactly why terminal approval stays on, and why real credentials should not sit in the working tree of a repository you point an agent at.
next phase
4
Local model for the cheap work
Routine tasks stop costing money and keep working without a network.
1. Pick a model sized for your machine's memory. A model that swaps is slower than the network you were trying to avoid.
  terminal
  ollama pull qwen2.5-coder:7b ollama list
2. Configure the extension with the local endpoint, usually http://localhost:11434. Confirm it answers before trusting it with a task.
  terminal
  curl http://localhost:11434/api/tags
3. Two lines in the README naming which task types go local. A rule you did not write down is not a rule.
  Files README.md
done when · tick each as it passes
watch out
- A small local model will confidently do a bad job of a task that needs judgement, and the failure is quiet rather than loud. Route by task type deliberately and write the routing down, rather than choosing per request and drifting toward whichever is on screen.
next phase
5
Knowing what it costs
Weekly spend is a number you set, not one you find out about at the end of the month.
1. A small script or extension hook writing one row per task with model, tokens and estimated cost.
  Files scripts/log_run.py
2. Fetch the provider's usage for the same window and compare. Investigate a gap rather than adjusting your estimate to hide it.
  Files scripts/reconcile.py
3. A monthly cap you actually intend to honour, and a warning at a fraction of it. Providers also offer their own spend limits; set those too, as a backstop.
done when · tick each as it passes
watch out
- Estimating cost from your own token counts alone drifts, because cached input, reasoning tokens and tool overhead are priced differently and change. Reconcile against the provider's usage endpoint rather than trusting your own arithmetic.
6
Sharing the setup without sharing the keysproduct builder
A colleague can adopt this in an afternoon, and nobody's key ends up in the repository.
1. Editor, extension, which provider, where to get a key, and the routing rule. Half a page, not a wiki.
  Files docs/agent-setup.md
2. gitleaks or a similar tool run as a hook. Test it with a fake key to be sure it actually fires.
  Files .githooks/pre-commit
  terminal
  gitleaks protect --staged
3. Run the scanner over the whole history, not just the working tree. If it finds something, rotate that credential today and treat removal as secondary.
  terminal
  gitleaks detect --source .
done when · tick each as it passes
watch out
- A key pasted into a settings file that is committed once stays in the git history after you delete it. Rotate the key rather than only removing the file, because the history is public the moment the repository is.

what this build does not replace

Cursor's own editor experience, which is the thing most people are actually paying for.
Managed model routing and the credit allowance behind it.
Cloud agents that keep working when your laptop is closed.
Whatever Cursor's repository indexing does that a local index does not.
native composer/agent UX
model routing/credits
cloud agents
editor polish
extensions compatibility
team features

after v1, if you want it

A shared rules file per repository so conventions travel with the project
Routing longer agent runs to a cheaper model and comparing the diff quality
A monthly review comparing your actual spend to the seat price you left

Need the files? The project pack on the verdict page hands your agent the whole brief · more dev tools.