The first time I really used AI for coding, it reminded me of mentoring a smart but inexperienced junior engineer.
I’d describe a problem in plain English, and it would suggest code. Sometimes it worked. Sometimes it missed the point entirely. But it was fast. Surprisingly fast. And just like a junior engineer, it needed guidance, context, and review.
In a traditional team setup, junior engineers are the ones who:
- Take on smaller, well-defined tasks
- Learn the codebase by contributing incrementally
- Ask a lot of questions (sometimes too many)
- Deliver quick wins when given clear instructions
- Need guardrails to avoid breaking things
- Eventually grow into mid and senior-level engineers by working under mentorship
They aren’t expected to make big architectural decisions or weigh complex trade-offs. They’re expected to learn, contribute, and grow.
That’s not so different from how we’re starting to work with AI.
AI today, whether it’s GitHub Copilot, ChatGPT, Cursor, or Claude Code. They are becoming our new junior teammate.
It can:
- Scaffold boilerplate code
- Generate tests from API specs
- Suggest solutions in real-time
- Refactor small chunks of code
- Summarize documentation or logs
But it can’t:
- Weigh the long-term trade-offs of a decision
- Understand the full system context unless we feed it
- Guarantee maintainability, performance, or elegance
- Spot subtle bugs that require real-world experience
- Design systems with intention
AI becomes a contributor in our source code. And just like with a junior engineer, the output is only as good as the guidance.
Treating AI like a junior engineer isn’t just a metaphor, it’s a practical mindset shift.
Here’s how you can get the most out of it:
Give clear instructions
Just like a new hire, AI thrives when it has clear context. The more context you give it, like data structures, constraints, goals, the better the result. Don’t expect magic from a vague prompt.
Review everything
AI might suggest 20 lines of working code, but you’re responsible for what ships. Skim it at your own risk. Review for performance, security, readability, and fit with your existing architecture.
Use it to unblock, not autopilot
Use AI to support debugging, understand unfamiliar syntax, or automate repetitive tasks. But don’t let it turn you into a passive reviewer. Keep your problem-solving muscle strong.
Teach it as you go
Use feedback loops. If a suggestion is wrong, correct it and explain why. Over time, you’ll learn to prompt better, and the AI will give better results in return.
Stay the decision-maker
Even if AI can scaffold a feature, ask yourself:
- Does this meet user needs?
- Is it scalable?
- Will my teammates understand and maintain this?
These are human questions. Keep asking them.
At the end of the day, the best engineers will know how to:
- Delegate effectively to AI
- Fill in the gaps it can’t see
- Make the final call when it matters
AI vs. Junior Engineer
| Task / Trait | Junior Engineer | AI |
|---|---|---|
| Writes code | ✅ With supervision | ✅ With guidance |
| Understands business context | ❌ Needs mentoring | ❌ Needs detailed input |
| Makes architectural decisions | ❌ Not expected to | ❌ Can provide ideas |
| Learns and grows with experience | ✅ Over time | ❌ Stays static (until retrained or better model) |
| Handles boilerplate and repetitive work | ⚠️ Might take time | ✅ Fast and efficient |
| Explains trade-offs | ⚠️ With guidance | ❌ Doesn’t understand consequences |
| Communicates and asks clarifying questions | ✅ Part of growth | ❌ Only when prompted properly |
| Needs code review | ✅ Always | ✅ Always |
| Can be mentored | ✅ Yes | ⚠️ Only indirectly via better prompts |
| Can become a senior engineer | ✅ That’s the goal | ❌ Never |
| Suggests solutions | ✅ Sometimes, with limited perspective | ✅ Often, based on pattern recognition |
| Write your opinion | … | … |
| Write your opinion | … | … |
| Write your opinion | … | … |