Building software with AI in 2026 - diving into Cursor

Welcome to 2026! To start off the new year, I’m covering Cursor, the AI coding tool.

Over the past couple years, it’s pretty clear that AI-integrated coding assistants have become the norm in software development. Some of the more well-known ones are Claude Code, Cursor, Google’s Anti-Gravity, OpenAI’s Codex, Kilo Code, Open Code, etc. But the issue is, the features of these tools are rapidly changing, and there’s frequently a lack of up-to-date tutorials for how to use them to their full extent.

In this article, I’ll go over Cursor and explain the key features you should be aware of in 2026. I’ll also cover the optimizations and strategies Cursor uses under the hood to turn raw LLMs into viable coding assistants.

Overview

Cursor is an AI-powered code editor that lets you ask questions about your codebase, plan new features, debug, and make changes through natural language using large language models. The creators of Cursor originally tried to make their own editor from scratch, but settled on forking the widely used IDE VS Code.

This is why I initially chose Cursor. I already used VS Code and was familiar with its features and layout. Since Cursor is a fork, it has the same plugin and settings system, and there’s a hassle-free way to migrate them.

There are many other tools for AI coding — Claude Code, Google Anti-Gravity, and all the ones mentioned earlier. Some are plugins, some are IDEs, and some are command-line tools. I don’t think one tool is necessarily better than the other, but the two most popular ones in my experience are Cursor and Claude Code. I recommend trying a few and seeing what works best for your workflow.

Cursor is built on top of large language models, and using them isn’t cheap. They offer different plans that cap your usage of their AI coding tools. I’m on the Pro Plus plan, which gives extended usage on the latest models, but Hobby or Pro work fine if you’re okay with limited use of the code agent.

Layout and Settings

I’ll assume you’ve already installed Cursor and opened a coding project. The features and layout change frequently, so what you see might not match exactly what’s described here, but the principles still apply.

If you’ve used VS Code before, this should all be familiar: there’s a file explorer, a terminal, and the actual text editor. Here’s a brief overview of the layout and how to adjust it.

Clicking the gear icon reveals different ways to toggle the layout:

• Sidebar — This is how you can look at all the different folders and files in your codebase. You can click on folders and double-click on files to view them in the text editor.

• Panel — The panel is the terminal at the bottom of the screen. You can have multiple terminal sessions running here.

• Central Editor — This is the text editor where you can enter text and modify your codebase.

  
  

There are also two options that are AI-enabled features:

• Chat — Where you enter commands to the Cursor agent to modify your codebase, ask questions, and help debug.

• Agents — This shows past agent interactions you’ve had. You can click on previous sessions to review the exact conversations you had with the agents.

Clicking Cursor Settings shows your account info and general setup. The General tab has options to manage your account and upgrade your plan. There are layout settings, editor settings for font formatting, minimap, and keyboard shortcuts. There are also options for privacy and notifications.

Cursor Tab (Autocomplete)

Now for the important stuff: the AI capabilities of Cursor.

The Cursor Tab is an autocomplete feature. As you navigate your codebase and start typing, suggestions will pop up below. Cursor might suggest a comment or a block of code based on the context of the file you’re in. Pressing Tab accepts the suggestion, and pressing escape will cancel them.

After you accept a suggestion, it often has another suggestion right underneath because it’s inferring what you want to do based on your actions in the codebase. You can keep pressing Tab to accept sequential suggestions, or press Escape if you don’t want what it’s offering.

Where this gets really useful is that Cursor Tab is context-aware across your project. If you define a utility function in one file, then go to another file and start typing that function name, Cursor will suggest auto-importing and using the function you just wrote. It understands the relationships between your files and can suggest relevant code based on what exists elsewhere in your codebase.

One downside is Cursor Tab can get annoying when you’re navigating your codebase — pressing enter a couple times triggers suggestions even when you’re just exploring. I actually don’t use this feature often, for this reason. If this bothers you as well, go to Cursor Settings > Tab section, where there are sub-options like partial accepts and suggestions while commenting that you can turn off.

Chat Feature (Agent Mode)

The chat feature is what most people are familiar with and what offers the most transformative value for coding.

