prelude

All things considered, I was late to the party when it came to using AI tools for development. I was mostly using LLMs through the browser up until a few months ago when I started using GitHub Copilot. It could handle the boilerplate of frontend pretty well, at least as long as I was writing code in JavaScript and not PureScript.

Around that time, I also began working again on the PureScript Analyzer, an alternative frontend for the PureScript programming language that uses modern compiler architectures with a focus on a good IDE experience.

Where Copilot came in handy for this project was the handwritten, recursive-descent parser, which exhibits repetitive patterns for things like repetition and recovery. The parser has very little abstractions and exists in one big file so I can imagine that it helps filling the context with enough information.

Last month, I decided to switch to Neovim to get a snappier, distraction-free editing experience. Obviously, it comes with the initial distraction of some Lua to configure Neovim, but I digress. After setting up completions, the LSP integration, and Tree-sitter syntax highlighting, I felt comfortable enough to start writing Rust code in it.

I also had the option to set up avante.nvim but I never got around to doing it. To some degree, I just also wasn’t interested with the Copilot experience anymore.

silence

One of the first things that I felt writing Rust code with my fresh configuration was that of silence. At times, Copilot felt more like someone backseating what I should do and it was pretty annoying when it gets code egregiously wrong.

Following this silence was the strong feeling to be more deliberate about the code that I write and how I go about writing it. I found myself in bursts of flow state more often when working, and the feeling that I got after was nothing short of euphoric.

To be deliberate about how code is written is to be more thoughtful of how to solve a problem. To be deliberate makes programming a tactile feedback loop of writing code and thinking about how it interacts with the problem.

I realised that Copilot was hindering my ability to engage in being deliberate by overriding one of the crucial processes that drive it, the act of writing code itself.

I suppose this is very similar to the idea of writing as a tool for active thinking. If an external tool does the writing for you then it defeats the entire purpose.

conclusion

I started my journey at the cusp of the LLM takeover of everything, and I feel quite proud about the way I learned to learn back then. I know that I could do just fine without LLMs backseating the code that I write or the problems that I’m solving.

With all that said, this decision allowed me to rediscover my love for learning and solving hard problems through the act of writing code. I owe it to myself to never allow a machine to take that passion away.

LLMs being good is an inevitability, and that naturally means having to keep up. Though I’m hopeful that it’ll take a while before compiler developers get replaced :P