u/Anantha_datta

letting generic chatbots handle your app architecture is genuinely dangerous sometimes lol yeah the code technically works at first, but then you open the project a week later and realize the entire thing is held together with hallucinated logic and random dependencies that make zero sense. few weeks ago i had an agent somehow connect frontend state management to the database layer in the weirdest way possible. deleted one line and the whole app basically detonated itself with errors. that was enough for me to stop letting raw chat windows guess project structure. now i usually let Claude Code handle the backend/data flow properly, then pass structured output into Runable for the UI layer instead of fighting broken layouts and cursed inheritance chains at 3am. honestly way less mental damage lol

Was updating my resume and realized every portfolio site looks exactly the same.

So I experimented with a few Al tools to make something way more dramatic.

Built a personal website with:

animated career timeline

project showcase sections

fake "skill tree" progression

cinematic transitions

interactive case studies

dark sci-fi UI

Used Runable for the site generation, ChatGPT and Claude for rewriting the content, and Midjourney for visual concepts/backgrounds.

Now my resume looks less like a PDF and more like a Netflix intro screen.

Would you actually prefer +his over traditional portfolio sites or is it to the top?

Had a bunch of random startup ideas sitting in Notion for months.

Finally decided to dump everything into a few Al tools and see what would happen.

Ended up generating:

a full pitch deck

landing page copy

pricing model

competitor breakdown

logo concepts

investor-style market slides

Used Runable for the actual product generation, ChatGPT/Claude for refining the positioning, and Midjourney for some visual directions.

Honestly expected garbage, but some of the slides looked surprisingly investor-ready.

What's the weirdest thing you've managed to build with Al lately?

Started as a random late-night idea after seeing people recreate anime scenes in Japan.

So I built a planner where you enter your favorite anime, budget, and trip length, and it generates a full Japan itinerary around it.

It maps:

anime locations

nearby food spots

train routes

themed cafés

shopping areas

estimated daily budget

Used a mix of AI tools like Runable, image generation models, and itinerary prompting workflows to put everything together.

The Akihabara and Shibuya sections honestly came out way better than I expected.

I’ve had this “main idea” sitting in my notes for almost a year. Every few weeks I’d come back to it, tweak it, watch a few videos, maybe redesign a flow… and then leave it again. It always felt like I wasn’t ready to actually build it yet.

This weekend I got a bit fed up and decided to do the opposite. Instead of touching that idea, I picked something small and kind of random and just tried to ship it in one sitting. No planning, no polishing just get something live.

I used a mix of tools I’ve been seeing around (ChatGPT for rough ideas, a bit of Claude for rewriting things, and an AI builder called Runable to put the page together) mainly so I wouldn’t get stuck on setup or design decisions. The goal was just to remove friction and see what happens if I actually finish something.

It’s nothing special honestly pretty basic. But it’s already getting more attention than the “perfect” idea I’ve been overthinking for months. Not huge numbers or anything, just enough to make me realize I was probably avoiding shipping more than I thought.

I think the biggest shift for me was realizing that planning feels productive, but it’s not the same as putting something in front of real people. Curious if anyone else has run into this where the quick, low effort thing ends up teaching you more than the idea you’ve been refining forever?

A few months ago I tried to automate some of my work — simple stuff. Moving data, triggering actions, connecting a few steps together.

On paper, it sounded perfect: set it up once and let it run.

But in reality, it turned into a mess.

Things wouldn’t trigger. APIs would fail randomly. One small issue would break the entire flow, and half the time I wouldn’t even notice until I checked manually.

And that became the real problem I couldn’t trust anything to just run.

I’d set something up, walk away, and still come back 10 minutes later just to make sure it didn’t break. Not because I wanted to… but because it usually did.

So instead of saving time, I ended up constantly checking, fixing, and worrying about things that were supposed to be automated.

It honestly felt worse than doing everything manually.

At some point I realized: the issue isn’t building workflows it’s that they aren’t reliably runnable without supervision.

That thought stuck with me, so I tried building something small for myself. Just a way to define a flow once and not have to keep checking it.

The first version wasn’t great. It broke a lot. I almost dropped it.

But even then, it reduced how often I had to step in and that alone made a difference.

So I kept improving it. Not by adding more features, but by focusing on one thing: making sure things actually run the way you expect them to.

Eventually I let a few people try it. One of them said, “I didn’t feel the need to check on it.”

That’s when it clicked.

That small shift not having to constantly look over your shoulder — is what I was trying to fix.

That’s basically how something like Runable came to exist.

It’s still a work in progress, but if something runs in the background now and I don’t even think about it, that feels like a win.

Curious if others have run into this do you actually trust your automations to run without checking them?