This content originally appeared on Level Up Coding - Medium and was authored by David Bethune
Cursor, an AI code writing and editing tool, represents a significant advance in the practical use of artificial intelligence in software development, primarily by offering “agents” that can not only answer questions but act on their own ideas. This powerful new ability requires a new approach to programming where your advanced reasoning skills become even more important than before. When an agent is “licensed to kill,” your instructions as Director make all the difference.
This article is part of my AI Library. The articles are listed in order of complexity. They’re not meant as prerequisites but rather alternative entry points to these topics:
- Behind the Curtain | Understanding the Magic of ChatGPT
- No math or programming - Last Night an AI Saved My Life | Debugging with ChatGPT
- Programming - Zero to Hero | Crafting a Custom GPT
- Programming - Something From Nothing | A Painless Approach to Understanding AI
- Math and programming - License to Kill | Coding with Cursor AI Agents
- Programming
Your Mission, Should You Choose to Accept It
I want to show you how to find Cursor’s most clever features and how to use them to maximum advantage, but I don’t recommend that you start there. If you’ve worked with other AI tools, dive in at the point where you’re using Cursor the same way as you used your last tool. For me, that was VS Code with Copilot. Once any “differences” in Cursor are smoothed out, try the next level of sophistication.
Here’s what we’ll cover. Feel free to skip any parts you already know about or have tried.
- What Is Cursor & Why?
- Inline Completions
- Tab to Complete
- Chat with Code
- Fix in Chat
- Agentic Thinking
- Copying Your Style
- Settings
- Token Limits
- Running an Agent
Late Update: Cursor has changed the user interface to combine the Chat and Composer tabs into one chat box, so your screenshots may vary from mine.
1. Wherefore Art Thou, Cursor?
What Is Cursor & Why
Cursor is one of the first truly useful RAG applications. Retrieval Augmented Generation is a fancy way of saying “use AI chat to figure out how to control the interface of an application instead of just pressing buttons and clicking menus.” Every RAG application combines some traditional user interface with a backing LLM or Large Language Model and a chat box. For Cursor, the traditional application is VS Code, an IDE or text editor optimized for writing code.
Cursor is also agentic, meaning it can act semi-autonomously like an agent under your control to complete tasks that you two agree on in advance. That control can extend from creating new files and fixing hundreds of lines at once across multiple modules — to deleting files, breaking interfaces, and preventing your code from running. Hence the title of this article.
If you’re already used to VS Code, you can import your key bindings and settings. I had to make one small adjustment because one of my custom keys was taken over by Cursor, but it was easy to fix because my binding wasn’t wiped out. Removing the Cursor binding left my original there and working. This import feature makes it easy to move to Cursor from VS Code, which is the most popular IDE by a wide margin.
You may be asking at this point, “If Cursor is VS Code under the hood, why not just make it an extension?” To that question, the Cursor development team replied that the changes they’ve made would be impossible with just an extension. By the end of this article, you’ll see that’s true. Cursor takes over full control of the IDE in a way that no extension would be able to.
Safety First
It should go without saying that if we’re going to give an agent control over our valuable codebase, we should be using best practices with Git. For me, that means making sure that I always have a copy of the repo that runs and that I check-in code (I use GitKraken with GitHub) at the right places in between letting Cursor run off with a gun. If I’m about to ask for a big change, commit and push that repo first. If something works correctly, commit and push again so I can roll back if the next change doesn’t work.
This way of thinking will play a big part in the new coding style that agents require. We used to try to carefully write working code at the beginning and then build upon that. This is still the case, but with agents you will find that many, many lines of code get written and immediately wiped out with better (or even just correct) code and nobody cares.
In other words, the work of writing the code becomes so fast and so cheap that it is no longer the primary work. The primary work becomes assessing those changes en masse and accepting or revising them. It’s a wild new world!
They Took ‘Er Jobs!
One key takeaway I want you to have from this article is that Cursor (or the Next Big Thing) is not going to eliminate your job as an experienced programmer. It’s exactly the opposite. I want you to see that being a human, an overseer, a manager, an architect, a deep thinker, and a person with wants and needs and feelings (yes!) is going to play even more of a role in AI-assisted coding than it did in the previous generation of software development.
When programmers are freed from the grunt work of typing low-level syntax and connecting interfaces in modules or APIs, we are left with the harder, human-level work of figuring out what should be done to the code in the first place.
You’re going to find quite quickly that 007’s ability to shoot anything requires very precise planning on your part to shoot the targets you want. You’ll also see how we get the endless stories about “I made an app in an hour with AI” that claim these tools are going to fix everything. What’s happening is that the writers of those stories used a tool like Cursor to build an app without specifying anything important. This is like sending Bond out on a mission to kill someone, anyone, for any reason. With no constraints and no parameters, of course you could write code.
The problem is that no real world application works this way. In our jobs, we have to continually evolve and expand (and replace) systems with hundreds or thousands of constraints and requirements. And while Cursor can see all your code, it cannot understand any of that. It will never know why you’re doing something or what you want — and I’ll show you later how you must bring up those issues in human terms. Even with the most careful guidance and prompting, your skills as a human programmer will be challenged and, I dare say, leveled-up by working with a pair programmer at the level of Cursor AI.
2. The Main Vein
Inline Completions
AI coding tools are often described as “autocomplete on steroids.” That’s a good starting point. Cursor can help you write or extend code by placing the cursor somewhere and starting to type, just like Copilot. I’ll take a guess here and say that the product is called Cursor because this concept of where the cursor is and what it can do is the overall driving principle behind the whole thing. In full agent mode, “the cursor is everywhere” and has the autocomplete power that we’re used to… times 1000.
As Above, So Below
The first thing you’ll notice about Cursor’s autocomplete is that it looks at a few lines above your cursor as well as a few lines below. If you make a change that’s going to break something a couple lines below, Cursor will go ahead and suggest that change, too. This is incredibly useful, especially with its ability to look into other modules. Cursor is able to figure out changes that are quite complex and make the necessary updates in big groups, rather than one line at a time. Big timesaver.
3. But Wait, There’s More…
Tab to Complete
As code evolves to accommodate new features or gets refactored to clean it up, a single change often necessitates many (low-level) changes in the same module. These aren’t hard to figure out. In fact, you can probably figure them out before you make the first change. For example, if something changes in a module you’re importing or in the import statement itself, you’ll have to adjust all the uses in this module.
That’s the kind of programming I call “donkey work.” Do I know what needs to be done? Yes. Can I tell if it’s correct or not? Yes. Do I want to sit there and do all of those? No. Well, guess what? Because it reads the linter (the error checker that puts red squiggles under lines it’s unhappy with), Cursor knows about all of the errors in advance, too.
This is where the Tab key becomes your best friend. By hitting Tab, Cursor will jump to the next line that needs fixing — no matter how far down in the module it is! Now, the donkey is walking to the next pile of rocks, not me.
Because it’s hundreds of times faster to read code than it is to write it, I can review the suggested change almost instantly and then press Tab to jump to the next one.
If this were all Cursor did, it would still be worth switching. Because the Tab key has lots of uses, Cursor doesn’t always get it right. But that’s OK, because you just undo the change you don’t like (with your normal keyboard shortcut) and press Tab again! Sometimes you need to move the cursor itself closer to the problem and press Tab to get the fix. This all seems very weird at first. You’re just tossing big blocks of code in and out. You’re not writing them. But when you realize that you have completed huge changes across multiple modules by doing nothing more than opening files and pressing the Tab key, you’ll start to think it might be kind of great!
4. Let’s Talk About Code, Baby
Chat with Code
Cursor advertises that you can “chat with your code” and it may seem like you have been doing that all along with other tools. I can assure you, you have not. What they mean with Cursor is specifically calling out files and functions by referencing them with the @ key. If you want to make a change in your doSomethingGreat() function, you can write @doSomethingGreat() in the prompt.
Fortunately, Cursor already knows all your file (and folder) and function names so you don’t have to type the full name, just enough to get it to autocomplete, then press — you guessed it — Tab! You don’t have to tell it where your functions or files are, either.
When you reference your code in this way, you’re including the current source in the prompt and ensuring that its content is considered in the answer. How much of your code is available to Cursor to mess with at any one point in time depends on which mode you’re using to interact with it (more on that later), but calling out code by function, module, file, or folder name always points Cursor to that exact code.
This means we can ask more complex questions like, “Can you find all the places in @components where I have a wildcard import?” and Cursor will look for answers only in that folder. At the highest level, we can write @codebase and Cursor will take into account the entire codebase when generating the answer. In agent mode, @codebase is included in all requests and we use specific module or function names to restrict actions or point to specific code constructs.
5. Fixer-Upper
Fix In Chat
VS Code has a very limited ability to fix linting errors when you put the cursor on them. A dialog appears with options for obvious stuff like missing imports. But VS Code can’t really analyze the codebase or figure out a deeper fix. That’s where Cursor’s Fix in Chat option helps. It replaces the VS Code pop-up on those kind of errors.
When you choose Fix in Chat, the error you’re seeing is copied over to the chat window on the right side of the screen. The chat automatically sees the entire @codebase and can also perform deeper investigation into those other files.
This is perfect for addressing problems where you’re seeing the error in one module but it’s really caused in another. And here again, you probably already know what’s wrong and you could fit it yourself. What’s great about having Cursor do it is that it’s fast and accurate and doesn’t make dumb mistakes about easy fixes like that, whereas people get tired — especially from repetitive, detailed work, and their performance decreases.
AI performance decreases, too, as the context window or amount of text you’re submitting keeps increasing with the continued thread. This is another place where your adult oversight must come into play. You need to cut off the thread and start a new chat when its topic changes or when its results are achieved to prevent the AI from taking a bridge too far and bringing in irrelevant material. All your previous chats are saved, so if you find you need to go back to a previous issue, reload that chat and continue it so that you include all the previous context.
6. They Laughed When I Sat Down At the Piano…
Agentic Thinking
Agents like Cursor require the most human level of chat of any AI product I’ve ever used. This is true of reasoning models in general, meaning a model that submits its own output back to the LLM to see if it’s right or wrong. In the previous kind of LLM programming like I talked about in my other articles, I advised breaking down your instructions into small steps so that the AI would act only on what you said.
This approach does not work with agents.
To get the agent to work for you, you must bring in the human aspect. You must say things like, “I want” and “I feel” and “I’m concerned about…” Stuff that a relationship counselor tells you to say to your partner. This seems very counterintuitive, especially when I generally dislike anthropomorphizing machines because it leads us to thinking they’re magical. But here it’s necessary because the “reasoning” portion of the model will take your feelings into account when deciding whether a solution is right or wrong (like a good partner).
One of the best (and also the most frustrating) things about software is that there are a million ways to do everything. Software nerds have some of our best arguments about all the “right” ways to get software to work. And it’s 99% BS because all software and all computers are functionally equivalent under the hood, as proved by Alan Turing.
Since there is no “one right way,” your agent that’s licensed to kill will absolutely come up with some way to do what you ask. Guar-an-teed. Will it be the right way? What is the right way for your application? Only you know that.
You must know it very well in order to get the AI to comply. You cannot be wishy-washy in your demands, or you will get some other working way that isn’t the “right” one for your app.
This is where the AI agent forces you to level up as a programmer! If you cannot completely describe how your application should work, it will only work insofar as the AI decides that it should. And that’s a long way from Tipperary.
When the term “prompt engineering” first came out, it was kind of a joke. Not anymore. I have had to really sit and think about my prompts — not only what would be in them but how many would be needed to get to the finish line, where to break the chat threads, and what to say and what not to say.
As much thought goes into agentic prompts as went into traditional programming. The only difference is, this new approach is much faster.
And this is why our jobs as experienced programmers is going to be even more important in this new era. Even if we could get to a prompt that fully included all of the specifications of an application (visual design, JIRA tickets, TDD, QA, etc.) a human would have to be the one making that spec, and that will be given to one of us as our job. A human will need to orchestrate a RAG application that builds and maintains such code. But that human won’t be writing much code, just approving or denying it and calling out additional changes and improvements to be made.
Nor will companies be able to hand over these agent coding tasks to junior programmers — precisely because they are lacking the overall architectural view that’s needed to tell the agent what to do. There is a reason that James Bond was not the director of British Intelligence. He didn’t have enough intelligence, enough information, enough of a global worldview.
This Message Will Self-Destruct…
When you submit a prompt to an agent, you give it the power to make all of the changes that it suggests, including massively writing, re-writing, or removing code, creating and deleting files, overhauling your build settings or runtime environment, or other massive changes that clearly involve breakage.
Why would you do that? Well, in the real world we do that all the time. Developers make breaking changes all day long. In many cases, it is simply not possible to extend an app without first breaking it — and that’s by design. We don’t want to try to build for the far future, so we have break the simple designs and connections we built at first to get to more robust modules that are reusable and can be deployed in different ways.
What really happens is that we usually slog thorough all those changes by ourselves, in silence. We massively change our front end to accommodate an API change or we change our backend because the tooling requires it. It’s a hidden time sink that we don’t talk about because we didn’t have a better way.
Agents are the better way. If we can describe the massive change we need at a high level and touch on all the possible “gotchas” or all the important constraints that the change must include, we can sit back and watch the agent do them all — moving from one working version of the code to the next without running an interim broken version in-between.
Now part of you is saying that’s not possible and it’s going to break in-between. And you’re right. But you just ignore that. Even if your big fix requires rolling back a whole series of changes that Cursor made (like dumping the work-in-progress files from the repo), it doesn’t matter because you’re just going to send the agent off again immediately to write new ones.
This is a clear example of when we need to let go of the old style of programming to make this work.
Instead of stopping the agent in the middle and trying to make it all fit together in your head, we can let it attempt to complete the task and assess it ourselves. If it’s not right, we dump it out and change our prompt, telling it what we didn’t like or what went wrong.
When we had to write every line of code ourselves, it made sense to carefully consider them all individually. But with the agent, it doesn’t make sense to do that. Often, Cursor will come up with a solution and decide in the middle of implementing it that it’s not great. Then it proceeds to self-correct!
Other times I will hit the stop button if it’s forgotten something important or is going down an obviously wrong road. But who is to blame for that? Not Cursor. If I had included the constraint or issue in my original prompt, I wouldn’t have had the problem in the first place. Big Human Thinking and an architectural viewpoint rule the day here.
Those “revision” conversations are the ones that look most like marriage counseling. I find myself saying things like, “I’m concerned that we’re overlooking so-and-so,” or “I’m really not comfortable with changing that because of this other thing.” But just like a human partner, the AI would have no way to know my concerns unless I voice them directly. I’m often surprised at how, when solving more difficult problems, these “communication encounters” were what led to the working fix.
7. And I’m Unanimous In This
Copying Your Style
In the early days of AI coding, people were concerned that the suggestions would be lifted out of someone else’s codebase. It should be evident from what I’ve said already that, while training on existing code gives Cursor (Claude Sonnet, really) much of its underlying understanding, taking action on my code and copying my code is what gives it power.
With this in mind, I try to make many references to my own code and my own style. I say things like, “Change all the comments in @someFolder to use the pattern established in @myModule.” Or, “I want to develop a module that handles audio files for my game in the same way as @app-node-images handles the image files. The audio files will be in the @mp3 folder.” And let it write the new module. All of the style and patterns and even comments will be taken from my existing module and updated for audio. Things like key names will be adjusted automatically… the whole works!
I’ve always been a believer in copying my own working code and then editing it to fit the new scenario. Now, I can just tell Cursor to do that. It’s a lot faster to scan the module it wrote and customize it myself than to copy and paste it from the old one and make the minimum, manual edits! I can do a refactor in one module and then say “Refactor @someOtherModule in the same way” and Cursor will open the other file and show me the changes with green lines for additions and red lines for deletions.
8. Throw Out The Rulebook
Settings
Cursor’s many differences from AI chatbots can be overwhelming at first, and the numerous settings aren’t exactly obvious. In a nod to the earlier generation of Custom GPTs that worked by defining strict rules, Cursor does allow you to setup rules for your chats and projects — like “always use library version so-and-so,” or other overall constraints you want to add. But I’ve found in practice that’s not necessary because Cursor can already figure out what you’re working with and it’s unlikely to suggest something too far outside your current app. I didn’t need to explain that I was working with Lit or Vite, for example, to talk about my web components or build issues.
Let’s go through the most important settings…
You can use Cursor entirely free, but your requests will all be in slow mode and cut off after you hit a monthly limit. They still work perfectly well, you just have to wait while the folks who paid for extra credit get their prompts queued first. It’s absolutely serviceable and I’d recommend you do all your experimentation in this free mode. You can expand to Pro mode (currently $20/mo) to get a block of fast requests every month and unlimited slow requests. Beyond that, you can buy extra tokens if you see the value in buying increased speed.
Riddle Me This…
On the Models tab in Cursor settings, you can turn models on and off, and later down on the page it looks like you can type in your own API keys and perhaps get around these limits. And perhaps you can, but you’ll need keys for both OpenAI and Anthropic and honestly I doubt there would be much of a savings unless you were on a huge plan from both those companies, but it’s worth poking around. The complex agent requests require Claude Sonnet, which is the current leader in AI coding tests.
Juicy Fruit
Finally, on the Features tab is where we get to the good stuff. I’ve turned on all the tabbing and prediction features I mentioned. I’ve also allowed it to act on files outside the ones mentioned in my prompt. This let’s it fix all the necessary files that come into play with one of my requested changes.
You’ll see that I did not check the YOLO mode box at the bottom. By default, Cursor stops at every single action (a completed request) in chat. When you submit to an agent, most actions complete automatically but not things like file deletions, which wait for your approval. YOLO mode would turn that off and I’m not there yet. :-)
9. Hit The Bricks, Kid!
Token Limits
After a few days of free mode, then a few days on the $20/mo plan, I decided to try a large refactor and pay for some extra tokens for fast completions. I set a limit of $20 and consumed $12.64 of that over three days. That’s fairly expensive as far as AI chat goes. Was it worth it for the work achieved in those three days? Absolutely.
I could have achieved the same result in a slightly longer time without paying, or by just paying the $20/month base plan, but any employer will quickly see the value of paying hundreds of dollars a month per programmer for this tool if they are actually cranking out product with it.
If I had to justify this at my last job, it would be easy just based on how many tickets, backlog items, and new features I could get done and how fast. It’s like asking if your employer in a factory would pay for you to have an extra arm. Yes, they would.
10. Lights, Camera, Action!
Running an Agent
In the chat window, choose Agent in the bottom left corner before submitting your first prompt in a new chat. This enables the agent for the entire chat. While it’s thinking and outputting ideas or code, you’ll see a stop button to interrupt if necessary. After each set of changes to a single file, you’ll see the file opened with the changes highlighted. You can accept them individually, or all at once. Once the entire task is done, the chat offers an Accept All button to save all the changes across all files.
Cursor does set rollback points and can undo its own actions, but I don’t use that for changes that I want to undo. I’d much rather rely on my Git repo where I can see a named commit and I know what’s in it. Cursor can do its own rollbacks to complete the tasks I give it, but if I’m going to yank the rug, it’s going to be from Git (or just Ctrl-Z in a module) rather than by asking Cursor to undo something. Whenever I do this, I’m sure to tell it that I reverted the module and why — just like you would do with a human pair programmer.
That’s All Folks!
Those are all my insights for today. I hope you found them helpful. If you did, a clap, comment, or share to your network helps my visibility, especially now that I’m in job hunting mode since my former studio closed.
I do thank you.
As always, I invite you to review my other articles here on Medium and visit me at my website to connect and comment.
Until next time… Be well!
— D
License to Kill: Coding with Cursor AI Agents was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.
This content originally appeared on Level Up Coding - Medium and was authored by David Bethune
David Bethune | Sciencx (2025-03-03T15:30:37+00:00) License to Kill: Coding with Cursor AI Agents. Retrieved from https://www.scien.cx/2025/03/03/license-to-kill-coding-with-cursor-ai-agents/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.