Sam's space

I’ve been experimenting with ai-assisted coding a lot. After trying some options, I’ve settled on Cursor as my daily driver - a VS Code fork turbocharged with ai capabilities that has fundamentally changed how I approach work.

# The promise of coding assistants

Cursor is really a game changer.

What used to take five minutes now takes fifteen seconds.

What used to take a week now takes two hours.

The feeling of flow is near constant as you fly through new features and squash bugs, not writing code but thinking on a higher level.

However, coding assistants aren’t replacing developers - they’re augmenting us, giving us capabilities that feel like having 100 fingers at once.

# Context-aware assistance

The most impressive aspect of cursor is its ability to understand context. When I’m working on a complex feature, cursor doesn’t just see the file I’m editing - it can understand the entire codebase, the relationships between components, and even my coding style.

# Cmd+k: edit code with natural language

The most immediately useful feature is the ability to edit code with natural language instructions. I can select a block of code and press cmd+k, then type something like “refactor this to use async/await instead of promises” or “optimize this database query” - and cursor will make intelligent changes based on my request.

What’s remarkable is that these aren’t just dumb find-and-replace operations. Cursor understands the structure and intent of the code, making changes that respect the existing patterns and edge cases.

# Ctrl+l: chat with your code

When I’m trying to understand a complex part of a codebase (especially one I didn’t write), the ctrl+l chat feature is invaluable. I can ask questions like “why might this function be causing a memory leak?” or “explain the authentication flow in this application” and get contextual answers that take into account the actual implementation.

This is particularly useful when onboarding to new projects or returning to code I wrote months ago. Instead of spending hours tracing through function calls and reading documentation, I can have a conversation about the code itself.

# Composer agent

The most powerful tool of Cursor is the agent that can reason about your code, execute commands, and iteratively makes changes.

The agent has multiple tools, including reading and writing code, searching the codebase, calling MCP servers, running terminal commands, and automatic web searching for up to date information.

This is incredibly powerful.

The conversation with the composer has checkpoints, so you can go back in time and branch out from a specific point in the converstation, if you think you have gone done a wrong path.

# The magical @ operator

One of cursor’s most powerful features is the @ operator, which lets you reference different contexts in your conversations with the ai:

• @file.js - reference specific files
• @folder/ - entire directories
• @codebase - your whole project
• @notepad - internal notes
• @web - search the internet
• @docs - custom documentation
• @summarized composers - reference summaries of long chats with the composer agent

This has been a game-changer for me. When I’m implementing a feature that requires understanding how a specific library works, I can use @web to search for documentation without leaving my ide. When I need to understand how a particular pattern is used across the codebase, I can reference entire directories.

# @Summarized Composers

Reference summarized versions of your previous Composer sessions as context in new conversations. When working on complex tasks in Composer, you might want to reference context or decisions from previous conversations. The @Summarized Composers symbol allows you to include summarized versions of your previous Composer sessions as context.

This is particularly useful when:

• You have a long Composer session with important context you want to reference
• You’re starting a new but related task and want to maintain continuity
• You want to share the reasoning or decisions from a previous session

# Customizing the experience

# Cursorrules

Cursor allows you to define custom instructions for the ai through “cursorrules” - essentially a set of preferences that guide how the ai interacts with your code.

I’ve set up rules like:

• Always include error handling in generated functions
• Use async/await instead of promises
• Use dependency injection where appropriate
• Break down functions that are longer than 20 lines
• Write clean code

This ensures that the code cursor generates or modifies aligns with my preferred style and our team’s standards.

# Yolo mode (for the brave)

For those feeling particularly adventurous, cursor offers “yolo mode” - allowing the ai to make changes without confirmation. I use this sparingly, mainly for repetitive, low-risk tasks like formatting code or adding documentation.

A word of caution: always commit your code before enabling yolo mode. With great power comes great responsibility!

# Real productivity gains

The most significant impact cursor has had on my workflow isn’t just writing code faster - it’s changing how I approach problems entirely:

# Faster onboarding to new codebases

When joining a new project, I used to spend days just trying to understand the architecture and how different components interact. Now, I can ask cursor to explain the project structure, identify key components, and even generate diagrams of how everything fits together.

# Minimal time spent on stack overflow

We’ve all been there - spending hours searching for the right way to use an api or fix an obscure error. With cursor’s web search integration, I can ask these questions directly in my editor and get relevant answers without context switching.

# Rapid prototyping

When exploring new ideas, cursor excels at generating scaffolding code that I can then refine. I’ll describe what I want to build in natural language, and cursor will generate a working prototype that I can iterate on.

# Fewer context switches

Perhaps the most underrated benefit is the reduction in context switching. Staying in the flow state is crucial for programming productivity, and every time you switch to a browser to look something up, you lose that flow. Cursor keeps me in the editor, maintaining focus for longer periods.

# Limitations and drawbacks

Cursor isn’t perfect, and it’s important to be aware of its limitations:

• It’s not a silver bullet - you still need to understand what you’re building and why
• It likes to write a LOT of code - sometimes more verbose than necessary
• It doesn’t always admit when it’s wrong - you need to verify its suggestions
• It can go down seriously wrong paths if your instructions aren’t clear

I’ve learned to use cursor as a collaborative tool rather than an oracle. I verify its suggestions, refine its output, and maintain final responsibility for the code that gets committed.

# Privacy and security considerations

# models

For those concerned about code privacy (as I was), cursor offers various privacy settings and is transparent about how it handles your data.

You can control what gets sent to the ai models and even use local models for sensitive projects. For most of my work, I’m comfortable with the default settings, but it’s good to know these options exist.

# Getting started with cursor

If you’re interested in trying cursor, here are some tips from my experience:

1. Start with small, focused edits to get a feel for how it works
2. Be specific in your instructions - the more precise you are, the better the results
3. Use the @ operator to provide relevant context
4. Review ai-generated code carefully before committing
5. Build your own cursorrules over time to match your preferences
6. Commit before making major changes (especially with yolo mode)

# Conclusion

AI-assisted coding with tools like cursor represents a significant shift in how we write software. It’s not about replacing developers but augmenting our capabilities, allowing us to focus on higher-level problems while the ai handles more routine aspects.

After months of daily use, I can’t imagine going back to coding without these tools. The productivity gains are real, and the reduction in cognitive load allows me to focus on what matters - solving interesting problems and building useful software.