Starting a New Project Using Cursor Agent

Your PM drops a message in Slack: “We need something like Trello but simpler, focused on daily standups. Can you have a prototype by Thursday?” No spec. No wireframes. No architecture doc. Just a sentence and a deadline. You have two days and an empty directory.

This is where most developers start Googling boilerplate repos and spending half the afternoon debating whether to use Next.js or Remix. With Cursor, you can skip the bikeshedding and have a running application — with auth, a database, real-time updates, and tests — in a single focused session. The key is knowing which Cursor features to reach for at each stage.

What You’ll Walk Away With

• A repeatable workflow for turning vague requirements into a structured PRD using Ask mode
• A project scaffolding prompt that generates config files, folder structure, and initial setup in one shot
• A .cursor/rules file that keeps the AI consistent across dozens of follow-up prompts
• Checkpoint discipline that lets you experiment freely without fear of losing progress
• A technique for using Plan mode to decompose complex features before Agent writes a single line

The Workflow

Step 1: Extract requirements with Ask mode

Before writing code, use Ask mode to turn that vague Slack message into something you can actually build against. Ask mode is read-only — it cannot edit files or run commands — which makes it the right tool for planning. Press Cmd+. to switch modes.

Tip

Copy-paste prompt — Requirements extraction:

I need to build a task management app “like Trello but simpler, focused on daily standups” for a team of 8-12 people. Before writing any code, help me define the requirements:

1. What are the 5 most critical features for an MVP that ships in 2 days?
2. What can we explicitly cut to stay on schedule?
3. What tech stack gives us the fastest path to a working prototype while staying production-viable?
4. What are the riskiest unknowns I should resolve first?

Be opinionated. I want decisions, not options lists.

The model will push back on scope and suggest trade-offs. This is exactly what you want. A good AI planning session feels like talking to a senior engineer who has built this kind of app before. Ask follow-up questions until you have a clear picture of what “done” looks like.

Save the output. You will reference it throughout the project.

Step 2: Generate the PRD as a file

Switch to Agent mode (Cmd+. again) and have Cursor create a structured document you can reference later with @-symbols.

Tip

Copy-paste prompt — PRD generation:

Based on our requirements discussion, create a file at docs/prd.md with a structured PRD containing:

• Problem statement (2-3 sentences)
• Target users and their workflow
• MVP feature list with acceptance criteria for each
• Explicit out-of-scope items
• Tech stack decision with rationale
• Data model (tables, key relationships)
• API endpoints (method, path, purpose)

Keep it under 500 words. This is a 2-day prototype, not an enterprise spec.

Agent mode will create the file and the docs/ directory. Now every future prompt can reference @docs/prd.md for context, which prevents the AI from drifting away from your requirements as the conversation gets longer.

Step 3: Set up project rules before any code

This is the step most people skip, and it costs them hours later. Before generating a single line of code, create a .cursor/rules directory with project-specific instructions. These rules are automatically included in every Agent and Ask interaction.

Tip

Copy-paste prompt — Project rules setup:

@docs/prd.md

Create the following cursor rules files:

1. .cursor/rules/code-style.mdc — TypeScript with strict mode, functional components, named exports, Tailwind for styling, no default exports except pages
2. .cursor/rules/architecture.mdc — Next.js App Router, server components by default, client components only when needed for interactivity, Drizzle ORM for database, Zod for validation
3. .cursor/rules/conventions.mdc — File naming (kebab-case), test co-location (*.test.ts next to source), error handling (Result pattern over try-catch for business logic), commit message format

Each file should use the frontmatter format with description and globs fields. Be specific — vague rules produce vague code.

The .cursor/rules directory with .mdc files is Cursor’s current standard for project rules. Each rule file can specify which file patterns it applies to via the globs frontmatter field, so your TypeScript rules only activate when editing .ts files.

Step 4: Scaffold the project with Agent mode

Now let Agent mode do the heavy lifting. Reference both the PRD and the rules so the generated code is consistent from the start.

Tip

Copy-paste prompt — Project scaffolding:

@docs/prd.md @.cursor/rules

Initialize this project:

1. Run npx create-next-app@latest . --typescript --tailwind --app --src-dir --no-import-alias (accept defaults)
2. Install dependencies: drizzle-orm, drizzle-kit, better-sqlite3, zod, next-auth
3. Set up the database schema in src/db/schema.ts matching the data model from the PRD
4. Create the Drizzle config and an initial migration
5. Add dev scripts to package.json for db:migrate and db:seed
6. Create a seed script that populates test data for development

