Next-Level Cursor: Cmd+K, Composer, and Agent Unpacked

In this article, let’s continue to explore Cursor even further. Our first article (

) covered Cursor’s basics and the easiest-to-understand features, such as 

 feature. So, if you’re new to Cursor, I highly recommend you check the previous article.

In this “Part 2” article, we’ll go over the 

 features, including some use cases. So, get ready to learn how to use Cursor to its fullest potential and save an enormous amount of time.

Starting from version 0.46, Cursor includes a lot of UI changes for the AI side panel. That’s why, if you’re currently using an older version, the UI elements mentioned in this article might not look the same for you. That’s completely fine, but I highly recommend you update to the latest version so we’re on the same page.

The easiest way to do so is to just wait until the 

 message appears in the bottom right corner and then click on it.

Besides the UI refresh, starting from version 0.46, Cursor also includes the new Agent feature. No worries, we’ll cover it in this article too.

Regarding updates, here’s how the UI has changed. Now, all the modes are available under a single dropdown:

If you want to know which version and features are the latest, just visit Cursor’s changelog - 

Also, if you are new to Cursor’s UI, to open or hide the AI panel, just click on the right rectangle or use the shortcut from the screenshot.

Great, now we should be on the same page. So, let’s continue exploring Cursor even further.

In Cursor, pressing "Cmd + K" (or "Ctrl + K" on Windows/Linux) brings up the "prompt bar." It’s a feature that lets you use an AI in-line editor to generate and edit your existing code.

For you, it might sound similar to the “Chat” feature that we discussed previously. So let's quickly cover the differences:

Cmd + K (Prompt Bar) is primarily used for generating or modifying code directly within your current file. This feature is ideal for in-line editing tasks, such as writing new functions or refining existing code snippets. It provides a quick and efficient way to apply changes without leaving the code editor.

The "Chat" feature opens an AI chat panel in the sidebar, allowing for broader code discussions and multi-round conversations. This mode is better suited for more general programming questions, debugging assistance, or when you need to engage in a dialogue with the AI about your codebase. It supports referencing specific code blocks and can provide explanations or suggestions based on the context of your project.

So, in short, "Cmd + K" offers an in-line editing experience, allowing for immediate code adjustments, whereas the "Chat" feature provides a conversational interface, enabling detailed discussions and iterative problem-solving.

Finally, let’s explore the main "Cmd + K" use cases: code generation, code editing and terminal use.

When you press "Cmd + K" without selecting any code, you’re going to generate code with your commands. For example, typing "create a function to add two numbers" will prompt the AI to write that function for you.

If you highlight a section of code and then press "Cmd + K," the prompt bar enables you to specify changes you’d like to make. So, whenever you are highlighting something, you can think of it as the “Editing” mode. For instance, selecting a function and typing "optimize this function" will guide the AI to improve it accordingly.

If you're uncertain about a particular piece of code, you can select it, press "Cmd + K," and then "Option/Alt + Enter" to ask the AI specific questions. The AI will provide explanations or insights about the selected code, enhancing your understanding.

Also, just like in the chat feature, you can directly reference your other code to make your conversations more context-aware by using the 

 if you are unfamiliar with this feature and need more context.

After the AI generates or edits code, you can further refine the result by providing additional instructions in the “Follow-up instructions…” section and pressing "Enter." This iterative process allows for continuous improvement of the code based on your feedback.

And if you’re satisfied or unsatisfied with the generated code, simply press “Accept” or “Reject” to apply or remove the changes.

Additionally, we can use "Cmd + K" in Cursor’s terminal. Here, you can describe the action you want to perform, and the AI will generate the corresponding command. You can then run this command immediately by pressing "Ctrl/Cmd + Enter.”

As we can see, the 'Cmd + K' feature in Cursor AI serves as a versatile assistant that helps you generate, edit, and understand code right inside the file you're working on.

The more code you want to highlight and edit, the worse the results. You want to be as precise as you can, since it works best with small to medium snippets of code. So, it’s better to select only the relevant parts that you want to update.

If you want to update a large amount of code, you’d better use Chat, Composer or Agent for better results.

Here’s a small note: you can save changes first (Cmd + S) before accepting them. This way, you can run and check your code before applying the generated changes. So, if you don’t like something, you can easily “Reject” all changes and ask for updates.

Before we begin discussing Composer, let's take a quick look into the future and mention the Agent feature. As was mentioned at the start of this article, starting with version 0.46, Cursor added a new Agent mode. In essence, Agent is a more powerful version of Composer, and I generally recommend using Agent over Composer. P.S. I wouldn't be surprised if, in a future update, Composer is deprecated altogether.

However, since a lot of concepts in Agents are built on the top of the Composer, let’s start from there first as it’s a good introduction. Additionally, it's interesting to cover Composer as part of Cursor’s evolution.

But before we move forward, let me remind you that in the new version of Cursor, the “Composer” feature was renamed to “Edit.” So from now on, you can think of Composer and Edit as the same feature.

What exactly is Composer? Composer goes beyond simple code suggestions, enabling you to create and edit multiple files simultaneously. This means you can give high-level instructions, and Composer will not only generate the necessary code across various parts of your application but also create files and folders as needed. In fact, multi-file updates are the main benefit of Composer and where it shines the most.

For example, if you're building a web application, you can instruct Composer to set up both the front-end and back-end components. It handles tasks such as creating the user interface or setting up server-side logic, allowing you to focus on refining and customizing the generated code to suit your specific needs.

Once you've opened Edit/Composer mode, it gives you a space where you can describe what you want—like “make me a basic to-do list app”—and it will figure out how to create the files and code you need.

