Cursor IDE: Run Your Validated Playbook in the Editor

What Cursor does

Cursor is a fork of VS Code with first-class AI editor integration: tab autocomplete, inline chat, and an agent mode that can edit multiple files and run tests. It’s currently the dominant AI-native IDE for indie hackers and startup engineers.

Cursor reads project-level configuration on session start and treats it as system-prompt context for every chat. ShipFit’s stage-9 export uses that mechanism to keep your validated decisions in front of the model, every prompt, for the life of the project.

What ShipFit ships to Cursor

When you reach stage 9 (What to Export?) and pick Cursor, the export takes the validated playbook produced by the previous 8 stages and lands it in your repo as Cursor configuration. The editor’s AI then works from your validated decisions, not generic defaults.

What carries over from the playbook into the export:

1. Buyer persona from stage 2 (Who Pays?), including verbatim quotes from your interviews.
2. Above-the-line pains from stage 3 (What Hurts?), scored by frequency × intensity.
3. Winning angle from stage 4 (How to Win?), tied to which of the 7 Powers the business will have at maturity.
4. V1 scope from stage 5 (What’s V1?). Differentiator + Operational features; Delights held back for V2.
5. Pricing model from stage 6 (How to Charge?). Tier structure, entry price, the Pricing Position verdict.
6. Launch plan from stage 8 (How to Launch?). Primary channels and message.

ShipFit also installs project-level shortcuts that re-apply the framework gates (MoSCoW, Van Westendorp, Superhuman PMF Engine) during development, so the validation discipline survives past the planning meeting. The exact mechanics are handled for you.

Set it up, step by step

Before you start

You need a finished playbook. Run the full 9-decision flow first (a Quick Take takes about 2 minutes, the full playbook 15 to 20 minutes). The export only works once the prior 8 decisions are locked, because that is what fills the rules with real content: your buyer, your above-the-line pains, your V1 cut, and your pricing model.

You also need Cursor installed and a repo (empty is fine) to drop the files into.

Step by step

1. Finish the playbook and reach the export step. The export is the last of the 9 decisions. Pick Cursor as a target (you can pick more than one tool at once). ShipFit packages your validated decisions into Cursor’s project rules format, i.e. a .cursorrules file or a rules file under the project’s rules directory, depending on your Cursor version.

2. Drop the export in your repo root. Unzip into the root of the project, alongside package.json or your equivalent. Cursor reads project rules on session start, so the location matters: rules in the root get picked up automatically, a doc buried in /docs does not.

3. Restart Cursor and open the project. Project rules load on session start, so a fresh window guarantees the new context is live. Open the rules file and read it once. You should see your buyer persona, the V1 feature cut, and the pricing model written in plain language.

4. Smoke-test the context. In a new chat, ask: “Who is this product for and what is in V1?” If Cursor answers with your validated buyer and your V1 scope rather than a generic guess, the rules are loading. If it gives a vague answer, the file is in the wrong place or Cursor was not restarted.

5. Add your engineering conventions in a separate block. Keep validation context (buyer, scope, pricing) apart from engineering rules (test framework, file layout, linting). When you re-export after a pivot, the validation block refreshes and your engineering block stays untouched.

6. Build against the scope. Now when you ask Cursor for a feature, it already knows whether that feature is in V1 or parked for V2. Ask “let’s add team billing,” and a well-scoped project should push back if billing was cut from V1. That pushback is the point: the MVP scope decision survives into the editor instead of dying in a doc.

Keeping it in sync

Re-run the export after any meaningful pivot, e.g. a new buyer segment or a changed pricing model. The repo’s rules should always match your current validated state. A stale rules file is worse than none, because the editor will confidently build against decisions you have already abandoned.

Why bother

The honest version: most validated playbooks die in a Notion doc the day you open the editor.

Loading the playbook into Cursor’s project context prevents that. The validated decisions stay in the model’s view for every prompt, for the life of the project. When you ask Cursor “let’s add a settings page,” the model already knows whether settings is in V1 or V2 and pushes back if you’re sliding into scope creep. When you ask for landing-page copy, the model reaches for your buyer’s verbatim pain phrasing, not generic SaaS jargon.

That’s the whole game: keep the validation context loaded so engineering decisions cascade from validated answers, not from whatever the AI thinks is plausible.

Common mistakes

1. Treating the export as a one-time setup. Re-export after any meaningful pivot. The repo’s validation context should always match your current ShipFit state.

2. Mixing engineering conventions with validation context in the wrong place. Validation goes in one block, engineering conventions (test framework, file layout, linting) in another. Re-exporting refreshes the validation block; your engineering block stays put.

3. Skipping the export and pasting context manually. Works for the first session. Falls apart by week 2.

4. Putting the file in the wrong place. Rules in a subfolder Cursor does not scan will silently never load. Root, then restart, then smoke-test.

5. Treating Cursor as the validator. Cursor builds; it does not validate. The validation happens upstream in the playbook. If you have not done that work, see pricing to start (the free tier includes 3 credits a month, paid playbooks from $5).

Further reading

• Cursor documentation on rules, the official spec.
• Claude Code integration, same playbook, terminal-native tool. Most teams use both.
• Validating a business idea with AI, the workflow this export plugs into.