Wasn't Claude supposed to do all the coding by now? Did we have a change of mind or did we run out of tokens?
1) By the time I’ve determined, and expressed to my satisfaction, exactly what I want, I’ve already done the hard work of coding that thing. The rest is fairly mechanical by comparison.
2) It’s a universal truth (which I know someone’s gonna argue with :D ) that reading and working with other peoples’ code is much less fun than reading and working with your own. This applies even if the other people are robots.
3) When checking and troubleshooting code, the bulk of the time is spent understanding it in the first place. If you wrote the code yourself this already implicitly happened and is ‘free’.
Put those four[1] things together and at least for me personally, AI-assisted coding isn’t a better experience than just doing it myself. It’s still great for bootstrapping yourself into a new unfamiliar language/environment though.
[1] Yeah it’s an off-by-one joke. ;)
The distinction I see now is between teams that read PRs and teams that don't. I still think the former is a good approach... for now, but I don't expect this will necessarily be the case in a year (or less).
This article was such an inspiration to me when I was younger, and the advice, for that time, was very correct. However seeing it today really drives home how big the gap is going to be in really understanding code in just a few more years.
I hear this from time to time. But I still write code at my job. I'm not a software engineer and I don't work for a software engineering firm.
> A lot of the time, I'm writing code that no LLM has seen before
I hear this tired point over and over from people who cannot fathom that others who use LLMs successfully could possibly also be working in a specialized domain. Frontier models are excelling at difficult, long-horizon tasks now. I write all sorts of esoteric stuff, and I can confidently hand a frontier model specification for a language it's never even seen before, working in a domain it's never encountered, and likely get good results, provided I have the knowledge and experience to guide the model.
The reality is that this "they are only good at things they have 'seen before'" talking point that often gets parroted is vaguely defined and largely based in opinion. Obviously, models perform worse when the input or expected output are out of distribution.
But this was much more true a couple years ago than it is today; the gap has closed considerably, and those who are learning to think deeply with these tools will be better positioned than those who arrogantly think that their process cannot be augmented by the most intelligent systems ever created.
Reading the code does not give you the knowledge of the 10 different approaches you would have tried and failed before coming up with that code. Why exactly a piece of code is the way that it is cannot be determined by just reading the code.
Reading a mathematical proof does not give you any meaningful understanding of it.
If you are experienced, attentive, curious, willing to explore, etc., that doesn't change after an LLM allows you to deeply discuss any concept at will, quickly try different prototypes and zone in on the correct implementation. You will use these tools to their full extent.
> Why exactly a piece of code is the way that it is cannot be determined by just reading the code.
If you maintained a good commit history and your code is self-documenting and you're not capable of understanding and navigating code you read, you can still literally just ask the LLM to explain the code within the context of the codebase. They are extremely good at that exact task. They will give you as much as you give them. If you want to know, and can understand, the nitty gritty, you can do that and no one is stopping you.
> Reading a mathematical proof does not give you any meaningful understanding of it.
Again: these things can function as personal tutors. Run the proof through an LLM and ask it what you care about. Furthermore, there are plenty of elegant proofs you can read which confer "meaningful" understanding.
Before just assuming that everyone telling you these tools are useful is less capable or experienced than you, it's worth considering if it's actually you who needs to maintain an open mind and attempt to learn from others.
Saying this kind of stuff kinda proves that you don't really know what you are doing.
Do you want to actually critically and healthily engage with my response instead of sliding into argumentative fallacy?
The original sin of the programming industry is not valuing expressive notation and expressive programming languages. (I am not talking about map/filter/reduce level party tricks but better metaprogramming and coherent abstractions). No amount of sacrificing tokens for Anthropicus is going to give you the same amount of understanding as writing the program.
Anthropic intentionally missed the opportunity to show that its models can develop really good native applications.
OpenAI’s latest desktop applications seem to be worse than before too.
There are HS interns at my company who admire me because I lived through a time without AI and I actually had to learn that stuff. I’m not kidding.
A linked-in post on CS enrollment at universities:
https://www.linkedin.com/posts/eric-pop_has-computer-science...
"In the past two years, the drop was ~20% at UC Berkeley and ~30% at UC Davis, while UC San Diego is the only one still rising."
On the other hand: LeetCode traffic rankings are up, so some people still solve programming problems by hand - or they hope to get a job, by being able to solve them.
https://www.semrush.com/website/leetcode.com/overview/
I think this is a confusing time. It will probably take a while, until things become clearer.