- Reimagine anything
- Planning with AI
- Learning with AI
- Be in control
- Git is your friend
- Language matters
- The way you think changes with LLMs
- Cursor Rules
2024 and early 2025 were one hell of a wild ride. Lots of AI tools emerged from
different companies. It’s not all that new, some were being developed for quite
some time. And as a matter of fact, they are becoming more and more usable day by
day. Recently, Anthropic released their latest model claude-4-sonnet, which is
great for coding as it writes fewer comments and can manage smaller tasks quite
well. I’ve been using Cursor (aka the AI editor) for quite some time. There are
also other alternatives. But as of writing this today, Cursor works best for me.
I got my subscription because I kinda liked the tab model. If you’ve been exposed to
any of the AI editors, you already know it can understand the pattern. If you
change something in one line, it can understand and then can apply the
same change for the next couple of lines, which is quite good and quite enjoyable
too. No need to learn vim macro for that. Sorry vim users (myself included, I
use vim mode all the time). Though in most cases with its tab model, it goes way
beyond that simple change.
For the first few days, I haven’t used any single thing in AGENT mode (that is
basically some kind of privileged option to edit files and modify the file
system). So I slowly started using agent mode and Oh boy! It can do a lot of
things, saving a ton of time. It basically lets you iterate fast! Very fast! Soon
I have a branch named vibe in all the projects I use cursor with. It can
write brand new code quite well, it can apply changes, it can help with
debugging a lot of things. I’m not talking about breakpoint debugging, rather
debugging system problems in general. One time I had a problem with MacOS
certificate installation, with commandline, Keychain Access GUI, and golang.
Cursor wrote multiple scripts, ran multiple commands to verify, and eventually
it accepted that it’s very weird. I don’t let cursor go wild and run any command
it likes, rather every time it tries to run any command, I must allow that. That
way I can see what it’s trying to run.
Reimagine anything
If you’re not a graphics designer or you’re a backend developer with little to
no design knowledge, you might’ve faced this. Whenever you try to
implement a basic UI, it looks ugly. It happens to me all the time. That’s why
when working with react, we use component libraries. (ShadCN changed the game
quite a bit. Though it’s outside the scope of this topic). With AI, you can
create beautiful UI, in a matter of seconds or minutes. I’ve designed and got
idea from v0 for my few personal projects. Most of the time it worked pretty
well for me as an initial iteration. Which then I can fine tune later. AI may
not make the best UI for your application, but it’ll definitely generate
something for you to get going. I experienced some theme changes with AI. I
didn’t like the colors, so I asked it to reimagine the colors, use its
creativity (or hallucinate, depends on how you look at it). Colors turned out
great for that specific use case.
Planning with AI
When you’re brainstorming and you’re looking for some ideas, you can create a README file and ask AI to populate the specific details. It’ll spit out some ideas about the project, particular features, gotchas, etc. Now you have a playbook to fine tune. You can go through the docs and you might get some insights to that. But if you’re well versed in that subject, you may not like the idea and you should rather go with your own.
Learning with AI
You can learn a lot of things from AI. You can tell it to implement certain things, and you can now visit those docs and go through the code. You need to understand why it wrote that thing. And while you’re verifying those things, you can learn about operating system APIs, patterns, specific ways of doing things that you may not be aware of.
Be in control
As of today, the big bump you’ll hit is the context size. Try to keep chat size very small. For unrelated things, create new chat. It can create messy situations quite easily if you’re not careful enough. Once I tried to replace the theming system in a react application, oh boy! It deleted a lot of code and totally messed things up. Because it went through all the project files and eventually created a messy situation. But when I instructed it for smaller changes, it worked quite well out of the box.
Git is your friend
Previously, I said I use the vibe branch a lot. Why? When working with LLMs in
your codebase, you want to keep track of your changes. If you think some changes
are good. Just commit it. If you’re not careful enough, it’ll mess up with good
code as well. And if there are lots and lots of changes and if you’re not
managing them with git, you’re cooked. So always commit, revert, reset. Git
integration with VS Code based code editors is very good for most tasks. You
can stage hunks, restore hunks, or reset the whole file. Which will save a ton of
time. Learn git basics and apply them effectively. Not just when you’re using
LLMs. In general, you should learn and be proficient in git.
Language matters
All these things will only work if you choose a domain which LLMs can help you
with. If you’re using React, ReactNative, TypeScript, or Golang, it’ll help you
very well to write code and implement features. Not so when it comes to obscure
things like windows driver development. I once tried windows callout driver
development, and LLMs hallucinated lots of Operating System APIs that don’t
exist on windows. That was pre sonnet-4 era. Maybe it has changed, who knows!
Sonnet-4 mostly gives working code, which is quite good, but if it starts
messing things up, you better stop it right there.
The way you think changes with LLMs
When working with LLMs, you also need to think about a lot of constraints. You need to know the limitations of the LLM. You need to explain your requirements such a way that LLM can make sense of it. You can’t just be vague and assume the LLM will understand what you’re talking about. Maybe some human will understand given that previous context. But with LLMs, you need to think about the context, what it knows, what context you should give it. Effective usage requires you to go through some trial and errors. But if you get the idea, you’ll only get better using LLMs.
Cursor Rules
When working on a project, you might set some base rules to attach to every
message. For example, if you’re using cursor with a ReactNative project and you
don’t specify this, the LLM might get you wrong and implement something which only
makes sense in the context of web. For example, usage of html tags,
localStorage, etc. But if you set the rule to let the LLM know this project is a
ReactNative project, it won’t do that mistake. Same thing goes for a package
manager. It may try to run npm for most tasks, but if you’re using bun for
your project, you better set a rule for that. That way it’s much more effective
and you don’t have to fight with it for that.
It’s been pretty fun experimenting with all of these. I’m just enjoying my last few days as a developer, because AI will eventually replace me and all the developers. Then we all will start farming… See you there…