Tell HN: AI tools are making me lose interest in CS fundamentals With powerful AI coding assistants, I sometimes feel less motivated to study deep computer science topics like distributed systems and algorithms. AI can generate solutions quickly, which makes the effort of learning the fundamentals feel less urgent. For those who have been in the industry longer, why do you think it’s still important to stay strong in CS fundamentals? |
Knowledge is still power, even in the AI age. Arguably even moreso now than ever. Even if the AI can build impressive stuff it's your job to understand the stuff it builds. Also, it's your job to know what to ask the AI to build
So yes. Don't stop learning for yourself just because AI is around
Be selective with what you learn, be deliberate in your choices, but you can never really go wrong with building strong fundamentals
Edit: What I can tell you almost for certain is that offloading all of your knowledge and thinking to LLMs is not going to work out very well in your favor
The LLM did all the coding, but came up with none of this by default. None of the optimizations I envisioned emerged up when I prompted “how could we make this faster?” If I hadn’t been an expert in my field the output wouldn’t have been useful.
Keep studying!
Instead do the opposite and give it a really hard problem that's scarce on searchable resources, something that you'll struggle to implement on your own. In general what you'll find is that it seems to implement something, but once you start digging you're just going to discover holes and mistakes all over.
You're the one who should be producing strong groundbreaking work, not the AI.
Think of how it was before AI. Someone without foundational knowledge of a topic would flounder. They wouldn’t know what to search for or what questions to ask. Meanwhile, someone with that foundational knowledge is able to put together abstract ideas to ask the proper questions and know how to search for to get additional details.
When you don’t know what you don’t know, it’s almost impossible to be effective, even with AI.
I'd also second bluefirebrand's point that "it's your job to know what to ask the AI to build" - https://news.ycombinator.com/item?id=47394349
Those are great answers to the question you did ask, but I'd also like to answer a question you didn't ask: whether AI can improve your learning, rather than diminish it, and the answer is absolutely a resounding yes. You have a world-class expert that you can ask to explain a difficult concept to you in a million different ways with a million different diagrams; you have a tool that will draft a syllabus for you; you have a partner you can have a conversation with to probe the depth of your understanding on a topic you think you know, help you find the edges of your own knowledge, can tell you what lies beyond those edges, can tell you what books to go check out at your library to study those advanced topics, and so much more.
AI might feel like it makes learning irrelevant, but I'd argue it actually makes learning more engaging, more effective, more impactful, more detailed, more personalized, and more in-depth than anyone's ever had access to in human history.
Knowing the right tool for the job is even more powerful now because it will prevent you from going down a rabbit hole the LLM thinks is just fine.
We care way less now about leetcode-like interviews (we used to have them before, but not anymore)
How can you be a good judge? You must have very strong foundations and fundamental understanding.
Either way, if you want to talk with an LLM on the same level, you're going to need to train on the same dataset.
Less urgent, sure. But I would argue it makes learning the fundamentals more necessary than ever. I am a firm believer in there being no such thing as a waste of knowledge. You never know when you might need something.
I studied Physics fundamentals even though I had a microwave or could buy an airplane ticket. And I deeply enjoyed it. I still do.
I will keep doing it with CS fundamentals. Simply because I enjoy it too much.
For now? I'm a CS grad. My son wants to be a CS grad. I'd like to believe what you wrote, and hope it is true. But at the current rate of LLM improvement, would this really be the case in 4yrs? Asking seriously as my son needs to choose a major in 4yrs.
I don't think anyone at any level has any idea what the future is holding with this rapid pace of change. What some old timers think is going to be useful in a post-Claude world isn't really meaningful.
I think if I had limited time to prioritize learnings at the moment it would be prioritizing AI tooling comfort (e.g. getting comfortable doing 5 things shallowly in parallel) versus going super deep in understanding.
Because otherwise you are training to become a button pressing cocaine monkey?
If the best argument for going into CS is that LLMs sometimes make stuff up and will need human error checkers, I can see why people are less excited about that future. The cocaine monkey option might sound more fun.
Software abstractions have always made it easier to build software without having to understand the inner workings of the mechanism that has been abstracted. But that doesn't mean we don't have to understand how it works.
I saw this happen frequently with cloud infrastructure. Cloud services remove the physical and organizational barriers associated with building and scaling infrastructure. But you still have to understand networking to manage your network infrastructure in the cloud. When it doesn't work, you can talk to AWS Support, but they are there to support AWS services, not design your network for you.
The Java Streams API makes it easy to write fluent code. But the Streams API doesn't make that code efficient for you. You still have to think about the cost of each step in the fluent chain, and the optimal order. Does it make sense to sort and then filter, or filter and then sort? Think about it.
I was working on a Chrome Extension with Claude. The extension kept getting rate limited immediately on one site. Claude suggested a few approaches, but nothing was working. Then I realized, wait, "are we sending two requests for the content when we could be sending one?" "Yes, let me fix that." Dude.
Commercial airline manufacturers have been working on automating every step of the process for decades. But pilots still have to know how to fly the plane, and troubleshoot when things go awry.
We still have to understand O(n) notation and how it applies. We still have to understand distributed systems.
We still have to know how to fly the plane.
Just last night I was struggling browsing / organising media on my NAS, because macOS Samba + NFS suck: "What if I build a bespoke web application I can run on the NAS to do this"
One episode of SNL and two episodes of Graham Norton Show later I had a Dockerized Vite + Go application where I can mount media directories to and browse pictures + videos with previews. It's not 100% done, but close enough for me to see if it's something I need to spend time working on
...but I can also learn stuff - by asking the LLM to teach me.
While that one was building, I stole an idea I saw on the internet and started building an agent harness that uses Qwen3.5:9b as a backend to run tools locally. I specifically asked Claude to build it in parts and explain to me how it works step by step.
Now I know a lot more about that than I did yesterday.
1. Summarize a page with gemini 2. Then go through it myself to see if I understand the entire page
Which can help a bit with getting up to speed.
What I'm demotivated by is all these new HN posts that are blatantly using LLMs to write, and then hiding the fact they are. Just be honest... There's nothing wrong with making a mistake, you learn from those.
I get that there's a rule against it now, but it will only filter out low-hanging fruit. I still see too many, and I don't think people will ever change in this sense.
80% of my comments lately have been about spotting these posts/comments and I feel like its not doing anything except getting me mad.
CS fundamentals? In this day and age it’s only important to keep up with them if you are one of the relatively few people (even in BigTech and adjacent) who are building the fundamentals or trying to get a job in one where “grinding leetCode” is important.
Before the pearl clutching starts I had to implement many of the algorithms as part of my $DayJob early in my career as a C bit twiddler across various platforms. But haven’t since 2012-2014.
We have seen so many massive changes to software engineering in the last 30 years that it is hard to argue the clear utility of any specific topic or tool. When I first started it really mattered that you understood bubble sort vs quicksort because you probably had to code it. Now very few people think twice about how sort happens in python or how hashing mechanism are implemented. It does, on occasion, help to know that but not like it used to.
So that brings it back to what I think is a fundamental question: If CS topics are less interesting now, are you shifting that curiosity to something else? If so then I wouldn't worry too much. If not then that is something to be concerned about. So you don't care about red black trees anymore but you are getting into auto-generating Zork like games with an LLM in your free time. You are probably on a good path if that is the case. If not, then find a new curiosity outlet and don't beat yourself up about not studying the limits of a single stack automata.
Do you feel yourself losing interest, curiosity, "spark"? If so, then maybe worrying is right.
If you're just (hyper?)focused on something else, then, congrats! Our amazing new tools are letting us focus on even more things -- I, for one, am loving it.
See also Profession by Isaac Asimov for a fictional story about the distinction between the desire to learn and the utility of learning: https://www.inf.ufpr.br/renato/profession.html
The day you need it, you'll be more motivated to learn it. That's pretty much how I learnt most things.
If you haven't learned the fundamentals, you are not in a position to judge whether AI is correct or not. And this isn't limited to AI; you also can't judge whether a human colleague writing code manually has written the right code.
It cannot really create anything new and never seen, which most people will never do either.
So if we push away even more onto AI, I am afraid MANY(not all) that would previously gone through the discovery path won't stumble onto their next innovation, since they simply prompted a good baseline for ABC task, because we are lazy.
If anything I consider fundamentals in STEM (such as Math/CS) to be even more valuable moving forward.
If not, how can it not hallucinate when you didn't give it any constraints?
Does it work? How does it work? If you can't answer those questions, you should think carefully about what value you bring.
We're in this greenfield period where everybody's pet ideas can be brought to life. In other words...
Now anyone can make something nobody gives a shit about.
As a corollary, I can build shit that's perfect for me and I don't really care if it's any good for anyone else =)
Before I had to find someone else's shit and deal with their shit, trying to make it do the shit I need it to do and nothing else.
lol nice one
https://bun.com/blog/behind-the-scenes-of-bun-install
Then look at how Anthropic basically Acquihired the entire Bun team. If the CS fundamentals didn't matter, why would they?
Even Anthropic needs people that understand CS fundamentals, even though pretty much their entire team now writes code using AI.
And since then, Jared Sumner has been relentlessly shaving performance bottlenecks from claude code. I have watched startup times come way down in the past couple months.
Sumner might be using CC all day too. But an understanding of those fundamentals (more a way of thinking rather than specific algorithms) still matter.
I agree. The nature of the machine, is to crush the artisanry and joy from the task. However, you can't beat it, so…
I use the miserable things as "research accelerators." I have neither the time, nor the capacity to sustain the BAC necessary, to parse all of the sources and documentation of the various systems in which I'm liable to take interest. I very rarely ask them to "do ${task} for me," but rather: "What is the modern approach to ${task}? And, how do I avoid that and do ${task} in the spirit of Unix?” "Has anyone already done ${task} well?" "Are there any examples of people attempting ${task} and failing spectacularly?"
If you treat it like your boss, it'll act like your boss. If you treat it like your assistant, it'll act like your assistant.
Edit: derp.
Just saying "use red/green TDD" is a shortcut to a very specific way of fixing bugs.
Or when you use a multi-modal model to transcribe video saying "timecode" instead of "timestamp" will improve the results (AV production people say timecode, programmers say timestamp, it hits different parts of the training material)
Either the AI doesn’t understand them, and you need to walk it down the correct path, or it does understand them, and you have to be able to have an intelligent conversation with it.
AI tools still don't care about the former most of the time (e.g. maybe we shouldn't do a loop inside of loop every time we need to find a matching record, maybe we should just build a hashmap once).
And I don't care if they care about the latter.
I see over and over those with the deeper understanding are able to drive the AI/LLM code generation processes faster and more effectively, and build things that can be built on by others without hitting hard bottlenecks.
The less people understand CS fundamentals the faster they his a blockade of complexity. This is not necessarily bad code, but sloppy thinking. And CS fundamentals are information and logical processing fundamentals.
It is the Centaur issue. You need to help provide the evaluation and framing for the AI/LLM to search out the possibilities and well known solutions, and code up the prototypes. Without the fundamentals you have to rediscover them slowly after you already hit the hard problems and pause for days or months while trying to work you way around them.
Simon wrote an article "What is agentic engineering?" [1]
> Now that we have software that can write working code, what is there left for us humans to do? > The answer is so much stuff. > Writing code has never been the sole activity of a software engineer. The craft has always been figuring out what code to write. Any given software problem has dozens of potential solutions, each with their own tradeoffs. Our job is to navigate those options and find the ones that are the best fit for our unique set of circumstances and requirements
Such navigations may require various skills. For example: people/product skills (e.g customer empathy) to determine what to build, or engineering skills (e.g optimizations). Please be open for learning and get stronger via feedbacks.
[1]. https://simonwillison.net/guides/agentic-engineering-pattern...
AI still needs some lucky wizards with CS skills that will keep it going, at least until Skynet gets turned on.
It's not a failing of yours or anyone else's, but the idea that people will remain intellectually disciplined when they can use a shortcut machine is just not going to work.
I'd say my ability to write code has stayed about the same, but my understanding of what's going on in the background has increased significantly.
Before someone comes in here and says "you are only getting what the LLM is interpreting from prior written documentation", sure, yeah, I understand that. But these things are writing code in production environments now are they not?
In the AI era, is it still worth spending significant time reading deep CS books like Designing Data-Intensive Applications by Martin Kleppmann?
Part of my hesitation is that AI tools can generate implementations for many distributed system patterns now. At the same time, I suspect that without understanding the underlying ideas (replication, consistency, partitioning, event logs, etc.), it’s hard to judge whether the AI-generated solution is actually correct.
For those who’ve read DDIA or similar books, did the knowledge meaningfully change how you design systems in practice?
Longer answer: About 10 years I moved into leadership roles (VP Eng) and while I continued to write code for POCs, it hasn't been my primary role for quite some time. DDIA has been a book I pull out often when guiding leaders and members of my teams when it comes to building distributed systems. I'm writing more code these days because I can, and I still reference DDIA and have the second edition preordered.
A recent example for me: I had a challenging problem in a medium sized codebase (tens of thousands of lines) that boiled down to performing some updates to a complex data structure where the updates needed to be constrained by some properties of the overall structure to maintain invariants. Maintaining the invariants while the data structure was being updated is tricky since naive approaches would required repeated traversals of the whole structure. That would be really inefficient, and a smarter approach would try to localize the work during the updates. The latest Claude and GPT assistants recognized this, but their solutions were exceptionally complex and brittle. I eventually solved it myself with a significantly simpler and more robust method (both AIs even gleefully agreed that my solution was slick after I did it).
Had I let my CS fundamentals go to waste I wouldn’t have been able to solve it myself, nor would I have been able to recognize that the solutions posed by the models were needlessly complex.
Just because an AI can generate a solution that passes tests quickly doesn't mean what it generated is a long term good solution. Your skills in fundamentals is key to recognizing when it does a good job and when it doesn’t, and being able to guide it in the right direction.
I was in middle and high school when calculators became the standard, but they were still expensive enough that we kept the Ti-80 calculators on a backroom shelf and checked them out when there was an overnight problem set or homework assignment. In a round about way, I think I ended up understanding more about the underlying maths because of this.
So, no, many did not actually learn arithmetic in school. This isn't necessarily because of the calculator, but if you don't get a student to understand what arithmetic even is then handing them a calculator may as well be like handing them a magic wand that "does numbers".
I'd probably do some hacky ass binary search or something (at least for easy integers)
Maybe you mean “AI tools are making me lose interest in learning anything”, which is… a common reaction, I suppose.
Knowledge builds on knowledge. We learn basic math before advanced math for a reason. The pyramid keeps accumulating from what came before. Understanding the fundamentals still matters, I think.
That'll always be useful.
What's less useful, and what's changed in my own behavior, is that I no longer read tool specific books. I used to devour books from Manning, O'reilly etc. I haven't read a single one since LLMs took off.
Things like cycle times of instructions, pipeline behavior, registers and so on. You had to, because compilers weren‘t good enough. Then they caught up.
You used to manage every byte of memory, utilized every piece of underlying machinery like the different chips, DMA transfers and so on, because that‘s what you had to do. Now it‘s all abstracted away.
These fundamentals are still there, but 99,9% of developers neither care nor bother with them. They don’t have to, unless they are writing a compiler or kernel, or just because it‘s fun.
I think what you‘re describing is also going to go away in the future. Still there, but most developers are going to move up one level of abstraction.
Dictionaries have made me feel like studying languages is pointless. People, why do you think it’s still important to stay strong in languages when dictionaries exist?
The vast majority of line of business apps can be solved with a relatively simple CRUD UI with a simple API server with a SQL based RDBMS. But even then, you will hit limits and experience bottlenecks in practice. If you need to do any kind of scaling, you need to know where the low hanging fruit and complexities lay.
And if you know that the previous algorithm completes in Z milliseconds, tell Claude that too and give it a tool (a command it can run) to benchmark its implementation.
This way you don't need to tell it what it did wrong, it'll check itself.
Of course when I gave that to Claude, Claude changed the algorithm. But if I didn’t have enough experience and CS fundamentals to find it fishy in the first place, why would I construct a counterexample?