A few years ago, when I started working with Python, my first instinct when stuck was to dive into Stack Overflow, followed by asking a senior developer.
Today, junior developers do the same. Except, the first choice without hesitation is ChatGPT or you know any other similar AI tools like Perplexity or DeepSeek etc.
Let’s leave Stack Overflow because they hardly touch it. And the seniors are their last choice.
And honestly, we should not blame them.
When AI provides us with instant answers, formatted solutions, and explanations that are often better than what you’d find in a messy Stack Overflow thread, why would you go the difficult way of searching and communicating?
But this shift raises a serious question:
Is AI creating a knowledge gap between junior and senior developers?
For junior developers, AI feels like a magic wand.
Stuck on an error? Just paste it into ChatGPT.
Need to optimize code? Ask for a better version. (The speed and efficiency are undeniable)
But But… there’s a hidden cost.
First,
Unlike Stack Overflow, where you had to wade through multiple answers, compare solutions, and often tweak things to make them work, ChatGPT gives polished responses on demand.
Dependency rather than understanding? No?
And Second,
In contrast, senior developers — who grew up debugging by hand and learning from colleagues — have a deeper grasp of system design, architecture, and the why behind the how.
When juniors skip this process, they risk knowing what works but not why it works.
I’ll give you an example —(Easiest way to explain is examples. My apologies — good examples)
A junior developer, Sumeet, on my team was recently building a Fast API service that required dependency injection for db access.
Their code:
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()Their usage:
db = get_db() # WRONG! db is now a generator, not a Session object
db.commit() # ❌ ERROR! A generator has no commit methodThey kept getting:
RuntimeError: Generator object has no attribute 'commit'Now, Instead of understanding how Fast API handles dependency lifetimes, Sumeet, like any modern developer, didn’t debug manually.
Instead, he pasted the error straight into ChatGPT.
AI quickly suggested a fix. But here’s the problem:
It didn’t explain why the issue happened
A senior dev, on the other hand, would have walked him through it:
- Why does FastAPI use
yieldinstead of returningdb? (Short answer: To properly manage the session lifecycle.) - What happens if you call
get_db()directly? (You get a generator, not a session.) - How does FastAPI handle dependencies behind the scenes? (It calls
next(get_db()), extracts the session, and ensures it's closed properly.)
The AI gave him a working solution, but not a learning opportunity. Next time he faced a similar issue? He’d be stuck again.
@app.get("/users/")
def get_users(db: Session = Depends(get_db)):
return db.query(User).all()The correct way as above, which ensures the session is created, used, and properly closed.
At the end of the day, AI should enhance a developer’s skills — not replace them. So next time you’re stuck in FastAPI, challenge yourself: Can you debug this before asking ChatGPT?
What do you think? Have you seen AI making juniors too dependent? Let’s discuss in the comments!
In case we are meeting for the first time, come over here, it’ll be worth the roller coaster of articles that are gonna come up in the next few weeks.
Use this to get to know more about me — https://linktr.ee/shashwat_writes
This story is published on Generative AI. Connect with us on LinkedIn and follow Zeniteq to stay in the loop with the latest AI stories.
Subscribe to our newsletter and YouTube channel to stay updated with the latest news and updates on generative AI. Let’s shape the future of AI together!
