If You Care, Don't Guess
In a world where accessing information is easier then ever, we should try to take a moment to reflect on what we really mean to understand. It is important to take time to comprehend stuff we find important. If there is something you care about and would like to have a legitimate grasp of, you shouldn't guess. You should be able to explain it clearly.
This summer, I am doing my first internship. I have been lucky to be assigned real work and projects to work on. Most of the time, I am cleaning data and extending the current codebase by adding some functionalities. It is my first encounter with making things that are going to be pushed to production. This made me think about and appreciate the value of really knowing what you are doing.
When I used to do projects and assignments at university, there really was no incentive to understand all their parts. Most of the time, you would write some code, run it, see if it produces meaningful results, and proceed if it does. If the output didn't make sense, you would reiterate until it did. Not much thinking needed. Usually, this technique worked just fine, and after two or three attempts, you produced something similar to what you saw on the slides. Sometimes there were parts of the code you didn't fully understand. But you wouldn't care much as long as the output looked good. Just let it be for now, was a common saying among some of my friends. We rarely went back to understand those concepts.
The assignments weren't usually marked very strictly. There could be multiple reasons for it, including the fact that I am not studying computer science. The result was that you could slack and get alright grades. Because most students optimize to get a good grade, they don't think too much about actually learning. It is more demanding and rarely rewarded with an appropriate reflection in your grade. Grades are not the best proxy for comprehension. After all, you would often skip understanding, as that wasn't optimal for getting the best grades you could.
When I started working, those just let it be moments stopped occurring. Since I am working in risk management in an investment fund, it is really crucial that all things work accordingly to the procedures. There is no room for error. You can't skip over a certain part of the process only to finish some task earlier. That just doesn't slide. I often felt a sense of boredom when being asked to go over the same procedure I had already looked into multiple times. But that was just the way it had to be. It had to be checked at each step, and checked carefully.
What I am trying to say is that there was no longer room for sloppiness. Just letting it be wasn't an option anymore. I have to be able to vouch for the changes I am making now, and in a sense, I am liable for the mistakes I make. Being an intern, I do not feel the biggest load on my shoulders yet, but this experience gave me a sense of what it can be.
So I turned to some advice I heard about becoming a good programmer. Stop guessing. Understand. This time, I started to appreciate it. When I was writing or reviewing code, I tried to understand the fundamentals and how the program was really structured. Instead of copying and pasting code that printed out bugs, I tried understanding the error messages and referring to the documentation of commands. This was made easier thanks to MATLAB's extensive docs.
And it really helped. I believe this is the only way to progress in things such as programming. Nail the fundamentals. Don't skip over content, but grasp what you are doing. And while asking LLMs about your code is helpful at times, they tend to be too helpful and spoon-feed you stuff you would rather find out about yourself. The thing is, if you struggle more to get something, you will remember it better. That is how learning works.
Now, you see, easy access to information is a double-edged sword. We, cyborgs, with our smartphones always within arm's reach, can look up information any time. We can easily offload remembering stuff to the internet. We are able to retrieve facts flawlessly at will, with the use of a simple query. This makes our memory way bigger, as we can access information about almost anything. But there is a caveat to that. We stopped remembering and understanding a lot.
I am not an advocate of struggling for struggle's sake. I don't see a point in memorizing the whole cosine table for every degree. Sure, remembering the most useful ones can be useful, but not more than that. I don't want to cut corners when it comes to the important stuff. Sure, if you have to knock off some stuff from your to-do list, and you want to do it quickly, go ahead. If there is an easier way to get the same job done, why not? But be mindful not to waste an opportunity to learn something useful. It might turn out that knowing how to do that thing you decided to skip earlier will be useful in the future.
Derek from Veritasium gave a very insightful talk on the topic of learning in a world with access to artificial intelligence. In it, he talked about how we need to put some struggle into acquiring information if we mean to hold onto it. And there is no overcoming of this. You need to put yourself out there and test yourself honestly.
Sure, go ahead and use the newest LLM to ask questions about your code - or anything else - but watch out not to get an easy and obvious reply which won't make you learn anything.
Stay critical when it comes to inbound information. Try to understand things instead of remembering them. It is an investment that will pay off later on, when you try to actually recall those things. It will make you less prone to making avoidable errors and, in general, able to make higher-quality work. Producing quality results is really needed in the age of ever-present slop.
Next time you encounter a bug in your code, recall this article and refrain from pasting the error message into your AI assistant of choice before thinking. Ponder about it for a brief moment, and look up the appropriate commands in the documentation if necessary. Figure it out on your own. Trust me, the second time you face the same bug, it will be easier to manage if you ever make the same mistake.