Run each command and verify it succeeds before moving on. Do not skip error output.

Agent mode will execute terminal commands, create files, and iterate if something fails. With auto-run enabled in your Cursor settings (Settings > Cursor Settings > Agents > Auto-Run), the agent can run build tools and fix errors without asking permission each time.

Checkpoint now. After the scaffolding succeeds and the dev server starts, this is your first safe restore point. Cursor creates checkpoints automatically, but you should also commit to git:

git add -A && git commit -m "Initial project scaffolding with database schema"

Step 5: Build features with Plan mode

For complex features, use Plan mode before letting Agent write code. Plan mode researches your codebase, asks clarifying questions, and generates a reviewable implementation plan. Press Shift+Tab from the chat input to switch to Plan mode.

This is particularly valuable for the first major feature, because Plan mode will catch architectural decisions you might miss — like whether the task board needs WebSocket connections or if SSE is sufficient, or whether drag-and-drop state should live in the URL or in local state.

@docs/prd.md @src/db/schema.ts

Plan the implementation of the task board feature:
- Kanban-style columns (To Do, In Progress, Done)
- Drag and drop cards between columns
- Real-time updates when another user moves a card
- Optimistic UI updates with rollback on server error

Consider: Should we use WebSockets, SSE, or polling? What's the minimum viable approach for a 2-day prototype?

Review the plan. Edit it if you disagree with the approach. Then click “Build” to let Agent execute it.

Step 6: Iterate with focused follow-ups

Once the core feature is running, iterate with small, focused prompts. Each prompt should do one thing well rather than asking for five features at once.

@src/components/task-board.tsx @src/db/schema.ts

The drag and drop works but there's no visual feedback during the drag.
Add a shadow and slight rotation to the card being dragged, dim the
source column, and show a highlighted drop zone in the target column.
Use Tailwind classes only -- no CSS-in-JS.

Keep conversations short. When a conversation exceeds 15-20 exchanges, context degrades. Start a new chat, reference the specific files with @-symbols, and continue from there.

Step 7: Add authentication and deploy prep

@docs/prd.md @src/db/schema.ts

Add NextAuth.js with GitHub OAuth:
1. Create the auth config in src/lib/auth.ts
2. Add the API route at src/app/api/auth/[...nextauth]/route.ts
3. Create a middleware.ts that protects all routes except /login
4. Add a login page at src/app/login/page.tsx
5. Update the task board to show the current user's name
6. Add a users table to the schema if it doesn't exist

Use the Drizzle adapter for NextAuth. Environment variables go in .env.local.example
(not .env.local -- never commit secrets).

When This Breaks

Agent generates an outdated tech stack. The model sometimes suggests pages/ router patterns or deprecated NextAuth v4 APIs. Fix this with explicit version constraints in your prompt: “Use Next.js 15 App Router” or “Use Auth.js v5 (NextAuth v5).” Better yet, add version pinning to your .cursor/rules.

The project gets inconsistent after 20+ prompts. Long conversations lose context. When you notice the AI generating code that contradicts earlier patterns (different naming conventions, different error handling), start a fresh chat. Reference the rules files and key source files with @-symbols to re-establish context.

Agent creates files in the wrong locations. This happens when your project structure is not obvious from the file tree. Add a structure.mdc rule file that describes your directory layout: “Components go in src/components/, database queries go in src/db/queries/, API routes go in src/app/api/.”

Agent runs a command that breaks your setup. Use checkpoints to restore. Click the “Restore Checkpoint” button on any previous message in the Agent chat. For git-level safety, commit after every successful phase.

Plan mode generates an overly complex architecture. The model sometimes over-engineers prototypes with microservices, message queues, or elaborate caching layers. Add constraints: “This is a 2-day prototype for 12 users. Optimize for shipping speed, not scale. Use SQLite, not Postgres. Monolith, not microservices.”

What’s Next

Legacy Code Refactoring Apply these same techniques to an existing codebase that needs modernization.

Project Rules Deep Dive Master .cursor/rules configuration for consistent AI output across your team.

Test-Driven Development Add comprehensive test coverage to your new project from day one.