u/Dimpy-Pokhariya

Here's literally how side projects are replicated

You create a single feature to "learn" or "validate a concept." It gets some users, someone provides some feedback, someone asks for a certain feature, and now you have startups ideas popping up in your mind every ten minutes.

Initially, it was supposed to be a small project. Suddenly you find yourself with a roadmap, version two, another repository, and an entire Notion page of ideas that somehow feel like a multi-billion dollar company at 3 AM.

But here's the funny thing - developers never settle for one project. One side project spawns another side project and the cycle goes on and on.

I experienced that after creating a landing page for my small idea through Runable AI. The page was done but I'm already thinking about what would happen if it becomes a platform

Side projects don't stop. They multiply.

Vibe coding confidence is genuinely terrifying 😭

Old programmers used to spend months learning syntax, debugging, reading documentation, and crying over semicolons.

Now people open AI at 2am with maximum confidence and type things like:

“create windows12 and make no mistakes”

No architecture. No specs. No planning. Just pure faith and unlimited optimism.

The funniest part is AI sometimes acts like it might actually try. Suddenly it starts generating folders, writing files, explaining system design, and for 3 minutes you genuinely believe Microsoft is finished.

I had the same delusion recently while using Runable AI to generate a landing page for a side project. Started with “quick page for testing an idea” and 20 minutes later I was acting like I accidentally built a startup.

AI didn’t remove overconfidence. It industrialized it.

There’s nothing that makes developers feel invincible like “100% test coverage” 🙁After days spent on validations, edge cases, clean architecture, meaningful error messages, unit tests, and integration tests, one begins to believe that the app can handle anything thrown at it. Every single scenario has been tested and everything looks polished, production-ready, and enterprise-grade.Then comes the real user.And within 14 seconds, they manage to:upload a 400MB profile picture, paste emojis into number fields, input their birthdate as tomorrow’s date, use the internet explorer on their fridge,find a bug that was deemed impossible to occur.The best part about users is that they’re more inventive at breaking apps than developers are at building them.That’s what happened to me after developing an admin dashboard using Runable AI recently. All went well until a symbol was entered inside the search filter that magically morphed my interface into something surrealistic.

At this point, I think users are the ultimate boss in software development.

I miss the days when “hello” was just a normal greeting and not a financially dangerous decision 😭

Now every interaction with premium AI models feels like summoning an ancient supercomputer that immediately starts burning resources just to answer the simplest thing imaginable.

You ask one tiny question and suddenly it generates:

full architecture plan

market analysis

emotional backstory

production-ready code

three alternative solutions nobody requested

Meanwhile you’re sitting there watching your usage limit evaporate in real time.

The funniest part is this has genuinely changed how I prompt. Recently I used Runable AI to create a landing page draft for a side project and caught myself writing prompts like I was paying legal fees per sentence. Straight to the point. No greetings. No extra words. Pure survival instincts.

AI was supposed to replace repetitive work. Instead it turned developers into people who strategically ration adjectives to save credits.

Rate it out of 10

Do you like color grading

Rate the photo out of 10

Please rate the photo

The problem is that when people write about AI as the next step toward creating an unstoppable superintelligence, what AI really does half the time is classify a picture of a raccoon as a picture of a tiger with 100% confidence

The issue isn't even the inaccuracy; the real problem is the confidence in their mistakes. The response you'll get from your friendly AI is always going to be an outrageous error, delivered as though it personally confirmed the laws of physics.

That realization came when I used Runable AI to build a product landing page for a side project I'm working on. Everything seemed great until I saw that one of the pages' feature descriptions included functions that were literally nowhere to be found in the product.

That's when you realize AI can never replace us any time soon. It can only help programmers generate problems in record amounts.

From now on, when I'm notified that my code has run successfully, I will be looking into it carefully since there must be some raccoon hidden deep in the machine somewhere.

Clients always say "modern", "clean", "responsive" and "user friendly" because they believe these terms will somehow describe the needs. Then comes days of deciphering vague messages, recordings from voice memos, and poorly drawn sketches, along with feedback that changes everything every few hours.

The really scary thing happens when after all that deciphering and understanding you finally grasp what is needed. The scary thing is right after that understanding the project gets its curse mark - the buttons just randomly get moved around, layouts bend as if physical laws stop applying, and the whole design just suddenly adapts, as if on its own will.

The software development half of the time seems to be not an engineering task but translation of human gibberish into functional code.

Recently while testing a small runable ai workflow, I found something truly frightening about AI technologies. They tend to follow the requirements to the letter, which turns out to be a terrible thing when the requirements themselves are ridiculous.

Suddenly bugs become a reasonable choice.

Writing code genuinely feels easy now compared to debugging it. You spend hours feeling productive, typing fast, adding features, reorganizing files, and convincing yourself you’re basically a senior engineer now. Then one random error appears on line 265 and suddenly your entire personality changes.

The funniest part is the bug is usually something absolutely disrespectful. Missing comma. Wrong variable name. One bracket living in the wrong dimension. Extra space. Something your brain magically becomes blind to after staring at the same file for 2 hours straight.

At some point debugging stops being programming and becomes psychological warfare between you and a machine that refuses to explain itself properly.

I had one tiny workflow break recently and spent more time debugging than actually building the feature itself. Even the small runable ai automations I experiment with somehow end with me questioning every life decision after midnight.

Coding gives confidence. Debugging removes it immediately.