Back

Notes from months of AI-assisted coding

6 minute read4 minute read

There are so many resources out there on how to use Cursor efficiently, but since I get asked a lot about very specific questions, I thought I’d just compile them here. If you’re just getting started I recommend reading How I Became 3x More Productive in 30 Minutes with Cursor. Also, I can’t really shut up about how good this tool is.

Anyway, here my observations:

  1. Get surgical with your cursor placement
    When you want to edit a single function, put your cursor at the same row as the function signature. This helps when changes are isolated to the function scope. It provides Cursor with better context and leads to more accurate suggestions. Plus, it keeps you focused on one thing at a time. It’s all about the context.

  2. Define your Cursor rules
    Take some time to actually define your Cursor rules. They will shape how you write your projects. Whenever you find yourself repeatedly specifying something in a prompt, it’s probably a good time to put it in the Cursor rules. This could be anything from always using a specific component for a task to writing tests in a certain way. Use cursor.directory for inspiration. This is also how you align with your team and define your ways of how you want to work.

  3. Use templates and boilerplates
    If you have templates or boilerplates that you frequently use, store them in a separate folder that can serve as context. It’s like having a coding cookbook that Cursor can reference. When starting a new project or adding a feature, you can tell Cursor to utilize these templates, saving time and ensuring consistency. This is like the next evolution of a cookie cutter template. If you can have determinism, use that. It’s way better than using LLMs. Faster, cheaper, more consistent.

  4. Leverage voice-to-text tools
    If you’re in an environment where you can speak freely (or you don’t give a), consider using a voice-to-text tool like Better Dictation (referral link). It’s honestly one of the best purchases I’ve made recently. Speaking your prompts can be faster than typing, especially for longer inputs. It allows you to explain complex ideas more naturally.

  5. Be cautious with Composer
    While Composer is powerful, it can produce inconsistent behavior across different files. You need to be very specific with your prompts when using it. Personally, I prefer a surgical approach to AI-assisted coding. I start by generating boilerplate code using Composer, then proceed to make fine-grained edits for better control and accuracy.

  6. Learn all your shortcuts
    This isn’t strictly related to Cursor, but learning keyboard shortcuts will make your life so much better. It doesn’t have to be Vim or Emacs, but understanding how to navigate your editor without touching the mouse is crucial. You shouldn’t have to click on menus, buttons, or files. I can’t stress this enough—become proficient with your shortcuts to improve efficiency.

  7. Read more than you write
    When using a tool that generates code, you’ll find yourself reading more code than you write. Get comfortable with reviewing and quickly refining code. This is why I prefer fine-grained edits; it allows me to produce code rapidly while minimizing errors.

  8. Use .cursorrules over “Rules for AI”
    Only put personal style preferences in “Rules for AI.” For project-specific guidelines, always use .cursorrules. This ensures consistency across your team and projects, while keeping your personal preferences separate.

  9. Utilize the terminal with CMD+K
    Don’t forget about the integrated terminal accessed with Cmd+K. You can run git commands, start servers, install packages—all without leaving Cursor. I’ve had this feature enabled but haven’t really used it. Maybe it’s time I start.

  10. Write longer prompts
    Don’t hesitate to write more detailed prompts. You won’t regret it. Use a voice-to-text tool to make this easier. My workflow typically involves explaining what I want, how I want it, and why I want it. Then I guide the models through a chain-of-thought process, helping them reason through each step.

  11. Experiment with different models
    Play around with different AI models for various tasks. They might perform differently depending on the context. While I haven’t found the perfect use case for o1, I often fall back to GPT-3.5 for its versatility.

  12. Embrace productivity gains
    The question often arises: “How much more effective is a developer today compared to three years ago?” Productivity gains are estimated at 20-50%, and the industry is feeling the impact. Tools like Cursor allow those who couldn’t code before to start coding, and help experienced developers focus more on core problems rather than syntax. I do believe everyone who’s a software engineer can benefit from a tool like this.

  13. Feel at home with Cursor
    If you’re comfortable with VS Code, you’ll feel right at home with Cursor since it’s just a fork. It includes your familiar shortcuts, themes, and most extensions work the same. You’re simply adding some extra superpowers to your favorite IDE.

  14. Compliance workarounds
    What if someone tells you AI tools can’t be used in their projects? Compliance issues like GDPR can complicate matters. In such cases, consider solutions like AWS Bedrock Access Gateway. It provides an OpenAI-compatible interface for Bedrock, allowing you to forward requests through compliant channels. You can then use the OpenAI config in Cursor.

  15. Use Cursor for rubber ducking
    Even if you’re skeptical about AI, there’s value in using Cursor for rubber-duck debugging. Explaining your code to the AI can help you understand it better. It can assist with everything from generating scaffolding to prompting documentation and clarifying how certain features work.

  16. Join my Cursor workshops I host Cursor workshops to help developers get the most out of this powerful tool. You can check them out at git.new/cursor-workshop. In these sessions, I also share some other AI-powered tools I like to use, including those for code review, documentation generation, and test writing. Exploring these can further boost your workflow. Reach out on eric@anyblockers.com or DM on twitter @ericzakariasson if you’re interested in joining.

  17. Integrate with Git
    Use Cursor alongside Git for streamlined version control. It can help with commits and reviews, offering suggestions for commit messages based on your changes and assisting with pull request reviews by explaining code changes.

  18. Team coding with AI
    Cursor can enhance team collaboration if you establish some ground rules. Agree on when and how to use AI-generated code, set standards for reviewing AI suggestions, and consider implementing shared .cursorrules for consistency across the team.

