These are the meta-tips — the principles that apply regardless of which AI dev tool you use. Master these and you’ll be more productive with any tool.
1. Write Prompts Like You’re Writing a JIRA Ticket
The single biggest productivity improvement across all AI tools is prompt quality. Bad prompt:
Add authentication to my app
Good prompt:
Add JWT-based authentication to this Express API.
Requirements:
- POST /auth/login accepts { email, password }, returns { token, refreshToken }
- POST /auth/refresh accepts { refreshToken }, returns new tokens
- Middleware in src/middleware/auth.ts validates JWT on protected routes
- Tokens expire in 15 minutes, refresh tokens in 7 days
- Store refresh tokens in the existing PostgreSQL database
- Use bcrypt for password hashing, jsonwebtoken for JWT
- Follow the error handling pattern in src/middleware/errorHandler.ts
Think: what would a new developer need to know to implement this correctly? That’s your prompt.
2. Always Review AI-Generated Code Like a PR
No AI tool produces perfect code. Establish a review habit:
- Read every line of generated code before accepting
- Check edge cases — AI often handles the happy path well but misses error states
- Verify security — auth, input validation, SQL queries, file access
- Run the tests — if there are no tests, that’s a red flag
- Check for hallucinated imports — AI sometimes imports packages that don’t exist
The developers who get burned by AI code are the ones who accept without reading.
3. Use AI for Boilerplate, Think for Architecture
AI tools excel at:
- CRUD operations, API routes, database queries
- Test generation, documentation
- Repetitive patterns across multiple files
- Converting between formats (JSON ↔ TypeScript types, SQL ↔ ORM)
AI tools struggle with:
- System architecture decisions
- Complex business logic specific to your domain
- Performance optimization that depends on real usage patterns
- Security design (auth flows, permission models)
Let AI handle the 60% that’s mechanical. Spend your brain on the 40% that requires judgment.
4. Context Is More Important Than the Model
A mediocre model with great context produces better code than a top model with no context. Across all tools:
- Provide project conventions — rules files, instructions, CLAUDE.md
- Reference existing code — “follow the pattern in file X”
- Include constraints — “we use PostgreSQL, not MongoDB”
- State what you don’t want — “no class components, no lodash”
Investing 5 minutes in context setup saves hours of correcting wrong output.
5. Learn Your Tool’s Keyboard Shortcuts
Every AI tool has shortcuts that save massive time:
| Action | Cursor | VS Code + Copilot | Windsurf |
|---|---|---|---|
| Inline edit | Cmd+K | Cmd+I | Cmd+K |
| Accept suggestion | Tab | Tab | Tab |
| Partial accept | Ctrl+→ | Ctrl+→ | Ctrl+→ |
| Open chat | Cmd+L | Ctrl+Cmd+I | Cmd+L |
| Cycle suggestions | Alt+] | Alt+] | Alt+] |
| Reject suggestion | Esc | Esc | Esc |
Memorize the 5-6 shortcuts you use most. The speed difference between keyboard-driven and mouse-driven AI workflows is significant.
6. Version Control Before AI Edits
Before any AI-powered refactoring or feature implementation:
git add -A && git commit -m "checkpoint before AI refactoring"
This gives you a clean rollback point. If the AI produces something you don’t want, git checkout -- . gets you back instantly.
Better yet: create a branch for AI-assisted work and merge only after review.
7. The “Explain Then Implement” Pattern
For complex tasks, ask the AI to explain its approach before writing code:
Before implementing, explain:
1. What files you'll create or modify
2. What approach you'll take and why
3. What trade-offs this approach has
4. What assumptions you're making
Then wait for my approval before writing code.
This catches misunderstandings before they become 500 lines of wrong code.
8. Maintain a Prompt Library
When you find a prompt that works well, save it. Create a prompts/ directory or a note with:
- Your project setup prompt (conventions, stack, patterns)
- Code review prompt
- Test generation prompt
- API endpoint generation prompt
- Refactoring prompt
Reusing proven prompts is faster than crafting new ones every time.
9. AI Cost Management Across Tools
Monthly costs can add up fast. Track and optimize:
- Free tiers first — Copilot free, Gemini free, Q Developer free cover basic needs
- One subscription — pick Cursor OR Copilot Pro, not both
- Pay-per-use for spiky usage — if you don’t code daily, API-based tools (Aider, Continue) may be cheaper
- Local models for simple tasks — Ollama is free and handles basic completions well
For developers in Latin America, where USD subscriptions are proportionally expensive, optimizing tool costs matters more than in high-income markets.
10. Know When to Stop Using AI
Recognize when AI is slowing you down:
- You’ve reprompted the same thing 3+ times — write it manually
- The task requires deep domain knowledge AI doesn’t have — code it yourself
- You’re debugging AI-generated code longer than it would take to write — start over
- Security-critical code — write and audit manually
- You’re not learning — occasionally code without AI to maintain your skills
AI tools are productivity multipliers, not replacements for understanding. The best developers use AI strategically, not compulsively.
Bonus: Teach AI Your Patterns, Don’t Adapt to Its Patterns
If an AI tool consistently suggests patterns you don’t like (class components when you prefer functions, lodash when you prefer native methods, etc.), don’t adapt your code to what the AI suggests. Instead:
- Update your project instructions/rules to explicitly state your preferences
- Reference example files that demonstrate the patterns you want
- Reject suggestions that don’t match your style
Your codebase should reflect your team’s decisions, not whatever the AI’s training data favored.
What’s the AI development principle that changed your workflow the most? Share below. 