I was three years into my development career when a simple question broke me.
"Can you explain how useState actually works?"
I froze. Sure, I could write const [count, setCount] = useState(0) in my sleep. I'd built dozens of components with hooks. But explain how it actually works? The mechanism behind it? Why it exists?
I had no clue.
That's when it hit me: I wasn't really a developer. I was just really good at copying patterns.
We're All Pattern Matchers
Here's what most of us do when learning something new in programming:
- Find a tutorial or Stack Overflow answer
- Copy the code
- Modify it until it works
- Move on to the next problem
It works. Your features ship. Your boss is happy. But you're building on quicksand.
I did this exact thing in high school with calculus. I memorized that the derivative of x² is 2x. Got A's on tests. But I had zero intuition for what a derivative actually meant. When I needed to apply calculus to real problems later, I was lost.
Same pattern, different domain.
The LLM Trap
Now we have an even bigger problem. ChatGPT can write better code than most of us. You can literally describe what you want and get production-ready functions back.
But here's the thing: the AI understands the code better than you do.
Let me give you an example. Ask ChatGPT for a debounced search hook and you'll get something like this:
function useDebounce(value, delay) {
const [debouncedValue, setDebouncedValue] = useState(value);
useEffect(() => {
const handler = setTimeout(() => {
setDebouncedValue(value);
}, delay);
return () => clearTimeout(handler);
}, [value, delay]);
return debouncedValue;
}
It's perfect. It works flawlessly. But do you know why that return function exists? What happens if you remove it? Why the dependency array matters?
If not, you're just a very sophisticated copy-paste developer.
What Understanding Actually Means
Real understanding isn't knowing the syntax. It's knowing the why behind everything.
Take that useState example that stumped me. The syntax is easy:
const [name, setName] = useState("John");
But the meaning? useState is React's way of giving functional components memory. Without it, every time your component re-renders, all your variables would reset. It's like giving your component a notebook where it can write things down and remember them between renders.
That understanding changes everything. Suddenly you know:
- Why you can't call hooks in loops (you'd mess up React's notebook system)
- Why useState returns an array (so you can name the variables whatever you want)
- Why calling setName triggers a re-render (React needs to update what's on screen)
The Magic Question
Want to know if you really understand something? Try explaining it to someone who's never seen it before.
Not the syntax. The purpose. The problem it solves. Why it exists.
I started doing this with every new concept I learned. Instead of just learning "how to use promises," I'd ask myself: what problem do promises solve?
Answer: JavaScript is single-threaded. Without promises (or callbacks), your entire app would freeze every time you made an API call. Promises let you say "hey, go do this thing, and let me know when you're done, but don't stop everything else while you wait."
That's not just syntax memorization. That's understanding.
The Three Questions That Changed My Career
Every time I encounter something new now, I ask myself:
What problem does this solve?
Not how to use it. What real-world pain point does it address? Why did someone bother creating this?
How does it solve that problem?
What's the mechanism? What's the mental model? If I had to build this from scratch, what would I need to think about?
What could go wrong?
What are the edge cases? When does this approach break down? What mistakes do people commonly make?
Let's apply this to something concrete. Say you're learning about database indexes:
- Problem: Searching through millions of database rows is slow
- Solution: An index is like a book's table of contents. Instead of reading every page to find "Chapter 7," you check the index and jump straight there
- What could go wrong: Indexes speed up reads but slow down writes (imagine updating the table of contents every time you add a sentence)
Now you don't just know how to add an index. You know when to add one and when not to.
Beyond Stack Overflow Thinking
Most developers stop at Stack Overflow. They find code that works and move on. But the real learning happens in the comments, in the alternative answers, in understanding why the accepted solution was chosen.
Same with AI tools. Don't just take the generated code and run. Ask follow-up questions:
- "Why did you choose this approach?"
- "What are the trade-offs?"
- "When would this approach fail?"
The AI will gladly explain, and you'll actually learn something instead of just getting working code.
The Compound Effect
Here's what happens when you prioritize meaning over memorization:
Month 1: You're slower. While others copy-paste solutions, you're reading docs and asking why.
Month 3: You start recognizing patterns. New frameworks feel familiar because you understand the underlying concepts.
Month 6: Debugging becomes easier. When something breaks, you can reason about what went wrong instead of just trying random fixes.
Year 1: You become the person others ask when they're stuck. You can see the forest, not just the trees.
Start Today
Pick one thing you use regularly but don't fully understand. Maybe it's:
- How JWT tokens actually work
- Why React needs keys in lists
- What happens when you deploy to production
- How CSS specificity really works
Spend 30 minutes not learning how to use it, but understanding what it means. What problem it solves. Why it exists.
Don't just read about it. Try to explain it out loud. Draw diagrams. Break it down into simpler pieces.
The Hard Truth
Learning this way is slower at first. While your coworkers are shipping features using copy-pasted code, you're still reading documentation and asking questions.
But here's the thing: they're building on sand. You're building on rock.
When the next big framework comes out, they'll need to learn everything from scratch. You'll see the patterns and adapt quickly.
When bugs appear in production, they'll be googling frantically. You'll understand what went wrong and how to fix it.
When they hit complex problems that can't be solved with existing Stack Overflow answers, they'll be stuck. You'll be able to reason through solutions.
The Bottom Line
Anyone can copy code. Anyone can follow tutorials. Anyone can ask ChatGPT to build features.
But understanding? That's rare. That's valuable. That's what separates senior developers from junior ones who happen to have been coding for a long time.
So next time you're tempted to just copy that Stack Overflow answer or paste that AI-generated function, pause. Ask yourself: do I understand what this actually means?
Your future self will thank you.
Top comments (0)