cim_summary/Best Practices for Debugging with Cursor_ Becoming.md

<img src="https://r2cdn.perplexity.ai/pplx-full-logo-primary-dark%402x.png" style="height:64px;margin-right:32px"/>

## Best Practices for Debugging with Cursor: Becoming a Senior Developer-Level Debugger

Transform Cursor into an elite debugging partner with these comprehensive strategies, workflow optimizations, and hidden power features that professional developers use to maximize productivity.

### Core Debugging Philosophy: Test-Driven Development with AI

**Write Tests First, Always**

The single most effective debugging strategy is implementing Test-Driven Development (TDD) with Cursor. This gives you verifiable proof that code works before deployment[^1][^2][^3].

**Workflow:**

- Start with: "Write tests first, then the code, then run the tests and update the code until tests pass"[^1]
- Enable YOLO mode (Settings → scroll down → enable YOLO mode) to allow Cursor to automatically run tests, build commands, and iterate until passing[^1][^4]
- Let the AI cycle through test failures autonomously—it will fix lint errors and test failures without manual intervention[^1][^5]

**YOLO Mode Configuration:**
Add this prompt to YOLO settings:

```
any kind of tests are always allowed like vitest, npm test, nr test, etc. also basic build commands like build, tsc, etc. creating files and making directories (like touch, mkdir, etc) is always ok too
```

This enables autonomous iteration on builds and tests[^1][^4].

### Advanced Debugging Techniques

**1. Log-Driven Debugging Workflow**

When facing persistent bugs, use this iterative logging approach[^1][^6]:

- Tell Cursor: "Please add logs to the code to get better visibility into what is going on so we can find the fix. I'll run the code and feed you the logs results"[^1]
- Run your code and collect log output
- Paste the raw logs back into Cursor: "Here's the log output. What do you now think is causing the issue? And how do we fix it?"[^1]
- Cursor will propose targeted fixes based on actual runtime behavior

**For Firebase Projects:**
Use the logger SDK with proper severity levels[^7]:

```javascript
const { log, info, debug, warn, error } = require("firebase-functions/logger");

// Log with structured data
logger.error("API call failed", {
  endpoint: endpoint,
  statusCode: response.status,
  userId: userId
});
```

**2. Autonomous Workflow with Plan-Approve-Execute Pattern**

Use Cursor in Project Manager mode for complex debugging tasks[^5][^8]:

**Setup `.cursorrules` file:**

```
You are working with me as PM/Technical Approver while you act as developer.
- Work from PRD file one item at a time
- Generate detailed story file outlining approach
- Wait for approval before executing
- Use TDD for implementation
- Update story with progress after completion
```

**Workflow:**

- Agent creates story file breaking down the fix in detail
- You review and approve the approach
- Agent executes using TDD
- Agent runs tests until all pass
- Agent pushes changes with clear commit message[^5][^8]

This prevents the AI from going off-track and ensures deliberate, verifiable fixes.

### Context Management Mastery

**3. Strategic Use of @ Symbols**

Master these context references for precise debugging[^9][^10]:

- `@Files` - Reference specific files
- `@Folders` - Include entire directories
- `@Code` - Reference specific functions/classes
- `@Docs` - Pull in library documentation (add libraries via Settings → Cursor Settings → Docs)[^4][^9]
- `@Web` - Search current information online
- `@Codebase` - Search entire codebase (Chat only)
- `@Lint Errors` - Reference current lint errors (Chat only)[^9]
- `@Git` - Access git history and recent changes
- `@Recent Changes` - View recent modifications

**Pro tip:** Stack multiple @ symbols in one prompt for comprehensive context[^9].

**4. Reference Open Editors Strategy**

Keep your AI focused by managing context deliberately[^11]:

- Close all irrelevant tabs
- Open only files related to current debugging task
- Use `@` to reference open editors
- This prevents the AI from getting confused by unrelated code[^11]

**5. Context7 MCP for Up-to-Date Documentation**

Integrate Context7 MCP to eliminate outdated API suggestions[^12][^13][^14]:

**Installation:**

```json
// ~/.cursor/mcp.json
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  }
}
```

**Usage:**

```
use context7 for latest documentation on [library name]
```

Add to your cursor rules:

