Look, I love AI as much as the next person. Claude Code, Cursor, Copilot are all incredible tools that have genuinely made me a more productive developer. But I'm watching new developers lean on AI so heavily that they're missing the fundamentals that actually matter. It's like learning derivative rules without understanding limits in calculus—you can mechanically apply the power rule, but the moment you hit something complex, you're screwed.
AI is amazing for speeding up workflows, but if you're using it as a crutch to avoid learning documentation, algorithms, or debugging, you're setting yourself up for failure.
Here are the four things that actually propelled my learning as a software engineer—the stuff that AI can't do for you.
1. Actually Reading the Documentation
I know, documentation is boring. But the documentation is literally the source of truth.
When I started learning React, I didn't just watch YouTube tutorials or ask ChatGPT. I sat down with the React docs and read them, then spent 10 hours a day (for about 2 weeks) building a project with them. And you know what? I understood React in a way that my classmates who only watched tutorials never did (by the way, that project was Reality Quest, and it's had about 150 real users).
The documentation tells you not just how to do something, but why it works that way. It explains edge cases, gotchas, and performance implications. It gives you the mental model you need.
// You can ask AI to write this:
const [count, setCount] = useState(0);
// But the docs teach you WHY this pattern exists
// and when you'd want to use useReducer instead
Reading documentation is about developing the skill of learning from primary sources. In your first job, you'll encounter internal tools and domain-specific problems that AI has never seen. The ability to read technical documentation will be your lifeline.
2. Finding a Mentor (Or at Least Someone Better Than You)
This changed everything for me. I was lucky enough to have a senior/staff developer take me under their wing for the past 4 years.
A good mentor doesn't just answer your questions. They ask better questions, and let you ask stupid ones. When I'd show up with "my code isn't working," my mentor would ask:
- "What did you expect to happen?"
- "What actually happened?"
- "How did you debug this?"
This taught me systematic problem-solving instead of throwing code at the wall.
The real magic happens during code reviews.
If you don't have a mentor: Contribute to open source projects, join developer communities, or find a study buddy who's slightly ahead of you (also X is incredibly useful for this, lots of great people on there).
3. Yes, DSA and Algorithms Actually Matter (Sorry)
"But I'm building web apps, not Google's search algorithm!" Look, I get it. But understanding data structures and algorithms isn't about memorizing BST algos, it's about developing problem-solving intuition.
When you understand how different data structures behave, you make better decisions in everyday code (below's a very simlpe example):
// Without basic DSA knowledge:
const findUser = (users, id) => {
return users.find((user) => user.id === id);
};
// O(n) every single time
// With basic DSA knowledge:
const userMap = new Map(users.map((user) => [user.id, user]));
const findUser = (id) => userMap.get(id);
// O(1) lookup
LeetCode problems are contrived, but they teach you how to break down complex problems, recognize patterns, and think about complexity. I'm not saying grind 500 problems, but understanding common patterns is genuinely valuable.
4. Build Everything You're Learning (Seriously, Everything)
This is probably the most important one. Nothing beats actually building things.
The learning-by-building loop:
- Learn a new concept
- Immediately build something with it
- Run into problems the tutorial didn't mention
- Debug those problems
- Understand the concept 10x better
When I was learning React, I didn't just follow tutorials. I built a webapp that was used at a convention with over 1000 attendees.
The real learning happens when things break. When your API calls fail, when state management gets messy, when CSS looks terrible on mobile. That's when you're forced to really understand what you're doing.
The Bottom Line
AI is an incredible tool, but the fundamentals still matter:
- Reading documentation teaches you independent learning
- Having a mentor shows you how to think like an experienced developer
- Understanding algorithms gives you problem-solving intuition
- Building projects teaches you how things actually work
These skills compound over time. The developer who can read docs, think algorithmically, and debug their own code will always be more valuable than one who can only prompt AI effectively.
So use AI, but don't let it become a crutch. Learn the fundamentals. They're called fundamentals for a reason.
What other fundamentals do you think new developers skip? 💭