Cursor is awesome, but sometimes things get weird. And unfortunately there isn't an instruction manual. Here's how I solve common "dangit" moments while building stuff with natural language.
Dangit, I need to start a new feature but don't know where to begin!
What worked for me:
1. Reference existing docs with @prd.md or @readme.md
2. Point to similar code with @directory
3. Say "let's focus on X first" to scope it down
4. Tell Cursor "Without any backend yet lets start to build this out"
The AI will help break it into manageable chunks.
Dangit, something's broken but the error is vague!
My debugging flow:
1. Show the error message directly
2. Point to where it happened with @filename
3. Ask "What other things we could check?"
4. Try the AI's suggestions one at a time
The AI will help explore different angles systematically.
Dangit, I need to make a bunch of similar changes!
My approach:
1. Make one change work first
2. Show the pattern: "I need to do this for all X"
3. Let the AI handle the repetitive parts
4. Review the changes one by one
Much faster than doing each change manually.
Dangit, the AI isn't quite getting what I want!
What works for me:
1. Use quotes for exact text/code
2. Reference files with @
3. Say "without removing anything previously added"
4. Ask "Will we still X if Y?"
The AI keeps the good parts and fixes the rest.
Dangit, I need to hook up multiple services!
My workflow:
1. Start with "Let's focus on X first"
2. Get one connection working
3. Show real config (DB URLs, API keys, etc.)
4. Test each integration step
The AI helps connect the dots gradually.
Dangit, I need to fix something small but don't want to break anything!
My iterative approach:
1. Show the exact line that needs changing
2. Say "without removing anything previously added"
3. Ask "Will we still extract X if Y?"
4. Test edge cases: "Will this work with messages like..."
The AI helps validate the change won't break existing functionality.
Dangit, I need to understand how something works!
My investigation style:
1. Show real data: "Here's an example payload..."
2. Ask specific questions: "Where does X come from?"
3. Question assumptions: "Will we still Y if Z?"
4. Get examples: "Like if someone says..."
The AI explains with your actual use cases.
Dangit, the first solution isn't working!
My troubleshooting flow:
1. Tell the AI what happened: "it's broken" or "doesn't load"
2. Let it suggest checks: "any other things we could check?"
3. Try simpler alternatives: "Let's try a regular img tag first"
4. Keep the AI updated: "ok now public is in the root"
The AI helps explore different solutions systematically.
Dangit, I need to try different approaches!
How I explore options:
1. Start simple: "Let's try X first"
2. Test each change: "Still broken..."
3. Let the AI suggest: "What else could we check?"
4. Keep what works: "Ok that fixed it"
Build up from simple to complex solutions.
Dangit, I need to build a new feature from scratch!
My scaffolding approach:
1. Start with a basic component: "Let's create a basic layout"
2. Add temporary data: "// Temporary mock data"
3. Show a minimal working version: "This gives us..."
4. List next steps: "Next steps would be..."
Build the skeleton first, then flesh it out.
Dangit, I need to connect frontend to backend!
My integration strategy:
1. Build UI with mock data first
2. Add placeholders: "// TODO: Will integrate with backend later"
3. Show real config: "Here's the database URL..."
4. Connect piece by piece
Keep the frontend working while adding backend features.
Dangit, I need to handle complex state!
My state management flow:
1. Start with simple useState
2. Add loading states early
3. Handle error cases
4. Then add more complex features
Build up state complexity gradually.
Dangit, I need to make UI components reusable!
My component patterns:
1. Extract shared props
2. Add sensible defaults
3. Make it flexible: "We can adjust X if needed"
4. Test different use cases
Start specific, then make it generic.
Consolidated Pro Tips From Real Usage
1. Keep it conversational:
- "OK now..."
- "Let's actually..."
- "What if we..."
- "Let's create a basic..."
2. Show what's wrong:
- "it's broken"
- "doesn't load"
- "still not working"
- "needs to handle X"
3. Ask for alternatives:
- "any other things we could check?"
- "what else could be wrong?"
- "will this still work if..."
- "want me to implement any of these next steps?"
4. Guide the process:
- "without removing anything previously added"
- "let's focus on X first"
- "let's try X first"
- "this gives us..."
5. Share context:
- Show example data
- Point to specific files
- Explain what changed
- List next steps
6. Build incrementally:
- Start with mock data
- Add basic functionality
- Handle edge cases
- Then add complexity
7. Stay in sync:
- Tell the AI what changed
- Show what happened
- Keep it updated
- Test assumptions
8. Structure your code:
- Start with types/interfaces
- Add basic components
- Include TODO comments
- List what's missing
About This Guide
This guide comes from real experiences building a social media tracking app with Cursor AI. It's based on actual conversations and problem-solving patterns that worked.
Credits
Thanks to:
- The Cursor AI team for building an awesome tool
- The dangitgit.com team for inspiration
- All the software composers, AI first builders and software developers sharing their real experiences