```
When referencing documentation for any library, use the context7 MCP server for lookups to ensure up-to-date information
```


### Power Tools and Integrations

**6. Browser Tools MCP for Live Debugging**

Debug live applications by connecting Cursor directly to your browser[^15][^16]:

**Setup:**

1. Clone browser-tools-mcp repository
2. Install Chrome extension
3. Configure MCP in Cursor settings:
```json
{
  "mcpServers": {
    "browser-tools": {
      "command": "node",
      "args": ["/path/to/browser-tools-mcp/server.js"]
    }
  }
}
```

4. Run the server: `npm start`

**Features:**

- "Investigate what happens when users click the pay button and resolve any JavaScript errors"
- "Summarize these console logs and identify recurring errors"
- "Which API calls are failing?"
- Automatically captures screenshots, console logs, network requests, and DOM state[^15][^16]

**7. Sequential Thinking MCP for Complex Problems**

For intricate debugging requiring multi-step reasoning[^17][^18][^19]:

**Installation:**

```json
{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}
```

**When to use:**

- Breaking down complex bugs into manageable steps
- Problems where the full scope isn't clear initially
- Analysis that might need course correction
- Maintaining context over multiple debugging steps[^17]

Add to cursor rules:

```
Use Sequential thinking for complex reflections and multi-step debugging
```

**8. Firebase Crashlytics MCP Integration**

Connect Crashlytics directly to Cursor for AI-powered crash analysis[^20][^21]:

**Setup:**

1. Enable BigQuery export in Firebase Console → Project Settings → Integrations
2. Generate Firebase service account JSON key
3. Configure MCP:
```json
{
  "mcpServers": {
    "crashlytics": {
      "command": "node",
      "args": ["/path/to/mcp-crashlytics-server/dist/index.js"],
      "env": {
        "GOOGLE_SERVICE_ACCOUNT_KEY": "/path/to/service-account.json",
        "BIGQUERY_PROJECT_ID": "your-project-id",
        "BIGQUERY_DATASET_ID": "firebase_crashlytics"
      }
    }
  }
}
```

**Usage:**

- "Fetch the latest Crashlytics issues for my project"
- "Add a note to issue xyz summarizing investigation"
- Use `crashlytics:connect` command for structured debugging flow[^20][^21]


### Cursor Rules \& Configuration

**9. Master .cursorrules Files**

Create powerful project-specific rules[^22][^23][^24]:

**Structure:**

```markdown
# Project Overview
[High-level description of what you're building]

# Tech Stack
- Framework: [e.g., Next.js 14]
- Language: TypeScript (strict mode)
- Database: [e.g., PostgreSQL with Prisma]

# Critical Rules
- Always use strict TypeScript - never use `any`
- Never modify files without explicit approval
- Always read relevant files before making changes
- Log all exceptions in catch blocks using Crashlytics

# Deprecated Patterns (DO NOT USE)
- Old API: `oldMethod()` ❌
- Use instead: `newMethod()` ✅

# Common Bugs to Document
[Add bugs you encounter here so they don't recur]
```

**Pro Tips:**

- Document bugs you encounter in .cursorrules so AI avoids them in future[^23]
- Use cursor.directory for template examples[^11][^23]
- Stack multiple rule files: global rules + project-specific + feature-specific[^24]
- Use `.cursor/rules` directory for organized rule management[^24][^25]

**10. Global Rules Configuration**

Set personal coding standards in Settings → Rules for AI[^11][^4]:

```
- Always prefer strict types over any in TypeScript
- Ensure answers are brief and to the point
- Propose alternative solutions when stuck
- Skip unnecessary elaborations
- Emphasize technical specifics over general advice
- Always examine relevant files before taking action
```

**11. Notepads for Reusable Context**

Use Notepads to store debugging patterns and common fixes[^11][^26][^27][^28]:

**Create notepads for:**

- Common error patterns and solutions
- Debugging checklists for specific features
- File references for complex features
- Standard prompts like "code review" or "vulnerability search"

**Usage:**
Reference notepads in prompts to quickly load debugging context without retyping[^27][^28].

### Keyboard Shortcuts for Speed

**Essential Debugging Shortcuts**[^29][^30][^31]:

**Core AI Commands:**