Now that you understand the main concept, let's move on to some more practical workflows and explore a couple of key features that you'll use in your day-to-day work.

When giving instructions, you can get really specific about which parts of your codebase you want to work with, use, or update. And it’s super easy to do.

Let’s say you’ve got multiple files open across several tabs. You can tell Cursor to work only with those files.

To do this, while writing an instruction, you can type a slash (

 option. This tells Cursor to update only the selected files. Once you’ve added those files to the context, you can even use natural language and refer to them as “those files,” and the AI will pick it up.

Another way to reference files is just by using plain language. For example, you can say, “Create a new component and save it to this specific folder,” or explain a path where something should go. You could also tell Cursor to update a document in a certain folder. It’ll try to understand your project’s structure and do the task. But if you’re not clear about the file path, it might save things in the wrong place.

Okay, so now you can update or generate files. But what if you want to undo some changes or keep them organized? That’s pretty simple too.

Let’s start with reverting changes. Imagine you’ve had a long chat with Composer, and you want to go back to a certain point and wipe out the previously generated code/files. To do that, just scroll to the specific instruction you gave earlier and click the 

 button. This will toss out all the changes up to that task.

Another situation is when you’ve made a bunch of changes or created lots of files and want to check them over by hand. To do so, after generating, just click the 

This opens an in-chat menu where you can click on each file to quickly open it, as well as accept or reject the changes related to it.

Not only that Cursor also gives you tons of ways to handle updates—like going file by file or accepting everything at once.

If you want to accept all changes at once, just use the button shown below.

If Composer suggests running some terminal commands, you don’t even need to open a terminal yourself. Just click the 

It might be just one or multiple commands at once.

Don't forget that Cursor's chat is multi-modal. You can also provide images as references. This is useful not only for writing code based on your visual references but also for bug fixing.

Speaking of bug fixing, it works the same way as the Chat feature we covered in our previous article. Just hover over your issue, and Cursor will offer to help fix it. Or you can copy and paste your issues directly into the chat yourself.

You can even select a file as context and ask if it has any issues. Then, Cursor will analyze the file and suggest solutions if it finds any problems.

Let’s finally move to the Agent feature! As mentioned in the previous section, you can think of Agent as the older brother of Composer. That means everything we covered in the Composer section applies to Agent too. And since it’s like a boosted version of Composer, I highly recommend using Agent mode from now on instead of Composer. Now since we’ve cleared things up, let’s figure out what Agent brings to the table and why it’s so good.

Agent is the latest thing to come out of Cursor AI. As mentioned previously, it was introduced in version 0.46. And it’s not just suggesting code or filling in a few lines—it’s a teammate that can read your code, write new stuff, search through your entire codebase, and even write and run terminal commands, all on its own. You can hand it a task, like “add a login page to my app,” and it’ll dive in, scan your project, figure out where changes need to happen, and make them without you hovering over it. It’ll check its own work, tweak things if something’s off, and keep going until the job’s done—fully autonomously. It’s a big step up from being just a handy tool for creating or editing code; it’s like having someone working alongside you. Agent can even install packages or fix bugs it spots along the way, so you don’t have to sweat over the small stuff.

While Composer would hand you the code and wait for your nod, Agent keeps moving—it can decide what’s next, fix its own mistakes, and handle bigger tasks. Think of Composer as the assistant who drafts your plans, while Agent’s the teammate who builds the whole thing start to finish.

The catch? It’s a bit slower than Composer since it’s thinking harder and doing more, and it might stumble if your instructions are fuzzy. Composer’s still the quick, simple option, but Agent’s the one you call when you want to offload serious work.

And let’s not forget that Claude recently released a new model—3.7—which is a great one to use in your Cursor. This model enhances the AI's reasoning abilities and allows it to process larger amounts of information simultaneously. For developers working with extensive codebases, this means Agent can comprehend and manipulate large sections of code in one go, making it particularly effective for heavy projects.

Besides being more autonomous, the way you use Agent isn’t that different from Composer. That’s why, instead of repeating everything we already covered in the Composer section, let’s focus on some useful settings which might get handy when you're working with Agent, Composer or Chat.

To open Agent related setting, open “Settings”, click on the “Features” tab and scroll down to the “Chat” section. Keep in mind that those settings are commonly shared between Agent, Composer and Chat modes.

Auto-apply to files outside context in edit mode

 options. Their descriptions are pretty clear. They let your files auto-scroll as code is generated and automatically pull in files to the context when needed. I highly recommend leaving both enabled.

. This mode allows Agent to run all code or terminal commands autonomously, without your approval. When you ask Agent to generate a large codebase at once, it might occasionally ask for your manual approval as a safety measure. This way, Cursor ensures that it doesn't accidentally run any malicious script or code that could harm you. It decides on its own when it needs your approval if it isn't sure about something. Honestly, this is pretty advanced stuff that most people won’t need to worry about 99% of the time. So, you can just leave it turned off.

Next, let's cover another batch of settings.

 is a really useful one to turn on, especially if you’re working with big codebases.

Collapse input box pills in pane or editor

 is more of a user experience thing. It’s not something you need to stress about, so you can leave it off.

 option lets the AI detect linting errors and fix them whenever possible. For example, if you have a TypeScript error, it will try to fix it automatically. I’d recommend keeping this one on.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Free Tools

Next-Level Cursor: Cmd+K, Composer, and Agent Unpacked

Tags

Level

Responses (1)

Free AI Career Tools

AI Job Listings

ATS Resume Checker

Startup Perks

Masterclasses

Tutorials

Fullstack React with TypeScript