Maximilian: So like GitHub Copilot,
Cursor provides smart, AI-driven suggestions.
Now, also like GitHub Copilot,
Cursor does not just do that for the line
you are currently working on,
but also for other lines in your code base.
It makes predictions regarding the next edit
you'll likely wanna make.
GitHub Copilot also has this feature now,
but they didn't always have it,
they basically copied it from Cursor,
and Cursor pioneered this feature.
And, of course, you'll have to simply try and find out
which editor works better for you,
so if you like the predictions
by GitHub Copilot more than Cursor's
or the other way around.
Now, for the Cursor team,
ultimately, their vision is,
they said that in a podcast,
that you can work on a code base
by just hitting tab, tab, tab all the time.
So that they predict the next edits very, very well,
and you therefore can move through a code file quickly
and make all those edits based on those smart predictions.
For example, if I change content here to text, let's say,
it's there after, it's a bit subtle to see,
but it there after highlights content down here.
It has a red background.
And on the right, it opens a little popup
where it shows me what it wants to change.
It wants to change the argument
that's passed to the write method to text.
So from content to text, it wants to make this change.
So if I hit Tab now
after changing this parameter name here to text,
if I hit Tab now, even though my cursor is here,
you see this here changed to text,
and now it jumps down here to the bottom,
highlights this in red,
and suggests that it wants to rename this here
to text as well.
So if I hit Tab a couple of times, it goes down there.
Next it highlights this
because it understands that this parameter here
needs to be renamed to be in line with this name.
So all I'm doing here is I'm hitting Tab all the time
to accept all these changes until at some point it's done.
And that's an important difference
compared to GitHub Copilot.
It can be confusing at first,
but once you get used to it,
this is really something that can get you into a nice flow
where you can make changes across your entire code file
rapidly by just hitting Tab.
Of course, you should also take a brief look
at least what's about to change,
but then you can just hit Tab to accept all these changes.
So Cursor really tries to take this code completion feature
to the next level and complete
and change parts of your code you
are not even working on right now.
But as you see, it always shows you
what it's about to change
and you confirm it with the Tab key.
So it's not automatic, but it's smart.
And that's a really neat feature that's built into Cursor.