u/Consistent-Stock9034

I’ve got an opening in my schedule today and want to see what people are building.

Drop your link below with a quick sentence on what it does. I’ll actually sign up, click around, and give you honest, actionable feedback on the UX and first impressions. No fluff, just real eyes on your product.

I can only get through a handful of these today, so first come, first served. Let's see what you’ve got.

Right now, Claude Code is a brilliant mind trapped inside a fragile body: your local machine.

You ask it to build something complex and suddenly it’s fighting your local Postgres config, hanging on npm install, burning context windows debugging dependency issues, or failing because it can’t spin up a proper mobile emulator or GUI environment.

And when you want parallelism, testing multiple architectures, branching experiments, or handing work between agents, you’re stuck doing everything sequentially because your local environment isn’t forkable infrastructure.

Most AI sandboxes don’t really solve this either. They’re constrained and not designed for generalized agent-controlled compute.

I’m one of the builders behind Fleeks, and we’ve been working on an SDK that gives Claude Code its own actual computer.

Instead of executing locally, Claude can provision cloud containers through the SDK and fully control them through API calls.

A few things that ended up mattering way more than we expected:

• Docker-in-Docker support (almost nobody supports this properly)
• 25+ pre-warmed runtimes with sub-200ms startup
• GUI support via Xvfb/VNC for browsers, frontend previews, Flutter emulators, desktop apps, etc.
• Stateful workspace forking

The forking part is the real unlock.

If Claude wants to test 3 architectures, run RL workloads, or hand off work between agents, it can clone the exact workspace state, including files, processes, env vars, and running services, then execute branches in parallel without resetting the environment.

That changes the model from:

“AI generates code on your laptop”

to:

“AI operates its own persistent compute environment.”

Feels like a much bigger shift than most people realize right now.

There’s a free tier if anyone wants to experiment with the infrastructure. Happy to answer questions about the architecture or how we handle the Docker-in-Docker routing internally.

We weren't trying to build an infrastructure product. We were trying to build agents that actually worked in production and kept getting blocked by the same thing.

The agent logic was never the problem. The problem was everything around it. Keeping it alive. Giving it persistent access to the right tools without writing a custom integration for each one. Making sure that when it ran at 3am and something went wrong, it didn't just silently die and leave the system in a broken state.

We went through every combination of Docker containers, Lambda functions, managed services. Everything was either too fragile, too expensive to maintain, or required more engineering than the actual product we were trying to ship.

Eventually we stopped trying to bolt existing tools together and built the layer that was missing. That became fleeks. You build your agent locally, run fleeks promote, and it runs 24/7 on persistent infrastructure with native connections to AWS, GitHub, Postgres and the rest of your stack. No glue code, no servers to manage.

But I'm more curious about how others are tackling this because I suspect everyone has a different version of the same war story.

Are you self-hosting? Using a managed platform? Just keeping a VPS alive and hoping it doesn't crash? And if you've built something that actually works well, what made the difference?

Would genuinely love to compare approaches here. This feels like a problem the community hasn't fully solved yet and there's probably a better answer somewhere in this thread.

Building used to feel like this:

Have idea. Open editor. Wait for dependencies to install. Hit an error. Fix it. Wait again. Get it running. Try to test something. Wait for a build. Change one line. Wait for another build. Want to deploy it? Now you're on YouTube learning Docker at midnight.

You spend more time waiting and configuring than actually building the thing.

I got fed up and built Fleeks.

Here's what it actually does: you describe what you want to build in your terminal. It figures out the stack, loads the right languages and dependencies, and gets your local environment ready. You write the code, or you let your AI agent do it, and Fleeks handles the dev servers and testing in the background. When you're ready to ship, one command containerizes the whole thing and pushes it to managed cloud infrastructure. You get a live URL or an always-on webhook for your agents. That's it.

We've been running it with a few teams already. The part that surprised me most wasn't the deployment speed. It was how much cleaner the whole build loop felt when infrastructure wasn't the bottleneck. You actually stay in the problem instead of context-switching into DevOps mode every 20 minutes.

Still early, still rough around some edges. But it works.

If you've got something unfinished sitting around, bring your coding agent and test it. Free to start. Link in the comments.

If you get stuck, DM me directly.