There’s also a plethora of AI-powered tools available, but for me, the real power lies in consolidating everything within one-stop-shop IDE. I like to draw a parallel with IDEs and spreadsheets; they’re enduring because they centralize a lot of work. While past tools might not have been perfect, we’re making significant progress. This is why I’ve started exploring spreadsheets as a primitive concept. One of my first experiments is sendsheets, which is built exclusively with Cursor.

These have been my observations from the field. I’d love to hear what works for you and what doesn’t.

Many resources on using Cursor well exist. I get very specific questions a lot, so here they are. New? Read How I Became 3x More Productive in 30 Minutes with Cursor first. Also, I cannot shut up about this tool.

Observations:

  1. Get surgical with your cursor placement
    Editing one function? Cursor on function signature row. Helps when changes stay in function scope. Better context, more accurate suggestions, one thing at a time. All about context.

  2. Define your Cursor rules
    Define Cursor rules. They shape how you write projects. Repeating something in prompts? Put it in rules. Always use specific component, write tests certain way, anything. cursor.directory for inspiration. Also aligns team on how you work.

  3. Use templates and boilerplates
    Frequent templates? Separate folder as context. Coding cookbook Cursor references. New project or feature: tell Cursor to use templates. Saves time, keeps consistency. Next evolution of cookie cutter. Determinism available? Use it. Beats LLMs: faster, cheaper, more consistent.

  4. Leverage voice-to-text tools
    Can speak freely (or do not give a)? Voice-to-text like Better Dictation (referral link). One of my best recent purchases. Speaking beats typing, especially long prompts. Complex ideas come out naturally.

  5. Be cautious with Composer
    Composer is powerful, inconsistent across files. Be very specific. I prefer surgical: boilerplate from Composer, then fine-grained edits for control and accuracy.

  6. Learn all your shortcuts
    Not Cursor-specific. Shortcuts make life much better. Not necessarily Vim or Emacs, but navigate without mouse. No clicking menus, buttons, files. Cannot stress enough.

  7. Read more than you write
    Generated code means more reading than writing. Get comfortable reviewing and refining fast. Why I prefer fine-grained edits: rapid code, minimal errors.

  8. Use .cursorrules over “Rules for AI”
    Personal style only in “Rules for AI.” Project guidelines in .cursorrules. Team and project consistency, personal preferences separate.

  9. Utilize the terminal with CMD+K
    Integrated terminal via Cmd+K. Git, servers, package installs, all in Cursor. Enabled, rarely used. Maybe time to start.

  10. Write longer prompts
    More detail, no regret. Voice-to-text makes it easy. My workflow: what I want, how, why. Then guide model through chain-of-thought, step by step.

  11. Experiment with different models
    Different models per task. Performance depends on context. No perfect o1 use case yet. I often fall back to GPT-3.5 for versatility.

  12. Embrace productivity gains
    Common question: “How much more effective is a developer today compared to three years ago?” Estimates 20-50%, industry feels it. Cursor lets non-coders code, lets experienced developers focus on core problems, not syntax. Every software engineer benefits.

  13. Feel at home with Cursor
    Know VS Code? Cursor is a fork. Same shortcuts, themes, most extensions. Superpowers on your favorite IDE.

  14. Compliance workarounds
    AI tools banned in project? Compliance like GDPR complicates. Consider AWS Bedrock Access Gateway. OpenAI-compatible interface for Bedrock, requests through compliant channels. Then OpenAI config in Cursor.

  15. Use Cursor for rubber ducking
    Skeptical about AI? Rubber-duck debugging still pays. Explaining code to AI helps you understand it. Plus scaffolding, documentation, clarifying features.

  16. Join my Cursor workshops I host Cursor workshops: git.new/cursor-workshop. Also share other AI tools I like: code review, documentation generation, test writing. Interested? eric@anyblockers.com or DM @ericzakariasson on twitter.

  17. Integrate with Git
    Cursor with Git: commit message suggestions from changes, pull request review help by explaining changes.

  18. Team coding with AI
    Cursor helps teams with ground rules. Agree when and how to use AI code, set review standards, share .cursorrules.

Plethora of AI tools exists. For me, real power: everything in one-stop-shop IDE. Parallel: IDEs and spreadsheets endure because they centralize work. Past tools imperfect, progress big. Hence I explore spreadsheets as primitive. First experiment: sendsheets, built only with Cursor.

Field observations. Tell me what works for you and what does not.