This is a story about curiosity, open source, and why I'm grateful I learned programming before AI became everyone's first answer.
"Wait... I built this?"
That was the first thing that came to my mind.
A few days ago, while cleaning up one of my old GitHub accounts, I found a repository named MKishoreDev/Howdoi-bot.
The funny part?
I genuinely couldn't remember creating it.
I opened the repository expecting some unfinished experiment that I'd delete within a minute.
Instead, I found something that instantly took me back four or five years.
A small Telegram assistant written in Python using Pyrogram.
Nothing extraordinary by today's standards.
No large language models.
No GPT.
No Claude.
No Gemini.
No AI agent planning tasks.
Just a simple Telegram bot that answered programming questions.
As I kept reading the source code, memories slowly started coming back.
I remembered exactly why I had built it.
I remembered the excitement.
I remembered spending hours trying to understand how another developer's bot could answer programming questions with a single command.
And most importantly...
I remembered what programming felt like before AI quietly became a part of almost every developer's workflow.
A Tiny Repository That Meant So Much More
The repository was built around an amazing open-source project called HowDoI.
If you've never heard of it, it's a Python package created by the community that searches programming resources and returns quick answers to coding questions.
Repository:
Today that probably sounds...
Normal.
Maybe even underwhelming.
You might be thinking,
"So... it answered programming questions? ChatGPT does that in seconds."
Exactly.
That's the point.
You're reading this in a world where asking an AI anything feels completely normal.
But imagine going back to 2021.
No ChatGPT.
No AI chatbots.
No coding copilots inside every IDE.
No "Generate Component" button.
No AI explaining your stack trace.
Back then, seeing a Telegram bot answer a programming question felt like seeing science fiction become real.
I still remember the first time I used another developer's bot.
The command was surprisingly simple.
/howdoiThat's it.
You could type something like:
/howdoi write a simple Pyrogram botA few seconds later...
The bot replied with code.
Not perfect.
Not conversational.
But useful.
Useful enough that I sat there staring at my phone wondering,
"How is this even possible?"
That single question changed everything.
Curiosity Is a Strange Thing
I've realized something over the years.
The best projects I've ever built didn't begin with an idea.
They began with curiosity.
Curiosity is weird.
Sometimes it starts with seeing someone else's project.
Sometimes it's an error message.
Sometimes it's a random GitHub repository.
Sometimes it's one tiny command that refuses to leave your mind.
For me...
It was /howdoi.
Most people would've used it once, thought "that's cool," and moved on.
I couldn't.
I wanted to know what happened behind the scenes.
How did it search?
Where did the answers come from?
Was it scraping websites?
Was it calling an API?
Could I build something similar?
Questions kept leading to more questions.
Eventually those questions led me to the HowDoI repository.
I spent hours reading code that I barely understood.
Looking back, I probably understood less than twenty percent of what I was reading.
But that didn't matter.
I wasn't reading because I already knew everything.
I was reading because I wanted to.
That's one thing I miss about those days.
Not because AI didn't exist.
But because curiosity always came before convenience.
Before AI Became the First Tab We Open
Today my workflow often looks like this.
- Think of an idea
- Ask AI
- Build
- Refine
- Ship
It's incredibly efficient.
Sometimes unbelievably efficient.
Back then...
The workflow looked very different.
It usually started with Google.
Then another Google search.
Then Stack Overflow.
Then Reddit.
Then a GitHub issue.
Then documentation.
Then YouTube.
Then another Google search because nothing made sense.
Sometimes I'd spend an hour trying to fix a missing comma.
Sometimes an entire evening disappeared because of one import error.
Sometimes Google simply didn't understand what I was asking.
Sometimes I didn't understand what I was asking.
But every search taught me something.
Every dead end taught me something.
Every mistake forced me to understand one more tiny piece of programming.
It wasn't efficient.
It wasn't fast.
But it quietly built foundations I still rely on today.
The Internet Was Full of Invisible Teachers
When people ask me who taught me programming...
I honestly don't know how to answer.
There wasn't one teacher.
There were thousands.
Most of them don't even know I exist.
A Stack Overflow answer from 2013.
A Reddit comment with three upvotes.
A GitHub issue someone opened after midnight.
A YouTube tutorial with 400 views.
A random blog post written by someone who probably forgot it even existed.
Those people unknowingly became my mentors.
Every time they documented a bug...
Every time they answered a beginner's question...
Every time they shared code...
Someone like me learned from it.
Looking back, it's beautiful.
Programming has always been a community effort.
Long before AI started answering questions...
Developers were already teaching millions of strangers without ever meeting them.
I happened to be one of those strangers.
And I'm incredibly grateful for it.
The Telegram Bot Era
My journey into programming didn't begin with web applications.
It didn't begin with React.
It didn't begin with Docker.
It didn't even begin with building websites.
It began with Telegram bots.
Looking back, I genuinely think that era shaped me more than any tutorial or course ever could.
Telegram bots weren't just little chat applications.
For many of us, they were our first experience with APIs, asynchronous programming, databases, deployment, version control, debugging, authentication, automation, and open source—all packed into a project that felt exciting enough to keep us awake until three in the morning.
There was always something new to build.
A moderation bot.
A music bot.
A chatbot.
A file uploader.
A game.
A utility command.
Or simply something weird that made your friends say,
"Wait... you made this?"
That feeling was addictive.
Every New Feature Was an Adventure
Back then, there wasn't an AI waiting to explain everything.
When I wanted to add a feature, I usually had no idea where to begin.
I'd search something like:
"Pyrogram inline keyboard"
Open ten different tabs.
Close eight because they weren't helpful.
Read the documentation.
Copy a small example.
Break it.
Fix it.
Break it again.
Finally understand why it worked.
Then I'd forget it two weeks later and repeat the process all over again.
It wasn't efficient.
But every repetition made me a little better.
Without realizing it, I wasn't memorizing code.
I was learning patterns.
The Community Was the Documentation
I think one of the most beautiful things about that time was the community.
Telegram developers were everywhere.
People built plugins.
Shared snippets.
Answered questions.
Explained weird errors.
Maintained open-source libraries.
Some were older developers.
Some were college students.
Some were kids like me.
Most of us had never met.
Yet somehow everyone kept helping each other.
I still remember asking what now feels like embarrassingly simple questions.
Nobody laughed.
Someone always answered.
Sometimes the answer was one sentence.
Sometimes it was a GitHub link.
Sometimes someone rewrote my entire function just so I'd understand it better.
Years later...
Those conversations still matter more to me than the code itself.
We Didn't Have Fancy Hosting
Today deployment feels almost effortless.
Connect your GitHub repository.
Push your code.
Wait a minute.
Your application is online.
Back then...
It wasn't like that.
Especially if you were just a student.
Cloud servers cost money.
Most of us didn't have credit cards.
So free hosting platforms became our playground.
Heroku.
Replit.
Railway.
PythonAnywhere.
Render.
GitHub Actions.
If it could run Python for free...
Someone had probably figured out how to host a Telegram bot on it.
I remember using Heroku long before I understood how Git worked.
Whenever I changed my code, I did something that sounds completely ridiculous today.
I created a brand-new deployment.
Every.
Single.
Time.
I simply didn't know there was another way.
One day another developer asked me,
"Why don't you just connect your GitHub repository?"
I had no idea that was even possible.
He showed me.
It took him maybe five minutes.
It probably saved me hundreds of hours over the following years.
Looking back, it's funny.
At the time, it completely changed the way I worked.
GitHub Actions Wasn't Meant for This...
...but that didn't stop us.
One trick that became surprisingly popular was running Telegram bots through GitHub Actions.
The workflow would start the bot.
It would keep running until GitHub's runtime limit was reached.
Then it stopped.
Whenever that happened...
We simply started the workflow again.
Was it the intended use of GitHub Actions?
Absolutely not.
Did GitHub probably expect teenagers to keep Telegram bots alive using CI workflows?
Probably not.
Did it work?
Surprisingly well.
It's one of those tiny memories that reminds me how creative developers become when resources are limited.
When you don't have money...
You compensate with curiosity.
The Internet Felt Smaller
Something else was different back then.
The developer community felt...
Smaller.
Not because fewer people programmed.
But because you'd keep seeing the same names.
The same maintainers.
The same Telegram usernames.
The same GitHub profiles.
You'd recognize people simply because you had seen them helping others before.
Some of those developers disappeared over time.
Some moved on to jobs.
Some stopped programming entirely.
Some deleted their accounts.
I don't even remember all their names anymore.
But I remember what they gave me.
Knowledge.
Without expecting anything in return.
If any of those people somehow read this...
Thank you.
You probably don't remember answering a random beginner's question years ago.
I do.
There Was No "Perfect Prompt"
One thing I rarely hear people talk about is how we asked questions before AI.
You couldn't just say,
"Here's my code. Fix it."
You had to explain the problem.
Share the error.
Describe what you already tried.
Search using the right keywords.
Sometimes the hardest part wasn't fixing the bug.
It was figuring out how to ask the question.
Ironically...
Learning how to ask good questions became one of the most valuable programming skills I ever developed.
And I still use that skill today—even when I'm asking AI.
Because the better your question...
The better your understanding usually becomes.
Looking Back...
I don't think that era was better.
It was harder.
Much harder.
But I'm grateful I experienced it.
Those years taught me patience.
They taught me persistence.
They taught me that reading documentation wasn't punishment.
It was part of being a developer.
Most importantly...
They taught me that every great developer was once someone staring at an error message with absolutely no idea what to do next.
The only difference between beginners and experienced developers wasn't intelligence.
It was simply that one person kept asking questions a little longer than the other.
Then AI Arrived
I don't remember the exact day.
I don't think anyone does.
There wasn't a countdown.
No announcement saying,
"Programming is about to change forever."
It just...
Happened.
One day people were sharing Stack Overflow links.
A few months later everyone was sharing ChatGPT screenshots.
At first it felt like another cool tool.
Then GitHub Copilot became better.
Then image generation exploded.
Then AI could generate voices.
Then videos.
Then entire applications.
Then autonomous coding agents.
Almost overnight, asking an AI became the default starting point for solving problems.
And honestly...
It still amazes me.
Sometimes I ask AI to explain an unfamiliar technology.
Sometimes I ask it to review code.
Sometimes I use it to brainstorm architecture.
Sometimes I simply ask,
"Am I thinking about this correctly?"
What would've taken hours now takes minutes.
That's incredible.
The Best Productivity Tool I've Ever Used
I won't pretend otherwise.
AI has made me significantly more productive.
I write code faster.
I learn concepts faster.
I prototype ideas faster.
I write documentation faster.
Sometimes I even discover libraries I would've never found through a normal Google search.
If someone asks me,
"Should developers use AI?"
My answer is always the same.
Absolutely.
Why wouldn't you?
Ignoring one of the biggest technological shifts in software development would be like refusing to use Git because FTP uploads already work.
Technology moves forward.
Developers should move with it.
The problem isn't AI.
The problem is forgetting how to think once AI starts answering.
The Day I Got Humbled
Not long ago, I contributed to a fairly large open-source project.
Like many developers today, I used AI to help me draft parts of my contribution.
I reviewed it.
Modified it.
Submitted it.
The maintainers weren't impressed.
Some of my reasoning was wrong.
Parts of my review showed that I hadn't fully understood what was happening internally.
Someone corrected me.
Publicly.
For a moment...
It hurt.
I felt embarrassed.
I wondered if they simply saw me as another "AI developer."
Another kid copying responses without understanding them.
Then I stopped feeling defensive.
Because if I removed my ego from the situation...
They were right.
Not about who I was.
But about the mistake I had made.
I had trusted AI a little more than I should have.
That experience changed how I use AI forever.
AI Doesn't Remove Responsibility
One lesson stayed with me after that contribution.
AI generated the response.
I submitted it.
That means the responsibility was still mine.
It's easy to blame AI.
"The model hallucinated."
"The AI misunderstood."
"The prompt wasn't good."
None of those excuses matter.
If my name is attached to the code...
It's my responsibility.
Not the model's.
That applies whether you're writing software, documentation, blog posts, or reviewing someone else's pull request.
AI can help.
AI can suggest.
AI can even teach.
But AI doesn't replace accountability.
The Difference I Keep Seeing
Over the past few years, I've noticed something interesting.
Some developers become dramatically better after they start using AI.
Others stop growing almost completely.
The tool is exactly the same.
So what's different?
Curiosity.
The first developer asks,
"Why did AI choose this solution?"
The second developer asks,
"What's the next prompt?"
The first developer opens the documentation.
The second developer opens another chat.
The first developer experiments.
The second developer regenerates the response.
Same tool.
Completely different mindset.
Sometimes I Worry
I'm still young.
Technically, I'm part of the AI generation.
But I sometimes worry about new developers entering programming today.
Not because they use AI.
Because they might never experience programming without it.
Imagine learning mathematics where every question is instantly solved.
You might become very good at asking questions.
But will you understand why the answer works?
Maybe.
Maybe not.
That's entirely up to you.
I meet developers who can generate beautiful landing pages in minutes.
Yet some struggle to explain basic concepts like DNS, responsive layouts, HTTP requests, or Git.
The application works.
Until something unexpected happens.
Then the AI conversation gets longer and longer...
Because the missing piece isn't another prompt.
It's understanding.
If You Build With AI, Learn With AI Too
This is probably the advice I'd give my younger self.
Don't just ask AI to write code.
Ask it why.
Ask it what alternatives exist.
Ask it why one approach is better than another.
Ask it to explain concepts like you're five.
Ask it to argue against its own answer.
Challenge it.
Treat AI less like an employee.
Treat it more like a mentor that occasionally makes mistakes.
Because it does make mistakes.
And sometimes...
Those mistakes become incredible learning opportunities.
The World Didn't Lose Curiosity
People often say AI is making developers lazy.
I don't think that's entirely true.
Curious people remain curious.
AI simply changed where curiosity begins.
Years ago my curiosity started with Google.
Today it might start with ChatGPT.
Tomorrow it might start somewhere else.
The starting point isn't what matters.
The journey afterward does.
Do you stop after getting an answer?
Or do you keep asking why?
That's the question that separates someone who merely uses technology from someone who truly understands it.
The Skills AI Can't Build For You
If there's one thing I'm truly thankful for, it's this:
I learned how to struggle.
That might sound strange.
Nobody likes struggling.
Nobody enjoys spending four hours debugging something that turns out to be a missing comma.
Nobody enjoys reading fifty Stack Overflow posts before finding the one answer that actually solves the problem.
Nobody enjoys deploying the same application over and over because they don't know a better way.
I didn't enjoy it either.
But those struggles quietly taught me something AI never could.
Patience.
Persistence.
Problem-solving.
The confidence to keep going when absolutely nothing makes sense.
Those skills stayed with me long after the bugs disappeared.
"Would You Still Be a Developer?"
Sometimes I ask myself a question.
Not because I expect it to happen.
But because I think it's a good way to measure how much I've actually learned.
If AI disappeared tomorrow... would I still be a developer?
My answer is yes.
Would I become slower?
Without question.
A feature I finish today in one afternoon might take me two weeks.
I'd spend more time reading documentation.
I'd watch far more YouTube tutorials.
I'd search GitHub issues again.
I'd read Stack Overflow answers from 2012.
I'd probably ask more questions in developer communities.
I'd make more mistakes.
I'd get frustrated more often.
But eventually...
I'd still build it.
Because AI accelerated my workflow.
It didn't create my foundation.
That difference matters.
Foundation vs. Acceleration
I like thinking of AI like this.
Imagine someone gives two people the fastest race car in the world.
One person already knows how to drive.
The other has never touched a steering wheel.
Both have the same car.
Only one reaches the finish line.
AI is the race car.
Understanding is the driving skill.
Without understanding, faster tools simply help you get lost more quickly.
Knowledge You Can't Prompt Into Existence
Some lessons simply cannot be generated.
You only learn them by building.
The first time your production server crashes.
The first time you accidentally delete your database.
The first time you spend hours debugging before realizing your environment variable has a typo.
The first merge conflict.
The first rejected pull request.
The first feature users actually love.
The first bug report.
The first contributor correcting your code.
The first time someone says,
"There's a better way to do this."
Those experiences change how you think.
No prompt can replace them.
Programming Isn't About Memorizing Syntax
One of the biggest misconceptions beginners have is thinking experienced developers remember everything.
We don't.
I still search documentation.
I still forget syntax.
I still copy examples.
I still read API references.
The difference isn't memory.
It's recognition.
After enough experience, patterns become familiar.
You stop thinking,
"How do I write this?"
Instead you start asking,
"Why is this designed this way?"
That shift changes everything.
AI can generate syntax.
Only experience teaches intuition.
Curiosity Is Still My Favorite Superpower
Looking back, curiosity has probably been the single most important reason I've stayed in programming.
Curiosity made me search for the HowDoI project.
Curiosity made me read source code I barely understood.
Curiosity made me ask questions that probably sounded silly.
Curiosity made me click "View Source."
Curiosity made me fork repositories just to see what would happen.
Curiosity made me break projects.
Curiosity made me fix them.
That's how I learned.
Not through talent.
Not through intelligence.
Through curiosity.
People often ask AI,
"Give me a startup idea."
It usually gives ten decent ideas.
But they're rarely new.
They're combinations of things that already exist.
The ideas that excite me the most don't usually begin with prompts.
They begin with observations.
Something annoying.
Something inconvenient.
Something I wish existed.
That's where interesting software comes from.
AI can help build it.
But curiosity usually discovers it first.
To Every New Developer Reading This
If you're just getting started today...
You're lucky.
Seriously.
You have access to tools I could only dream of a few years ago.
You can ask questions in natural language.
You can generate examples instantly.
You can translate documentation.
You can debug faster.
You can learn almost anything.
Don't feel guilty about using AI.
Use it.
Learn it.
Master it.
But don't let it become the only way you learn.
Open the documentation even when AI already answered.
Read the GitHub issue.
Watch the conference talk.
Read the pull request discussion.
Study why the code works.
Don't stop at "it works."
Ask why it works.
That one extra question compounds over years.
Fork It. Break It. Run It.
When I first started programming, I wasn't building amazing products.
I was breaking other people's code.
Forking repositories.
Changing random values.
Deleting lines just to see what happened.
Running projects that crashed immediately.
Fixing them.
Breaking them again.
Reading code I didn't understand.
That's how most of us learned.
Not by watching someone else build.
By building badly ourselves.
Even today, when I discover an interesting open-source project, one of the first things I do is clone it.
I want to see how someone else solved a problem.
Not because I want to copy it.
Because I want to understand how they think.
That habit has taught me more than any single tutorial ever has.
And I hope I never lose it.
Looking Back at That Little Repository
After spending some time reading through the code, I closed the repository and just smiled.
Not because it was well written.
It wasn't.
Not because it followed best practices.
It definitely didn't.
Not because it used some revolutionary architecture.
It was just another Telegram bot.
But it represented something much bigger than code.
It represented a younger version of me.
A kid who didn't know much.
A kid who didn't know how deployment worked.
A kid who didn't know Git properly.
A kid who didn't understand asynchronous programming.
A kid who thought seeing a Telegram bot answer programming questions was the coolest thing ever.
A kid who wasn't afraid to ask,
"How does this work?"
That question changed my life.
Not overnight.
Not in one week.
But over years.
Every repository I explored.
Every Stack Overflow thread I read.
Every Reddit discussion.
Every YouTube tutorial.
Every failed deployment.
Every broken production bot.
Every maintainer who corrected me.
Every developer who answered one of my beginner questions.
Every GitHub issue.
Every bug.
Every mistake.
Every success.
Every one of those moments slowly shaped the developer I am today.
The Developers Who Never Knew They Taught Me
Programming is a strange profession.
Some of the people who have influenced me the most have absolutely no idea who I am.
Maybe you wrote a Stack Overflow answer in 2014.
Maybe you explained a confusing Python error on Reddit.
Maybe you uploaded a Pyrogram tutorial with only a few hundred views.
Maybe you maintained an open-source library.
Maybe you reviewed my pull request.
Maybe you simply answered a beginner's question in a Telegram group.
You probably forgot about it.
I didn't.
Knowledge spreads in ways we rarely notice.
One answer can teach thousands of people.
One repository can inspire hundreds of projects.
One encouraging reply can convince someone not to quit programming.
Open source has always been about more than code.
It's about people helping people they'll probably never meet.
And I think that's beautiful.
AI Will Continue to Change
If there's one thing I'm certain about, it's this.
AI isn't slowing down.
It's getting better.
Much better.
I remember when AI-generated images looked distorted and almost funny.
Now they're photorealistic.
I remember when AI could barely complete a sentence consistently.
Now it writes applications.
I remember when AI-generated voices sounded robotic.
Now they're almost indistinguishable from real people.
I remember when asking AI to write code meant getting twenty lines of broken Python.
Now it can generate entire applications, review pull requests, explain architecture, and help debug production issues.
And this is probably the worst AI we'll ever use.
Five years from now, we'll probably look back at today's models the same way we look back at early image generators.
Primitive.
That's exciting.
And honestly...
I'm excited to watch that future unfold.
But Don't Outsource Your Curiosity
There's one thing I hope never changes.
Curiosity.
The internet taught me programming because I stayed curious.
Open source taught me programming because I stayed curious.
Developers taught me programming because I stayed curious.
AI should make that curiosity stronger.
Not replace it.
Don't stop exploring repositories.
Don't stop reading documentation.
Don't stop asking questions.
Don't stop wondering,
"Why?"
That one word has probably taught me more than any programming language ever has.
A Message to Future Me
Maybe I'll read this article ten years from now.
Maybe AI agents will be building complete companies.
Maybe software development will look completely different.
Maybe we'll laugh at how much time we spent writing code manually.
Maybe this entire article will feel outdated.
If that happens...
I hope one thing stays true.
I hope I never become someone who stops learning.
I hope I never think,
"AI already knows everything."
Because that's the fastest way to stop growing.
I hope I still open random GitHub repositories just because they look interesting.
I hope I still read source code for fun.
I hope I still break things.
I hope I still build things that nobody asked for.
I hope I still stay awake at two in the morning because one tiny idea refused to leave my head.
Most importantly...
I hope I never lose the curiosity that started all of this.
One Last Question
Before you close this page, I want to leave you with one question.
Not because there's a right answer.
But because it's worth thinking about.
If every AI model disappeared tomorrow... would you still call yourself a developer?
If your answer is yes...
Keep going.
You're using AI exactly the way it should be used.
As a tool.
If your answer is no...
Don't be discouraged.
Start learning the fundamentals today.
Read the documentation.
Understand networking.
Learn Git.
Break projects.
Fork repositories.
Deploy something yourself.
Read source code.
Ask questions.
Fail.
Fix it.
Repeat.
The goal isn't to stop using AI.
The goal is to become someone who can build with it—or without it.
Because tools evolve.
Frameworks change.
Programming languages rise and fall.
Companies disappear.
Even AI will eventually be replaced by something better.
But genuine curiosity...
That never becomes obsolete.
When I found that little MKishoreDev/Howdoi-bot repository, I expected to rediscover an old project.
Instead, I rediscovered an old version of myself.
A curious kid.
One Google search after another.
One Stack Overflow answer after another.
One bug after another.
One tiny victory after another.
I'm grateful I experienced programming before AI became the default answer to everything.
Not because those days were better.
Not because today's developers have it easier.
But because those years taught me something I'll carry for the rest of my career.
Technology will always change.
Curiosity shouldn't.
If you ever find one of your old repositories, don't rush to delete it.
Open it.
Read it.
Smile at the mistakes.
Thank the younger version of yourself for being brave enough to build it anyway.
You might just rediscover why you fell in love with programming in the first place.