- `Cmd/Ctrl + K` - Inline editing (fastest for quick fixes)[^1][^32][^30]
- `Cmd/Ctrl + L` - Open AI chat[^30][^31]
- `Cmd/Ctrl + I` - Open Composer[^30]
- `Cmd/Ctrl + Shift + I` - Full-screen Composer[^30]

**When to use what:**

- Use `Cmd+K` for fast, localized changes to selected code[^1][^32]
- Use `Cmd+L` for questions and explanations[^31]
- Use `Cmd+I` (Composer) for multi-file changes and complex refactors[^32][^4]

**Navigation:**

- `Cmd/Ctrl + P` - Quick file open[^29][^33]
- `Cmd/Ctrl + Shift + O` - Go to symbol in file[^33]
- `Ctrl + G` - Go to line (for stack traces)[^33]
- `F12` - Go to definition[^29]

**Terminal:**

- `Cmd/Ctrl + `` - Toggle terminal[^29][^30]
- `Cmd + K` in terminal - Clear terminal (note: may need custom keybinding)[^34][^35]


### Advanced Workflow Strategies

**12. Agent Mode with Plan Mode**

Use Plan Mode for complex debugging[^36][^37]:

1. Hit `Cmd+N` for new chat
2. Press `Shift+Tab` to toggle Plan Mode
3. Describe the bug or feature
4. Agent researches codebase and creates detailed plan
5. Review and approve before implementation

**Agent mode benefits:**

- Autonomous exploration of codebase
- Edits multiple files
- Runs commands automatically
- Fixes errors iteratively[^37][^38]

**13. Composer Agent Mode Best Practices**

For large-scale debugging and refactoring[^39][^5][^4]:

**Setup:**

- Always use Agent mode (toggle in Composer)
- Enable YOLO mode for autonomous execution[^5][^4]
- Start with clear, detailed problem descriptions

**Workflow:**

1. Describe the complete bug context in detail
2. Let Agent plan the approach
3. Agent will:
    - Pull relevant files automatically
    - Run terminal commands as needed
    - Iterate on test failures
    - Fix linting errors autonomously[^4]

**Recovery strategies:**

- If Agent goes off-track, hit stop immediately
- Say: "Wait, you're way off track here. Reset, recalibrate"[^1]
- Use Composer history to restore checkpoints[^40][^41]

**14. Index Management**

Keep your codebase index fresh[^11]:

**Manual resync:**
Settings → Cursor Settings → Resync Index

**Why this matters:**

- Outdated index causes incorrect suggestions
- AI may reference deleted files
- Prevents hallucinations about code structure[^11]

**15. Error Pattern Recognition**

Watch for these warning signs and intervene[^1][^42]:

- AI repeatedly apologizing
- Same error occurring 3+ times
- Complexity escalating unexpectedly
- AI asking same diagnostic questions repeatedly

**When you see these:**

- Stop the current chat
- Start fresh conversation with better context
- Add specific constraints to prevent loops
- Use "explain your thinking" to understand AI's logic[^42]


### Firebase-Specific Debugging

**16. Firebase Logging Best Practices**

Structure logs for effective debugging[^7][^43]:

**Severity levels:**

```javascript
logger.debug("Detailed diagnostic info")
logger.info("Normal operations")
logger.warn("Warning conditions")
logger.error("Error conditions", { context: details })
logger.write({ severity: "EMERGENCY", message: "Critical failure" })
```

**Add context:**

```javascript
// Tag user IDs for filtering
Crashlytics.setUserIdentifier(userId)

// Log exceptions with context
Crashlytics.logException(error)
Crashlytics.log(priority, tag, message)
```

**View logs:**

- Firebase Console → Functions → Logs
- Cloud Logging for advanced filtering
- Filter by severity, user ID, version[^43]

**17. Version and User Tagging**

Enable precise debugging of production issues[^43]:

```javascript
// Set version
Crashlytics.setCustomKey("app_version", "1.2.3")

// Set user identifier
Crashlytics.setUserIdentifier(userId)

