LLMs evolve so fast. I feel it’s worth recording my current thoughts on how this technology changes my day to day experience in writing code.
Reflection on Timeline
I have been a vim user since 2006. Early on, it was local completion and then tags based completion. Building the tag database was a huge pain but you did get some great completion out of it. The LLVM/clang based completion was a huge leap forward. The legendary YouCompleteMe was a time saver, although it took the community a while to accept and adapt to it.
Then the LLM came. I didn’t get into Cursor very early because it’s hard to move away from vim. My option is heavily biased when it comes to any GUI based editor. I just feel like it would be slow and won’t fit into my ssh-into-remote-server-and-code workflow.
I stayed with vim but started to use Codium. It’s much better than any prior completion tools. Because it is LLM based, I got long and complex completion. It is also surprisingly fast as a vim/neovim plugin.
I was happy with Codium until early this year I tried the Cursor like workflow inside vim. After playing with the “Vim Cursor” for some time, I decided to really try Cursor.
I have to say I was totally convinced and now I spend more than 80% of my coding time within this GUI based editor and only use vim for some quick edits.
What shines
Type much less
One obvious change for me is that I type much less. When you were in vim (or Emacs, unfortunately), you are constantly hitting keys. The editor provides tons of tools and shortcuts to help you. Together with the muscle memory, sometimes you feel like you can move as fast as you want, which is a great feeling when you are in the zone.
However, within Cursor (or any other AI-powered editor I assume), the model can be faster than you. It is very good at getting the intent right and write the next piece of code for you. You make a little change here and it will propose (correctly) the other updates.
I’m not sure if I did more typing in the chat box than writing code in the editor. I guess human are lazy by default. “Easier said than done” suddenly feels very real.
Trace inside the codebase
This is one of my favorite things about Cursor. It is good at gathering information and put them together for you. I can ask it to trace the usage of something and put together the code snippets that I can easily understand the workflow without jumping around the codebase.
Something more specific for research projects, because usually you have an understanding of the changes from the paper, you can ask it to localize the change you want to understand in detail. Very likely the codebase is large because it may be built on top of some other projects and the coding practices can be very inconsistent even messy. This is very handy.
Another bonus point when working on image or video related models is that it can infer the size of tensors along the way. It makes it much easier to debug and understand the code.
Prepare the boilerplate
When you start something new, we use to search for “github template …” and then copy the code to our project. Now we just ask for it. Moreover, the template is highly customized for my usecase. The tricky part is to limit the scope to make sure it is not too lengthy or complicated if you want to fully understand the code by yourself.
Write frontend code
I barely know how to do frontend development. I can read and modify HTML/CSS/JS but that’s about it. I kind of understand the vibe coding idea when refactoring my webpages with Cursor. I am not going to read the code it produces as long as it looks good in the browser. To me, it feels like static website building is much easier now. The security concern is minimized as it has no backend and AI definitely knows compatibility and responsiveness better than me.
Complete one-off tasks
I use to have a lot of scripts under my repository, to reformat some file, to extract some information from data, to generate some mock data, etc. You kind of want to keep them because it feels like you may need them later. However, it is usually the case that next time you need them, you have to understand it again or you may just forget about it.
Now you just ask for the result instead of how to do it. For example, you want to extract some columns from a CSV file and filter out some rows. You just ask AI to get you the output csv file instead of coding up a script. This is actually a new perspective to me. In the beginning, I was still use to ask for the script and run it by myself. But now for simple tasks I would quickly look at the script and approve the running.
One surprisingly good use case is to extract data from webpage. Combing with the background agent mode, it really feels like you are working with a maybe junior developer for web crawling.
Not there yet
Understand when to stop
This is probably the most frustrating thing for me. Although most of the time it made the change I want, it also added, sometimes a lot, unnecessary changes. You ask for a update to something, it may go ahead to refactor the whole codebase. Early days, it will add a Readme file for whatever script it wrote, which is kind of annoying.
The problem may allieviate with stronger model. For now, I would just explicitly ask for a stop. Sometimes it may sound hash 🙂
Maintain good quality of code
Sometimes, it just does not work well. It produces something compiled but not runnable. Sometimes, it wrote a function/class that is so long the compiler cannot handle it. I am sure it will get better but at this moment, if the code is something you want to maintain later, you would want to double check it.
Value of carbon-based life
Current models still need a lot of attention (pun intended!) to work with. We provide context to guide them and set limit to avoid mistakes. Many times, we need to chime in to guide them out of the loop of buggy fixes. Beyond coding, in our day to day job, our value in human-to-human alignment matters much more than the speed of writing code.
The idea that AI will free us from tedious jobs may not be welcomed or agreed upon by everyone. But just like how compilers translate programming languages into machine code, these LLMs are now translating human language into programs.
The community is being discussing about this a lot. It is hard to not feel a bit worried given the speed of the evolution of AI models. My feelings are mixed as well. On one hand, I feel like I enjoyed the AI-assisted coding experience a lot and it greatly expanded what I can build. On the other hand, I feel a bit nostalgic or even a little sad about not being able to go back to coding in the old way.
Until next wave, enjoy coding!