You enter instructions into the chat window, and the Cursor agent uses them to modify your codebase. An “agent” is just an LLM that understands your instructions, reasons about them in relation to your code, and makes decisions or modifications accordingly. Instructions can be anything — adding features, asking questions, making a plan, or debugging.

How It Works

To use Agent mode, type your instructions into the chat window and press enter. The agent starts working on your request, and you can see its chain of thought as it implements. For example, what it’s thinking about, what files it’s exploring, and what changes it’s making in real time.

As it works, you can see the individual file changes it’s making. Once it’s done, it summarizes all the changes it has made.

Reviewing Changes

After the agent finishes, you can review all the file changes to make sure they’re in line with what you wanted. There’s a tab that lets you navigate between the different files it edited. For each file, you can see exactly what was added, removed, or modified, line by line. If the changes look good, you can press “Keep File” to accept them, or you can accept each chunk of code it changed, line by line.

Iterative Changes

Cursor and other AI coding assistants are very iterative. If you accept changes and notice something you don’t like, add another command in the chat and it will follow up and apply the fix. If a button is the wrong color or a layout doesn’t look right, you can tell the agent what to change and it updates accordingly.

Undoing Changes

Not every change the agent makes will be something you want to keep. When reviewing changes, you’ll see options to “Undo File” or “Keep File,” as well as options for individual lines. If you don’t like a change, you can press “Undo File” and it will revert back to what you had before.

Providing Context with @ References

You can give better context to the agent using the @ key, which references specific files. Instead of saying “change the background of the navbar,” you can type @navbar.tsx directly in your prompt to tell the agent exactly which file you mean.

This is especially useful on large codebases where the agent might not know which file you’re referring to. The more specific you are, the better the results.

Model Selection

An important part of the chat feature is model selection. Clicking the model selector shows your current model and a list of options to switch to.

Cursor is essentially a wrapper around an LLM of your choosing. The LLM is the core engine that powers the changes, and Cursor is the interface built on top that calls the model under the hood. The available models are the same ones you’d find on each provider’s website — for example, Claude Opus 4.5 in Cursor is the same model you’d use on Claude’s website.

There’s also an “Auto” option where Cursor decides which model to use based on quality, speed, and what’s best suited for your task.

There are different opinions on these models — some say Gemini 3 is the best for UI, others say Opus 4.5 is the best all-around. Everyone has different experiences, so try them out and see which works best for you.

How Cursor Works Under the Hood

Context Management

When requests are sent to the underlying LLM, it’s not just sending your latest instruction — it also includes all the previous conversation. This provides more context for the model to work with. The context window includes all the questions you’ve asked the agent and all its output. Every new question gets sent along with this full history to the language model.

This makes context management important. Cursor’s context window is 200,000 tokens. In a long conversation where you’re requesting dozens of features, the model adds output from your terminal, file contents, and code snippets, and obviously this context can quickly exceed the limit. Even the content from a few files may be too much!

Even below the limit, more context means more unnecessary data for the model to process, leading to less accurate answers. It’s like a human conversation, where extracting relevant info from a long text is harder when there’s irrelevant data mixed in. Cursor also charges by the token, so managing context saves money too.

Managing Context

To keep context manageable, press the plus button to open a new chat. The new chat doesn’t share context with previous ones, so you get cheaper, faster, and more relevant responses.

This is also useful for running multiple agents on different tasks simultaneously. For example, one working on the web app and another on the mobile app.

Cursor’s Context Optimizations

Cursor also has its own tricks for managing context. It routinely summarizes your previous conversation so there isn’t too much information sent to the model at once. This summarization extends to files too, since referencing a large file in your instruction could exceed the context window on its own, so Cursor handles that for you.

This is what makes Cursor and similar tools more powerful than using an LLM directly. Cursor is a wrapper over these models that optimizes context about your codebase, producing more accurate output than if you dumped your entire codebase into an LLM.

Tool Calling

So what are these optimizations? One in particular is tool calling. Agents can do more than generate text, they have access to tools that let them retrieve data dynamically from your codebase.

