What to do when Cursor times out

TL;DR

Cursor times out during large generation tasks when the request exceeds the model's token limit or the server connection drops. Breaking the task into smaller prompts, using a different model, and leveraging Composer's checkpoint system lets you resume generation without losing progress or starting over from scratch.

Cursor timeouts happen when generation tasks are too large, network connections drop, or the AI model hits processing limits. This tutorial covers prevention strategies, recovery techniques, and model selection tips for large scaffolding tasks.

Prerequisites

Cursor installed with a project open
A large generation task that has timed out or may time out
Familiarity with Cursor Chat (Cmd+L) and Composer (Cmd+I)

Step-by-step guide

Understand why Cursor times out

Timeouts occur for three main reasons: the output exceeds the model's token limit, the network connection drops during generation, or the server is overloaded. Identifying the cause helps you choose the right fix.

Diagnostics

1// Common timeout triggers:
2// 1. Generating too many files at once (5+ files)
3// 2. Very large files (500+ lines of output)
4// 3. Complex prompts with many @file references
5// 4. Using a slow model during peak hours
6// 5. Network instability (VPN, mobile hotspot)
7//
8// Check the Cursor output panel for error messages:
9// - 'Request timed out' = server/network issue
10// - 'Context window exceeded' = too much input/output
11// - 'Generation stopped' = model hit output limit

Expected result: Understanding of which timeout cause applies to your situation.

Break large tasks into smaller chunks

Instead of asking Cursor to scaffold an entire microservice at once, break it into sequential steps. Each step generates 1-2 files, making timeouts unlikely.

Cursor prompting strategy

1// Instead of one massive prompt:
2// 'Generate a complete user microservice with models,
3// routes, middleware, tests, and Docker setup'
4
5// Break into sequential prompts:
6// Step 1: 'Generate the User model and types at src/models/User.ts'
7// Step 2: 'Generate the user repository at src/repositories/userRepo.ts'
8// Step 3: 'Generate the user service at src/services/userService.ts'
9// Step 4: 'Generate the user routes at src/routes/users.ts'
10// Step 5: 'Generate the middleware at src/middleware/auth.ts'
11// Step 6: 'Generate tests for the user service'
12// Step 7: 'Generate the Dockerfile'
13//
14// Each step references the files from previous steps with @file.

Pro tip: Reference files from previous steps with @file in each new prompt. This gives Cursor context about what already exists without reprocessing everything.

Expected result: Each generation step completes quickly without timeouts.

Resume after a timeout using partial output

If Cursor timed out mid-generation, check what was partially created. Cursor may have generated some files before the timeout. Use those as context to continue from where it stopped.

Cursor Chat prompt

1// After a timeout:
2// 1. Check which files were created/modified
3// 2. Review the partial output in the Chat panel
4// 3. Start a new prompt referencing what exists:
5
6// Cursor Chat prompt (Cmd+L):
7// @src/models/User.ts @src/services/userService.ts
8// The previous generation timed out after creating the
9// model and service. Continue from where it stopped.
10// Next: generate the route handlers at src/routes/users.ts
11// that use the existing userService.

Expected result: Generation continues from the stopping point using existing files as context.

Switch models for large generation tasks

Some models handle large outputs better than others. GPT-4o and Cursor Small are faster for scaffolding. Claude models produce higher quality but may time out on very large outputs.

Model selection

1// Model recommendations for large generation:
2//
3// Fast scaffolding (many files, basic code):
4//   - GPT-4o (fast, good for boilerplate)
5//   - Cursor Small (fastest, free)
6//
7// Quality-critical generation:
8//   - Claude 3.5 Sonnet (best quality, may timeout on large tasks)
9//   - MAX mode (larger output limit, costs more credits)
10//
11// To switch models:
12// Click the model dropdown at the top of the Chat panel
13// Select the model before sending your prompt

Expected result: The appropriate model selected for your generation task size.

Use Plan Mode for complex scaffolding

For large scaffolding tasks, use Plan Mode (Shift+Tab) to have Cursor create a step-by-step plan before generating any code. You can then execute the plan one step at a time, avoiding timeouts.

Plan Mode workflow

