I’ve reached that point in my career where I’m mostly done learning to code. (Well, mostly.) I’m comfortable enough with languages and systems that when I ask an LLM to spit out some code, I can eyeball it, verify it’s solid, and submit it confidently. I also tend to think more about large-scale designs, so getting the LLM to handle the “grunt work” of writing boilerplate or wiring up APIs feels like outsourcing to a virtual assistant. It’s nice.
But for juniors? It’s a different story.
Why Juniors Still Need to Learn the Basics (Even if They Want to Skip It)
Junior devs are still wrestling with fundamentals that you really can’t shortcut:
The syntax of their language.
The idioms — eg what “good” TypeScript looks like vs. JavaScript with “any” sprinkled all through it.
How to write solid tests — because coverage numbers don’t count if they don’t catch bugs.
Writing clean, maintainable code — low complexity, good structure, SOLID principles, composability.
This learning grind is part of becoming a great developer. Relying too early on LLMs to just “write the code” is like trying to learn to swim by floating on a lilo. Sure, you’re in the water, but you’re not going anywhere fast.
Using LLMs as Coaches, Not Crutches
That said, LLMs are fantastic when juniors use them as coaches. When a question hits the common-but-confusing realm. Concepts like caching patterns, AWS IAM policies, networking basics – LLMs can explain things clearly and patiently. It’s like having a knowledgeable buddy who never gets tired or annoyed.
They can also act as a first-pass code reviewer, pointing out potential flaws. But remember, LLMs want to please. They might not argue or defend their points rigorously. Juniors need to push back, reason through suggestions, and decide what actually makes sense.
Practice & Exploration with LLMs
LLMs are way more than just answer machines — they’re awesome sparring partners for active learning:
Stuck on a coding challenge? Ask for hints or step-by-step walkthroughs instead of the whole answer.
Looking for side project ideas to explore new tech? LLMs can tailor suggestions to your level and interests.
Need to talk through your thought process? Use LLMs as a virtual pair programmer to brainstorm, debug, or plan designs.
Turn LLMs into learning tools — not just code generators.
Documentation: Learning to Communicate, Not Just Write
Documentation is a skill juniors must build themselves — it’s how you organize your thoughts and communicate your work.
Here’s a better use for LLMs: communication coaches. Draft your docs or explanations yourself, then ask the LLM to help rewrite for different audiences — fellow devs, PMs, or even non-technical folks. Practice simplifying complex concepts without dumbing them down too much.
LLMs can also polish commit messages, pull request descriptions, or status updates — helping juniors learn the tone and clarity good communication needs.
Legacy Code: More Than Just Lines of Mystery
Legacy code is the ultimate challenge. Sure, LLMs can explain snippets or spot obvious problems, but remember: legacy code isn’t just “bad” because it’s old. It’s often a product of history:
Decisions made under tight deadlines
Tradeoffs forced by limited resources
Team and company constraints that no longer apply (or maybe still do)
An LLM won’t know this story. Real understanding comes from slogging through, reading docs (if you can find them), asking teammates, and connecting dots.
Use LLMs as a starting point — a flashlight in the dark — but be ready to do the hard work.
Accountability Reminder: Own Your Code, Even if AI Helped
If you’re submitting code generated by an LLM, you are the one putting your name on it. You need to be able to explain, defend, and take responsibility for it.
No “Oops, CoPilot wrote that and I didn’t check.” That’s not how professional development works. Be accountable. It’s your name on the commit.
Summary: Use LLMs Wisely, and Remember It’s a Journey
LLMs are powerful tools that juniors can use to accelerate learning — as coaches, practice partners, and communication aids. But they aren’t a shortcut through the fundamentals. Learning to code well means practicing syntax, writing tests, understanding good design, and grappling with legacy systems.
Your relationship with LLMs will evolve as you grow. They’ll get smarter, you’ll get smarter, and the ways you use them will change — and that’s totally okay. Think of them as part of your toolkit, not a replacement for your brain.
Use them to learn, not just to do.