Time Savers

It is 2pm and you have spent the morning on a feature that should have been straightforward. But between manually writing JSDoc for 8 functions, fixing the same ESLint error in 12 files, copy-pasting the same error handling pattern into 4 new endpoints, and typing out a commit message that accurately describes your changes, you have lost an hour to tasks that require zero creative thought. None of these tasks are hard. They are just tedious, repetitive, and constant.

The time savers in this guide are not dramatic. Each one saves 10 to 60 seconds. But you do most of them dozens of times per day, and a few of them dozens of times per week. When you add them up, you reclaim 5 to 10 hours per week — not by working faster, but by eliminating the work that should not require human attention in the first place.

What You’ll Walk Away With

• Quick-win prompts for the most common repetitive tasks
• Workflow patterns that batch similar operations together
• Rules that automate conventions you currently enforce manually
• A prioritized list of optimizations sorted by time saved per week

Instant Documentation Generation

Writing documentation for functions, components, and modules is one of the most skipped tasks in software development because the cost-benefit feels wrong: 30 seconds of typing for something that only matters later. AI flips this equation.

Tip

Copy-paste prompt for batch documentation:

Add JSDoc documentation to every exported function in @src/services/order-service.ts.

For each function:
- Describe what it does in one sentence
- Document every parameter with its type and purpose
- Document the return type and what it contains
- Add @throws for any errors the function can throw
- Add a brief @example if the usage is not obvious

Do NOT change any implementation code. Only add documentation comments.

Run this once per file after you finish implementing. It takes the AI 15 seconds to document what would take you 5 minutes to write by hand.

Commit Message Generation

Writing good commit messages is a discipline that pays off during debugging and code review — but it is also a speed bump in your flow. Let the AI read your diff and generate the message:

Tip

Copy-paste prompt for commit messages:

Look at the staged changes (git diff --staged) and write a commit message.

Format:
- First line: type(scope): description (under 72 characters)
- Types: feat, fix, refactor, test, docs, chore
- Blank line
- Body: 1-3 bullet points explaining the key changes and why they were made

Do not include file names in the message. Focus on what changed and why.

Save this as a custom command at .cursor/commands/commit-message.md so you can invoke it with /commit-message instead of pasting it every time.

Bulk Operations That Save Hours

Converting Patterns Across Many Files

When you need to apply the same change to many files (adding error handling, converting callbacks to async/await, updating an import path), batching saves massive time compared to editing each file individually:

Tip

Copy-paste prompt for bulk pattern updates:

Find every file in @src/routes/ that uses the old error handling pattern:

  res.status(500).json({ error: error.message })

Replace it with our standardized error handler:

  throw new AppError(500, error.message, { cause: error })

Import AppError from @src/lib/errors.ts in any file that does not already import it.

Make the changes file by file. Run `npm run build` after all changes to verify nothing broke.

This kind of bulk update takes 30 to 60 minutes to do manually across 15 files. Agent mode handles it in 2 minutes.

Generating Missing Test Files

Tip

Copy-paste prompt for bulk test generation:

Look at @src/services/ and identify every .ts file that does not have a corresponding test file in __tests__/.

For each missing test file, generate a basic test suite that covers:
- The happy path for each exported function
- One error case per function
- Mocking of external dependencies

Follow the test patterns in @src/services/__tests__/user-service.test.ts.
Run the tests after generating them.

This is not about achieving 100% coverage in one shot — it is about going from 0% to 60% coverage in 5 minutes instead of 2 hours, then incrementally improving from there.

Auto-Formatting and Auto-Fixing on Save

Configure Cursor to handle formatting and simple lint fixes automatically so you never think about them:

{
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit",
    "source.organizeImports": "explicit"
  }
}

This eliminates an entire category of review comments (“fix the formatting,” “organize your imports”) and saves you from running npm run format manually.

Quick File Scaffolding

Instead of copying an existing file and manually renaming everything, let the AI scaffold new files from your existing patterns:

Tip

Copy-paste prompt for file scaffolding:

Create a new service file at src/services/notification-service.ts following the exact structure of @src/services/email-service.ts.

Replace:
- Class name: EmailService -> NotificationService
- Method names: adapt to notification domain (sendNotification, getNotificationHistory, markAsRead)
- Types: create NotificationPayload and NotificationResult interfaces
- Dependencies: keep the same DI pattern but with notification-specific deps

Also create the test file at src/services/__tests__/notification-service.test.ts following the test structure of @src/services/__tests__/email-service.test.ts.

Two files scaffolded in 30 seconds instead of 10 minutes of copy-paste-rename.