// Add custom context
Crashlytics.setCustomKey("feature_flag", "beta_enabled")
```

Filter crashes in Firebase Console by version and user to isolate issues.

### Meta-Strategies

**18. Minimize Context Pollution**

**Project-level tactics:**

- Use `.cursorignore` similar to `.gitignore` to exclude unnecessary files[^44]
- Keep only relevant documentation indexed[^4]
- Close unrelated editor tabs before asking questions[^11]

**19. Commit Often**

Let Cursor handle commits[^40]:

```
Push all changes, update story with progress, write clear commit message, and push to remote
```

This creates restoration points if debugging goes sideways.

**20. Multi-Model Strategy**

Don't rely on one model[^4][^45]:

- Use Claude 3.5 Sonnet for complex reasoning and file generation[^5][^8]
- Try different models if stuck
- Some tasks work better with specific models

**21. Break Down Complex Debugging**

When debugging fails repeatedly[^39][^40]:

- Break the problem into smallest possible sub-tasks
- Start new chats for discrete issues
- Ask AI to explain its approach before implementing
- Use sequential prompts rather than one massive request


### Troubleshooting Cursor Itself

**When Cursor Misbehaves:**

**Context loss issues:**[^46][^47][^48]

- Check for .mdc glob attachment issues in settings
- Disable workbench/editor auto-attachment if causing crashes[^46]
- Start new chat if context becomes corrupted[^48]

**Agent loops:**[^47]

- Stop immediately when looping detected
- Provide explicit, numbered steps
- Use "complete step 1, then stop and report" approach
- Restart with clearer constraints

**Rule conflicts:**[^49][^46]

- User rules may not apply automatically - use project .cursorrules instead[^49]
- Test rules by asking AI to recite them
- Check rules are being loaded (mention them in responses)[^46]


### Ultimate Debugging Checklist

Before starting any debugging session:

**Setup:**

- [ ] Enable YOLO mode
- [ ] Configure .cursorrules with project specifics
- [ ] Resync codebase index
- [ ] Close irrelevant files
- [ ] Add relevant documentation to Cursor docs

**During Debugging:**

- [ ] Write tests first before fixing
- [ ] Add logging at critical points
- [ ] Use @ symbols to reference exact files
- [ ] Let Agent run tests autonomously
- [ ] Stop immediately if AI goes off-track
- [ ] Commit frequently with clear messages

**Advanced Tools (when needed):**

- [ ] Context7 MCP for up-to-date docs
- [ ] Browser Tools MCP for live debugging
- [ ] Sequential Thinking MCP for complex issues
- [ ] Crashlytics MCP for production errors

**Recovery Strategies:**

- [ ] Use Composer checkpoints to restore state
- [ ] Start new chat with git diff context if lost
- [ ] Ask AI to recite instructions to verify context
- [ ] Use Plan Mode to reset approach

By implementing these strategies systematically, you transform Cursor from a coding assistant into an elite debugging partner that operates at senior developer level. The key is combining AI autonomy (YOLO mode, Agent mode) with human oversight (TDD, plan approval, checkpoints) to create a powerful, verifiable debugging workflow[^1][^5][^8][^4].
<span style="display:none">[^50][^51][^52][^53][^54][^55][^56][^57][^58][^59][^60][^61][^62][^63][^64][^65][^66][^67][^68][^69][^70][^71][^72][^73][^74][^75][^76][^77][^78][^79][^80][^81][^82][^83][^84][^85][^86][^87][^88][^89][^90][^91][^92][^93][^94][^95][^96][^97][^98]</span>

<div align="center">⁂</div>

[^1]: https://www.builder.io/blog/cursor-tips

[^2]: https://cursorintro.com/insights/Test-Driven-Development-as-a-Framework-for-AI-Assisted-Development

[^3]: https://www.linkedin.com/posts/richardsondx_i-built-tdd-for-cursor-ai-agents-and-its-activity-7330360750995132416-Jt5A

[^4]: https://stack.convex.dev/6-tips-for-improving-your-cursor-composer-and-convex-workflow

[^5]: https://www.reddit.com/r/cursor/comments/1iga00x/refined_workflow_for_cursor_composer_agent_mode/

[^6]: https://www.sidetool.co/post/how-to-use-cursor-for-efficient-code-review-and-debugging/

[^7]: https://firebase.google.com/docs/functions/writing-and-viewing-logs

[^8]: https://forum.cursor.com/t/composer-agent-refined-workflow-detailed-instructions-and-example-repo-for-practice/47180

[^9]: https://learncursor.dev/features/at-symbols

[^10]: https://cursor.com/docs/context/symbols

[^11]: https://www.reddit.com/r/ChatGPTCoding/comments/1hu276s/how_to_use_cursor_more_efficiently/

[^12]: https://dev.to/mehmetakar/context7-mcp-tutorial-3he2

[^13]: https://github.com/upstash/context7

[^14]: https://apidog.com/blog/context7-mcp-server/

[^15]: https://www.reddit.com/r/cursor/comments/1jg0in6/i_cut_my_browser_debugging_time_in_half_using_ai/

[^16]: https://www.youtube.com/watch?v=K5hLY0mytV0

[^17]: https://mcpcursor.com/server/sequential-thinking

[^18]: https://apidog.com/blog/mcp-sequential-thinking/

[^19]: https://skywork.ai/skypage/en/An-AI-Engineer's-Deep-Dive:-Mastering-Complex-Reasoning-with-the-sequential-thinking-MCP-Server-and-Claude-Code/1971471570609172480

[^20]: https://firebase.google.com/docs/crashlytics/ai-assistance-mcp

[^21]: https://lobehub.com/mcp/your-username-mcp-crashlytics-server

[^22]: https://trigger.dev/blog/cursor-rules

[^23]: https://www.youtube.com/watch?v=Vy7dJKv1EpA

[^24]: https://www.reddit.com/r/cursor/comments/1ik06ol/a_guide_to_understand_new_cursorrules_in_045/

[^25]: https://cursor.com/docs/context/rules

[^26]: https://forum.cursor.com/t/enhanced-productivity-persistent-notepads-smart-organization-and-project-integration/60757

[^27]: https://iroidsolutions.com/blog/mastering-cursor-ai-16-golden-tips-for-next-level-productivity

[^28]: https://dev.to/heymarkkop/my-top-cursor-tips-v043-1kcg

[^29]: https://www.dotcursorrules.dev/cheatsheet

[^30]: https://cursor101.com/en/cursor/cheat-sheet

[^31]: https://mehmetbaykar.com/posts/top-15-cursor-shortcuts-to-speed-up-development/

[^32]: https://dev.to/romainsimon/4-tips-for-a-10x-productivity-using-cursor-1n3o

[^33]: https://skywork.ai/blog/vibecoding/cursor-2-0-workflow-tips/

[^34]: https://forum.cursor.com/t/command-k-and-the-terminal/7265

[^35]: https://forum.cursor.com/t/shortcut-conflict-for-cmd-k-terminal-clear-and-ai-window/22693

[^36]: https://www.youtube.com/watch?v=WVeYLlKOWc0

[^37]: https://cursor.com/docs/agent/modes

[^38]: https://forum.cursor.com/t/10-pro-tips-for-working-with-cursor-agent/137212

[^39]: https://ryanocm.substack.com/p/137-10-ways-to-10x-your-cursor-workflow

[^40]: https://forum.cursor.com/t/add-the-best-practices-section-to-the-documentation/129131

[^41]: https://www.nocode.mba/articles/debug-vibe-coding-faster

[^42]: https://www.siddharthbharath.com/coding-with-cursor-beginners-guide/

[^43]: https://www.letsenvision.com/blog/effective-logging-in-production-with-firebase-crashlytics

[^44]: https://www.ellenox.com/post/mastering-cursor-ai-advanced-workflows-and-best-practices

[^45]: https://forum.cursor.com/t/best-practices-setups-for-custom-agents-in-cursor/76725

[^46]: https://www.reddit.com/r/cursor/comments/1jtc9ej/cursors_internal_prompt_and_context_management_is/

[^47]: https://forum.cursor.com/t/endless-loops-and-unrelated-code/122518

[^48]: https://forum.cursor.com/t/auto-injected-summarization-and-loss-of-context/86609

[^49]: https://github.com/cursor/cursor/issues/3706

[^50]: https://www.youtube.com/watch?v=TFIkzc74CsI

[^51]: https://www.codecademy.com/article/how-to-use-cursor-ai-a-complete-guide-with-practical-examples

[^52]: https://launchdarkly.com/docs/tutorials/cursor-tips-and-tricks

[^53]: https://www.reddit.com/r/programming/comments/1g20jej/18_observations_from_using_cursor_for_6_months/

[^54]: https://www.youtube.com/watch?v=TrcyAWGC1k4

[^55]: https://forum.cursor.com/t/composer-agent-refined-workflow-detailed-instructions-and-example-repo-for-practice/47180/5

[^56]: https://hackernoon.com/two-hours-with-cursor-changed-how-i-see-ai-coding

[^57]: https://forum.cursor.com/t/how-are-you-using-ai-inside-cursor-for-real-world-projects/97801

[^58]: https://www.youtube.com/watch?v=eQD5NncxXgE

[^59]: https://forum.cursor.com/t/guide-a-simpler-more-autonomous-ai-workflow-for-cursor-new-update/70688

[^60]: https://forum.cursor.com/t/good-examples-of-cursorrules-file/4346

[^61]: https://patagonian.com/cursor-features-developers-must-know/

[^62]: https://forum.cursor.com/t/ai-test-driven-development/23993

[^63]: https://www.reddit.com/r/cursor/comments/1iq6pc7/all_you_need_is_tdd/

[^64]: https://forum.cursor.com/t/best-practices-cursorrules/41775

[^65]: https://www.youtube.com/watch?v=A9BiNPf34Z4

[^66]: https://engineering.monday.com/coding-with-cursor-heres-why-you-still-need-tdd/

[^67]: https://github.com/PatrickJS/awesome-cursorrules

[^68]: https://www.datadoghq.com/blog/datadog-cursor-extension/

[^69]: https://www.youtube.com/watch?v=oAoigBWLZgE

[^70]: https://www.reddit.com/r/cursor/comments/1khn8hw/noob_question_about_mcp_specifically_context7/

[^71]: https://www.reddit.com/r/ChatGPTCoding/comments/1if8lbr/cursor_has_mcp_features_that_dont_work_for_me_any/

[^72]: https://cursor.com/docs/context/mcp

[^73]: https://upstash.com/blog/context7-mcp

[^74]: https://cursor.directory/mcp/sequential-thinking

[^75]: https://forum.cursor.com/t/how-to-debug-localhost-site-with-mcp/48853

[^76]: https://www.youtube.com/watch?v=gnx2dxtM-Ys

[^77]: https://www.mcp-repository.com/use-cases/ai-data-analysis

[^78]: https://cursor.directory/mcp

[^79]: https://www.youtube.com/watch?v=tDGJ12sD-UQ

[^80]: https://github.com/firebase/firebase-functions/issues/1439

[^81]: https://firebase.google.com/docs/app-hosting/logging

[^82]: https://dotcursorrules.com/cheat-sheet

[^83]: https://www.reddit.com/r/webdev/comments/1k8ld2l/whats_easy_way_to_see_errors_and_logs_once_in/

[^84]: https://www.youtube.com/watch?v=HlYyU2XOXk0

[^85]: https://stackoverflow.com/questions/51212886/how-to-log-errors-with-firebase-hosting-for-a-deployed-angular-web-app

[^86]: https://forum.cursor.com/t/list-of-shortcuts/520

[^87]: https://firebase.google.com/docs/analytics/debugview

[^88]: https://forum.cursor.com/t/cmd-k-vs-cmd-r-keyboard-shortcuts-default/1172

[^89]: https://www.youtube.com/watch?v=CeYr7C8UqLE

[^90]: https://forum.cursor.com/t/can-we-reference-docs-files-in-the-rules/23300

[^91]: https://forum.cursor.com/t/cmd-l-l-i-and-cmd-k-k-hotkeys-to-switch-between-models-and-chat-modes/2442

[^92]: https://www.reddit.com/r/cursor/comments/1gqr207/can_i_mention_docs_in_cursorrules_file/

[^93]: https://cursor.com/docs/configuration/kbd

[^94]: https://forum.cursor.com/t/how-to-reference-symbols-like-docs-or-web-from-within-a-text-prompt/66850

[^95]: https://forum.cursor.com/t/tired-of-cursor-not-putting-what-you-want-into-context-solved/75682

[^96]: https://www.reddit.com/r/vscode/comments/1frnoca/which_keyboard_shortcuts_do_you_use_most_but/

[^97]: https://forum.cursor.com/t/fixing-basic-features-before-adding-new-ones/141183

[^98]: https://cursor.com/en-US/docs