The Cursor docs provide a good analogy. Imagine you’re helping someone cook dinner over the phone. You can give them instructions, but you can’t see their fridge or taste their food. Now imagine you can ask them to send photos of their fridge or tell you the temperature of their oven. You’re in a much better place to give instructions because you can ask questions to get the data you need for a more accurate response.

If we apply that to actually using agents, say you ask a simple question like “What tech stack is this project using?” The agent will plan its next moves, and then you’ll see it start reading files like your package.json or config files. Those are tool calls. The agent realizes it needs to know the content of certain files to answer your question, so it invokes the tool for reading files.

If you ask something like “What file contains the sign-in button?” you’ll see it start using grep to search through your codebase. Agents are intelligent enough to understand what tools they can use to find out more about your codebase. They can invoke these tool calls and use them to better extract information to give you an accurate answer.

A full list of tools is available on Cursor’s website, but many of the commonly used ones are read file, grep, delete file, and the terminal tools.

Agent Modes

Those are the essential features of the agent chat, but it’s only one of the modes available. Cursor’s agents can do more than just code, they can be integrated into your entire software development workflow.

There are four modes: Agent, Plan, Debug, and Ask. Each puts the agent into a different strategy for specific tasks.

Agent Mode

Agent mode is the general-purpose mode, primarily used for modifying code. It’s the one you will probably be interacting with the most while developing.

Ask Mode

Ask mode lets you ask questions about your codebase without it making any modifications. Ask mode only has access to search tools, deliberately limiting it so it can’t modify code.

Plan Mode

Plan mode creates detailed plans for accomplishing tasks. It’s ideal for larger features that are too big for a single Agent mode prompt, such as tasks requiring many changes across your database, backend, and front end.

Doing a complex feature in one prompt might produce something that works, but it won’t give you a scalable, clear solution you can rely on long-term. In addition, if you delegate too much to the AI, you might lose sight of how your codebase works, making it harder to improve later.

When you describe what you want, Plan mode reads through relevant files and asks clarifying questions to help you figure out what you want, and it helps the agent figure out how to build the feature. If your requirements are vague, it narrows down exactly what you need, forcing you to think through the details before any code gets written.

Once done, it produces a plan.md file, which is a spec with an overview, architecture, data flow, and planned backend and front-end changes. The plan is supposed to be iterative, so you can chime in with your own opinion and offer critiques, which the agent can use to further update the plan. These modes are for many different parts of software development, beyond just writing the code.

Debug Mode

Debug mode lets you post details about issues in your application, and the agent walks through the debugging process step by step. I haven’t used this much since Agent mode and Ask mode cover similar ground, but it’s worth knowing about.

Other Features

Browser

Cursor can render your application directly within its UI, allowing you to interact with your running app and reference specific elements more easily.

Buttons at the top let you select elements on the page. When you select an element, it shows up in the chat, so instead of describing which component you mean, you can click on it and write your instructions. You can also take screenshots and use the CSS inspector.

I haven’t used this feature much. As a developer familiar with the relationship between UI and code, it’s easier to describe changes directly. It could be more useful if you’re less familiar with front-end development.

Inline Editing

Beyond the chat, you can modify code by highlighting it directly. When you highlight code, you’ll see two options: add it to the chat or do a quick edit.

Quick Edit lets you give instructions directly on the highlighted code. It’s more convenient for small, targeted changes where you don’t need the full agent workflow.

Summary

Those are the core features of Cursor. There are other features too, such as the BugBot, CLI, parallel agents, and MCP, but they’re not necessary to get started. This article covers the important parts of Cursor in 2026 so you can use it effectively. The UI and features will likely change over time, but the core concepts here should still apply.

One last thing — how do you decide between Cursor and other solutions like Claude Code or Anti-Gravity?

A lot of it comes down to how deeply you want to incorporate agents into your workflow. Cursor is a much larger tool that is meant to be all in one - including a file explorer, terminal, text editor, all familiar, with agentic features layered on top. This differs from Claude Code, which is barebones, and just a terminal tool with agent access.

So, that’s a brief overview of Cursor, how it works, and its key features. Happy coding in 2026.