Rules That Automate Conventions

Instead of remembering to add error handling, logging, and validation every time you create a new endpoint, encode these conventions in rules that apply automatically:

---
globs: "src/routes/**/*.ts"
---

Every route handler in this project must:
1. Validate the request body using the Zod schema from @src/schemas/
2. Wrap the handler body in a try/catch
3. Log the request at the start: logger.info('[ROUTE_NAME] request received', { userId })
4. Log errors at the catch: logger.error('[ROUTE_NAME] failed', { error, userId })
5. Return errors using AppError from @src/lib/errors.ts
6. Include the route in the route registry at @src/app.ts

Follow the exact pattern in @src/routes/users.ts.

This rule fires automatically whenever Agent creates or modifies a route file. You never need to remind it.

Quick Inline Edits with Cmd+K

For small, targeted changes, Cmd+K (inline edit) is faster than switching to Agent mode:

• Select a function and press Cmd+K: “add input validation”
• Select a block and press Cmd+K: “handle the null case”
• Select a variable name and press Cmd+K: “rename to currentUser across this file”
• Select a try/catch and press Cmd+K: “add logging and re-throw”

Each of these takes 3 to 5 seconds. The equivalent Agent mode interaction (switch to chat, describe the change, wait for the agent to read the file, review the diff) takes 30 to 60 seconds for the same result.

The rule of thumb: if your change is one sentence, use Cmd+K. If it is a paragraph, use Agent mode.

Rapid Prototyping with Tab Completion

Cursor’s Tab completion learns your patterns over time. The more consistently you write code, the better its predictions become. These habits improve Tab accuracy:

• Be consistent with naming. If your services are always [Domain]Service (UserService, OrderService, PaymentService), Tab predicts the pattern when you type Notif....
• Be consistent with structure. If every service has create, get, update, delete methods in that order, Tab predicts the next method after you finish one.
• Accept partial completions. Press Cmd+Right Arrow to accept one word at a time instead of the entire suggestion. This gives you finer control while still saving keystrokes.

The Pre-Push Checklist

Before pushing your branch, run this one-shot verification:

Tip

Copy-paste prompt for pre-push verification:

Run these checks in sequence and fix any issues:

1. npm run build (fix all TypeScript errors)
2. npm run lint (fix all lint errors)
3. npm test (fix any test failures)
4. npm run format (apply formatting)

After all four pass, show me a summary of what was fixed.
Do not skip any step. Iterate until all four pass cleanly.

This prevents the “CI failed, push a fix, CI failed again” cycle that wastes 15 minutes per iteration.

Daily Workflow Optimizations

Start of Day

Open your project and run a quick status check in Ask mode:

Summarize the state of this branch:
- What changes are staged and unstaged?
- What is the last commit?
- Are there any uncommitted changes from yesterday?
- Are there merge conflicts with main?

This takes 10 seconds and prevents the “wait, where was I?” confusion that costs 5 minutes every morning.

During Development

Keep Agent mode conversations short. When a conversation exceeds 15 to 20 messages, the context window fills up and the agent starts losing track of earlier instructions. Start a new conversation for each distinct task rather than continuing one long thread.

End of Day

Before closing your editor, create a breadcrumb for tomorrow:

Look at my current changes (staged and unstaged) and write a brief summary of:
1. What I was working on
2. What is done
3. What still needs to be done
4. Any blockers or questions I need to resolve

Save this as a comment at the top of the file I was editing.

Remove the comment tomorrow morning after you read it. This eliminates the 10-minute “what was I doing?” ramp-up at the start of each day.

When This Breaks

Auto-save triggers too many format-on-save operations. If your formatter is slow (common with large files or complex Prettier configs), increase the auto-save delay to 3000ms or switch to format-on-paste instead of format-on-save.

Bulk operations change too much at once. If a bulk update touches 20 files and breaks something, it is hard to pinpoint which change caused the issue. Prefer running the test suite after every 3 to 5 file changes rather than after all changes are complete.

Tab completion suggests wrong patterns. Tab learns from your codebase, so if your codebase has inconsistent patterns, the suggestions are inconsistent. Fix the root cause by standardizing patterns, not by fighting the predictions.

Commit messages are too generic. The AI-generated message says “update order service” instead of explaining why. Include context in your prompt: “The staged changes fix the bug where decimal quantities returned NaN in the total calculation.”

What’s Next

• Keyboard Shortcuts — The input speed layer that makes these workflows even faster
• Prompt Templates — Pre-built prompts for the tasks covered here
• Custom Rules and Templates — Encoding your conventions into rules that apply automatically