1// Step 1: Plan Mode (Shift+Tab)
2// 'Plan a complete user microservice with: models, repository,
3// service, routes, middleware, tests, and Docker. List each
4// file to create with its purpose and dependencies.'
5//
6// Step 2: Execute one step at a time
7// 'Execute step 1 of the plan: create the User model'
8// 'Execute step 2: create the user repository'
9// ... and so on
10//
11// Plans are saved in .cursor/plans/ for reference.

Expected result: A detailed plan executed step by step without any single step causing a timeout.

Complete working example

.cursor/rules/large-tasks.mdc

1---
2description: Rules for large code generation tasks
3globs: ""
4alwaysApply: false
5---
6
7## Large Task Guidelines
8When asked to scaffold or generate multiple files:
9
101. Generate ONE file at a time, not multiple files per response
112. Wait for user confirmation between files
123. Reference previously created files with @file in each step
134. Keep individual file output under 100 lines
145. For files that need more than 100 lines, split into:
15   - Types/interfaces file
16   - Implementation file
17   - Test file
18
19## File Generation Order
20Generate files in dependency order (dependencies first):
211. Types and interfaces (src/types/)
222. Models (src/models/)
233. Repositories (src/repositories/)
244. Services (src/services/)
255. Middleware (src/middleware/)
266. Routes/Controllers (src/routes/)
277. Tests (src/**/*.test.ts)
288. Configuration (Dockerfile, docker-compose.yml)
29
30## If Generation Stops
31- Check which files were created
32- Reference existing files in the next prompt
33- Continue from the last completed step

Common mistakes

Why it's a problem: Asking Cursor to generate an entire project in one prompt

How to avoid: Break the task into sequential prompts, each generating 1-2 files. Reference previous files with @file.

Why it's a problem: Retrying the exact same prompt after a timeout

How to avoid: Reduce the scope of the prompt. Generate fewer files per request and reference existing files instead of regenerating them.

Why it's a problem: Not checking partial output after a timeout

How to avoid: Check your file system and Git status for any new or modified files. Use them as context for the continuation prompt.

Best practices

Break large generation tasks into 1-2 files per prompt
Use Plan Mode for complex scaffolding to create a step-by-step execution plan
Reference previously generated files with @file in each subsequent prompt
Use GPT-4o or Cursor Small for fast scaffolding of many files
Use MAX mode for quality-critical large generations
Check for partial output after timeouts before restarting
Generate files in dependency order (types first, routes last)

Still stuck?

Copy one of these prompts to get a personalized, step-by-step explanation.

ChatGPT Prompt

I need to scaffold a Node.js microservice with: User model, repository, service, routes, auth middleware, tests, and Dockerfile. Break this into sequential generation steps where each step creates 1-2 files. Show the dependency order and what context each step needs from previous steps.

Cursor Prompt

In Cursor Chat (Cmd+L, Plan Mode via Shift+Tab): Plan a complete user microservice. List each file to create, its purpose, dependencies on other files, and the order to generate them. Do not generate code yet, just the plan. I will execute it step by step.

Frequently asked questions

How long does Cursor take before timing out?

Typically 30-60 seconds for Chat responses and up to 2 minutes for Agent operations. If you see no response after 60 seconds in Chat, the request likely timed out or is being processed slowly.

Does Cursor save partial output from timed-out requests?

Partially generated files may be saved to disk by Agent mode. Chat responses that timeout are lost. Check your file system and git status to see if any files were partially created.

Will MAX mode prevent timeouts?

MAX mode increases the output limit and processing capacity, reducing timeouts for large generations. It uses more credits but is worth it for scaffolding tasks.

Can I increase Cursor's timeout setting?

There is no user-configurable timeout setting. The timeout is determined by the model and server. Breaking tasks into smaller pieces is more reliable than trying to extend timeouts.

Should I use Background Agents for large tasks?

Yes. Background Agents (Ctrl+E) run in cloud VMs without the timeout constraints of interactive sessions. They are ideal for large scaffolding tasks. Available on Business+ plans.

Talk to an Expert

Our team has built 600+ apps. Get personalized help with your project.

Book a free consultation

What to do when Cursor times out

What you'll learn

What you'll learn