The Stupid Questions That Got Me Here (And Why You Should Ask Them Too)

Spoiler: I still ask stupid questions. Every single day.

Six months ago, I didn't know what an API was. I didn't know what "deploying" meant. I definitely didn't know that a single missing semicolon could break an entire website and send me spiraling into an existential crisis at 2am.

Now I have a live portfolio site. I've built games. I write about AI. And the only reason any of that happened is because I was willing to feel like an idiot long enough to figure it out.

This post is for anyone who's ever been too scared to start something because they don't know enough. Spoiler for that too: you'll never feel ready. Start anyway.

What You'll Learn in This Post

Why "stupid" questions are actually the smartest move
How failure teaches you things success never will
Real examples from building this site that nearly broke me
The mindset shift that changes everything

The First Step Is Always Embarrassing

When I started using AI to help me code, I didn't even know how to ask the right questions. My prompts were vague. My expectations were unrealistic. I thought I could just say "build me a website" and boom—done.

What actually happened: AI gave me back exactly what I put in. Which was nothing useful.

My first ChatGPT conversation about this project went something like:

Me: "I want to make a website." ChatGPT: "Great! What kind of website? What features do you need? What tech stack are you considering?" Me: "...I don't know."

That was my starting point. I didn't even know what I didn't know.

So I did the only thing I could: I started asking what felt like stupid questions.

"What's a tech stack?" "What does Next.js do?" "Why is my page blank?" "What's a 404 and why does it hate me?"

Every question felt embarrassing. But every answer got me one step further.

The Truth About Failure (It's the Whole Point)

Here's what nobody tells you about learning something new: if it all works perfectly the first time, you haven't actually learned anything.

Think about it. If AI just magically does everything right and you never see an error, what happens when something breaks? You're stuck. You don't know why it worked in the first place, so you definitely don't know how to fix it.

When I was building this site, things broke constantly. I'm not exaggerating—I broke the same component three separate times in one afternoon.

One time I spent two hours debugging a page that wouldn't load. The issue? I'd put a comment in the wrong place. Two hours. For a misplaced comment.

But now I'll never make that mistake again. I know exactly what that error looks like. I know where to look. I know how to fix it.

That knowledge didn't come from a tutorial. It came from failing, googling frantically, and eventually figuring it out.

Real Failures From Building This Site

Let me give you some concrete examples of me getting it wrong. Publicly. For your entertainment and education.

The "It Works On My Computer" Problem

I built a feature. Tested it. Everything looked perfect. I was proud of myself.

Then I deployed it. And it didn't work. At all.

Turns out, what works on your own machine doesn't always work when you put it online. Different environment, different rules. I had no idea that was even a thing.

I spent hours trying to figure out why my perfectly working code suddenly wasn't. The fix ended up being small—but finding it taught me to always test in the real environment, not just my own little bubble.

The Cleaning Out the Garage Moment

At one point, I realized my project had accumulated a ton of stuff I wasn't actually using. Old code from tutorials I'd tried. Features I'd started and abandoned. Things I'd copied without fully understanding.

It was like a digital junk drawer. And it was slowing everything down.

Going through and cleaning it all out was tedious. But it forced me to actually understand what each piece did—and whether I needed it. Half the stuff? I didn't even remember adding it.

The Missing Piece I Didn't Know Was Missing

My site kept failing certain checks. I couldn't figure out why. Everything looked right to me.

After way too much digging, I found it: I'd referenced something that didn't exist. I'd written the code assuming a file was there, but I'd never actually created it.

The system was looking for something I'd promised but never delivered. Classic beginner move. And honestly? I've done some version of this more than once.

The Questions I Was Afraid to Ask

Here are actual questions I've asked AI during this project. Questions I was convinced were too basic, too obvious, too stupid:

"What does this error message actually mean?"
"Why is my page blank when the code looks right?"
"What's the difference between these two things that sound the same?"
"How do I know if my code is good?"
"Why does this work sometimes but not other times?"
"Can you explain this like I'm five?"

Every single one of those questions taught me something important. Not one of them was actually stupid.

The only stupid question is the one you don't ask because you're too worried about looking dumb.

Why AI Makes This Easier (And Harder)

AI is an incredible tool for learning. I can ask it anything at 2am and get an answer. I can ask it to explain things "like I'm five" or "like I'm a senior developer" depending on what I need.

But here's the catch: AI is only as good as what you give it.

If your prompts are vague, your answers will be useless. If you don't give it context—what you're building, what you've tried, what's not working—it can't actually help you.

I learned this the hard way. Early on, I'd just paste error messages and hope for a miracle. Now I include:

What I'm trying to do
What I've already tried
The specific error or behavior
Screenshots when relevant (seriously, screenshots are a game-changer)

The better I got at asking for help, the better the help became.

The Mindset That Changed Everything

I used to think I needed to understand everything before I could start. I thought I needed to take courses, read documentation front to back, get some kind of certification.

What I actually needed was to just start. And be okay with not knowing.

The moment I gave myself permission to be a beginner—to ask dumb questions, break things, and figure it out as I went—everything changed.

I stopped waiting to feel ready. I just started doing.

And every failure, every error message, every moment of confusion became a lesson instead of a defeat.

What I'd Tell You If You're Just Starting

You don't need to know everything to begin. You need to begin to know anything.

Ask the stupid questions. They're not stupid. They're the fastest path to understanding.

Break things on purpose. Seriously. Change something and see what happens. You'll learn more from one broken build than ten working tutorials.

Use AI as a thinking partner, not a magic wand. Give it context. Ask follow-up questions. Make it explain things until they click.

Expect to feel lost. That feeling doesn't mean you're doing it wrong. It means you're doing something new. Big difference.

What's Next?

I'm still learning. Still asking questions that feel obvious. Still breaking things and fixing them.

This site is a living document of that process. Every blog post, every project, every game—it's all proof that you don't need credentials or experience to build something real.

You just need to start. And keep going when it gets hard.

Have You Taken the First Step?

I want to hear about it. What are you trying to learn? What's the question you've been too afraid to ask? What broke last week that you finally figured out?

Reach out. Comment. Share what you're working on.

We're all figuring this out together. Might as well do it in public.

Thanks for reading.