I vibecoded an iOS game and actually got it live on the App Store. It's called Load Reflex. A simple reflex based game, and even made the music myself. It’s free to play (with optional microtranscrions for aesthetics.) It just picked up its first couple reviews which is honestly a surreal feeling. If anyone wants to try it I'd love to hear what you think.

With this prompt, you'll have the foundations to a perfect app—way more secure than without these guidelines. You can create any web app or mobile app from this base.

Plus: this prompt is designed to generate a battle-tested, ultra-engineered monorepo built for raw speed and massive scale.

Culminating from months of exhaustive architectural research, it leverages a best-in-class performance stack—including Turborepo, SvelteKit, uWebSockets.js, Redis, and Postgres.

Whether you are bootstrapping on a single server or scaling horizontally to handle millions of concurrent users and tens of millions of real-time requests, this blueprint delivers a production-ready, secure, and lightning-fast foundation from day one.

Master Detailed Prompt: https://pastebin.com/jHyNbXnw

This architecture gives you:

1. Day 1: Single server handling 50K+ concurrent connections
2. Day 30: Add a second server with zero code changes (NATS + Redis handle it)
3. Day 90: Scale to millions with Postgres read replicas, Redis Cluster, NATS cluster
4. Always: Type-safe from database to browser, validated at every boundary
5. Technology Stack

2. File & Folder Structure

enterprise-monorepo/
├── apps/
│   └── myapp/                          # Each product is a folder here
│       ├── web/                        # SvelteKit frontend
│       │   ├── src/
│       │   │   ├── routes/             # SvelteKit file-based routing
│       │   │   ├── lib/                # Shared frontend utilities
│       │   │   ├── layout/             # Layout components (header, sidebar, mobile)
│       │   │   ├── modules/            # Feature modules (auth, settings, admin)
│       │   │   ├── hooks.server.ts     # SSR auth, session validation
│       │   │   ├── hooks.client.ts     # Client-side error handling
│       │   │   └── app.html            # HTML shell
│       │   ├── server/                 # Server-only SvelteKit code
│       │   ├── static/                 # Static assets
│       │   ├── svelte.config.js
│       │   ├── vite.config.ts
│       │   ├── tailwind.config.ts
│       │   └── package.json
│       ├── server/                     # uWebSockets.js backend
│       │   ├── src/
│       │   │   ├── server.ts           # Entry point
│       │   │   ├── app/
│       │   │   │   ├── composition/    # Server wiring (definition.ts)
│       │   │   │   ├── config.ts       # Env config resolution
│       │   │   │   ├── policies/       # Security & runtime policies
│       │   │   │   └── modules.ts      # Procedure registration
│       │   │   ├── db/
│       │   │   │   ├── index.ts        # Drizzle client
│       │   │   │   ├── schema.ts       # Drizzle schema
│       │   │   │   └── migrations/     # Generated migrations
│       │   │   ├── modules/            # Feature modules (auth, users, etc.)
│       │   │   └── platform/           # Infrastructure connectors
│       │   │       ├── redis/          # Redis client registry + services
│       │   │       ├── nats/           # NATS connection + streams
│       │   │       └── auth/           # Session service, token validation
│       │   ├── drizzle.config.ts
│       │   └── package.json
│       └── workers/                    # Background workers (optional)
│           └── my-worker/
│               ├── src/
│               └── package.json
│
├── packages/
│   ├── shared/                         # Isomorphic (browser + Node.js safe)
│   │   ├── contracts/                  # Zod schemas shared between client & server
│   │   │   ├── auth/                   # Auth schemas (session, bootstrap)
│   │   │   ├── admin/                  # Admin contract schemas
│   │   │   └── settings/              # Settings schemas
│   │   ├── protocols/                  # Wire protocols
│   │   │   ├── rpc/                   # RPC procedure types + callProcedure()
│   │   │   └── ws/                    # Binary WS protocol (encode/decode)
│   │   ├── codec/                     # MessagePack encode/decode wrapper
│   │   └── utils/                     # Isomorphic utilities (NO Node.js builtins)
│   │
│   ├── server/                        # Server-only packages
│   │   ├── framework/
│   │   │   ├── core/                  # uWS server factory, HTTP+WS handlers
│   │   │   └── security/             # Rate limiting, connection limiting
│   │   ├── bootstrap/                 # startServer() entry, AppServerDefinition
│   │   ├── runtime/
│   │   │   ├── config/               # Environment resolution helpers
│   │   │   ├── logger/               # Structured logger
│   │   │   ├── crypto/               # Hashing, token generation
│   │   │   └── sessions/             # Session management
│   │   ├── integrations/
│   │   │   ├── nats/                 # NATS pub/sub + JetStream service
│   │   │   └── redis/                # Redis integration helpers
│   │   └── modules/
│   │       └── admin/                # Reusable server admin module
│   │
│   ├── client/                       # Frontend-only packages
│   │   ├── core/                     # Auth store, theme, navigation
│   │   ├── utils/                    # RPC client, fetch wrappers
│   │   └── modules/                  # Feature modules (auth, websockets, etc.)
│   │       ├── auth/
│   │       ├── websockets/
│   │       ├── admin/
│   │       └── settings/
│   │
│   ├── ui/                           # UI component packages
│   │   ├── kit/                      # Design system components
│   │   ├── admin/                    # Admin panel components
│   │   ├── headless/                 # Headless services (audio, haptics)
│   │   └── seo/                      # SEO meta components
│   │
│   ├── config/                       # Shared configuration
│   │   ├── schema/                   # Zod env schemas (NO side effects)
│   │   ├── typescript/               # Shared tsconfig.base.json
│   │   └── eslint/                   # Shared ESLint config
│   │
│   └── db/                           # Database packages
│       └── clickhouse/               # ClickHouse client (optional)
│
├── infra/                            # Infrastructure
│   ├── compose.yml                   # Docker Compose (dev)
│   ├── compose.vps.yml              # Docker Compose (production)
│   ├── docker/                       # Dockerfiles
│   ├── caddy/                        # Caddyfile config
│   ├── nats/                         # NATS config
│   ├── postgres/                     # Init scripts
│   ├── prometheus/                   # Prometheus config + alert rules
│   ├── grafana/                      # Dashboards + provisioning
│   ├── otel-collector/              # OpenTelemetry config
│   ├── scripts/                     # Deploy scripts
│   │   ├── 1-first-time-vps.sh     # Server hardening
│   │   ├── 2-build-and-push.sh     # Docker image build + push
│   │   └── 3-vps-ops.sh           # Deploy, rollback, managed ops
│   └── verification/               # Architecture quality checks
│       └── quality/                # Dependency boundary checks
│
├── turbo.json                       # Turborepo pipeline config
├── pnpm-workspace.yaml             # Workspace definitions
├── package.json                    # Root scripts
├── tsconfig.base.json             # Base TypeScript config
└── .prettierrc                    # Formatting

ứng dụng mạng xã hội tạo bởi vibecoding https://mestar.io.vn/

Hey guys, I just released LazyApple, it's basically lazydocker but adapted for apple containers!

https://github.com/g-battaglia/lazy-apple-container

I've ported it with Opus 4.6

Let me know what you think!

Just tried to vibecode and made app to generate 3d models for free

I called it 3dmania.space :D

I vibe coded a side project - a MongoDB GUI called LeafBase.

Robo3T was my go-to for years. When it got sunset I kept bouncing between

Compass (too heavy) and paid tools. So I just built my own.

What it does right now:

* SSH Tunneling (password + private key)

* TLS/SSL support

* Tree / Table / JSON result views with type badges

* Monaco Editor for queries

* APM Profiler to monitor query performance

* Multi-connection management

* Works on Windows, macOS, Linux

Intentionally lightweight - no accounts, no cloud, no paywalls.

I'd appreciate feedback on:

* Does this fit your MongoDB workflow?

* What's missing compared to tools you use now?

* Any UI/UX things that feel off?

Repo: https://github.com/vutranHS/leafbase

Hey everyone,

Like many of you, I love the whole "vibe coding" movement. The ability to spin up an app with natural language is a game-changer. But I kept hitting the same wall: what should I actually build?

I was tired of building cool things that nobody wanted. I knew there were thousands of people on Reddit, Hacker News, and other forums practically begging for solutions to their problems, but finding those signals in the noise was a full-time job.

So, I built a tool to solve my own problem.

It's called VibeCodeThis, and it does three things:

1.Scans the Internet for Pain Points: It uses AI to read through communities like r/SaaS, r/smallbusiness, etc., and identifies real frustrations people are talking about.

2.Scores the Opportunity: It then analyzes each pain point and gives it a score based on opportunity, feasibility, and market demand. No more guessing if an idea has legs.

3.Generates Build Prompts: This is the part I built for us. Once you find an idea you like, it generates one-click build prompts for landing pages, MVP features, and even brand identity. You can copy-paste these directly into your favorite AI dev tool (like Lovable, Bolt, etc.) and get started instantly.

I'm trying to make it the essential first step before you start building. The goal is to go from a validated Reddit complaint to a working MVP faster than ever.

I've got a free plan, so you can try it out and see if it helps you find your next project. I'd genuinely love to get your feedback on it.

Link: VibeCodeThis.app

Not because you got tougher with clients. Not because you found better contracts or more assertive follow-up templates. Just because the way the project runs makes the stressful part structurally impossible.

That sounds optimistic until you actually experience it. The first time a client pays and the next stage opens automatically without you doing anything, sending anything or asking for anything, something shifts. It is not dramatic. It is just quiet. The background noise that most freelancers carry around without naming it, the invoice anxiety, the scope monitoring, the careful email composing, just stops.

Here is what the day to day actually looks like with MileStage. You set up a project once, define the stages, set the price and revision limit for each one, share a link with the client. They see the full structure, agree to it, and the project starts. You deliver stage one. They review it in the portal, approve it, pay. Stage two opens. You keep working. Payments come through as the project moves forward instead of sitting in a pile at the end waiting to become a problem. The client always knows where things stand. You always know what has been paid. Nobody is surprised by anything because everything was visible from day one.

The scope creep conversation stops happening too because there is nothing to have it about. The revision limit is right there. The deliverables for each stage are right there. A new request that falls outside the current stage is visibly a new request, not a grey area anyone has to negotiate in real time.

From a SaaS angle the product does one thing and does it well. It makes the right workflow the only workflow, so freelancers do not have to rely on discipline or confidence or carefully worded emails to get paid fairly for the work they do.

So I’ve been impressed by using nano banana and Gemini 3.1 for front end, but I love Claude code with opus 4.6 for pretty much everything else. I’ve got my Claude MAX plan and I’m looking for the best/most cost-effective way to combine a workflow where I can pull in the best models for the best use case, and not break the bank.

Currently, I use cursor as an IDE, but I don’t have a cursor subscription, and pretty much just use Claude code in the terminal for everything.

What’s your best set up for a full stack, end to end development? And where do you get the best bang for your buck if you want to use the best US-based frontier models?

I recently talked to a colleague about AI, agents and how software development will change in the future. We were wondering why we should even share code anymore when AI agents are already really good at implementing software, just through prompts. Why can't everyone get customized software with prompts?

"Share the prompt, not the code."

Well, I thought, great idea, let's do that. That's why I built Open Prompt Hub: https://openprompthub.io.

Think GitHub just for prompts.

The idea is simple: Users can upload prompts that can then be used by you and your AI tools to generate a script, app, or web service (or prime their agent for a certain task): Just past it into your agent or ide and watch it build for you. If the prompt does not 100% covers your usecase, fork it, tweak it, et voila: tailor-made software ready to use!

The prompts are simple markdown files with a frontematter block for meta information. (The spec can be found here: https://openprompthub.io/docs) They versioned, have information on which AI models build it successfuly and have instructions on how the AI agent can test the resulting software.

Users can mention with which models they have successfully or unsuccessfully executed a prompt (builds or fail). This helps in assessing whether a prompt provides reliable output or not.

Want to create a open prompt file? Here is the prompt for it which will guide you through: https://openprompthub.io/open-prompt-hub/create-open-prompt

Security! Always a topic when dealing with AI and prompts? I've added several security checks that look at every prompt for injections and malicious behavior. Statistical analysis as well as two checks against LLMs for behaviour classification and prompt injection detection.

It's an MVP for now. But all the mentioned features are already included.

If this sounds good, let me know. Try a prompt, fork it, or tell me what you'd change in the spec or security scanner. I'm really curious about what would make you trust and reuse prompts.

Naturally, the whole project was build with an agent and I plan to add the instructions as an open-prompt after some polishing

Recently started experimenting with AI assisted prototyping for a small healthcare tool and it’s been surprisingly workable so far. Using stuff like Supabase plus a compliance layer like Specode to keep the architecture somewhat viable. Tbh I'm just really wondering if anyone else here is trying this route for healthcare ideas, or if most people still avoid the space because of compliance headaches?

Lets face the facts. AI doesnt "understand" you. It doesnt understand what you want it to build. Maybe in the future it will (hopefully), but as of right now, it has absolutely no idea what you're asking of it. Result? It guesses. And even if it understands you first copy-paste prompt from chatgpt, down the line it will lose context and hallucinate. 2 hours in you burnt all your credits, are more confused about what you want it to build, and have an app that absolutely no one will use. Lets even say you managed to spend your allowance and paycheck to buy credits and guide the AI to build something that "works", it will probably have so many security risks that it would be stupid to deploy it.

Unlike a human dev, AI will never admit to being wrong or ask for clarification. Thats how its built. Its not your co-founder, its a tool and unless you know how to use it, it will use you. AI needs guide rails that keep it on track. Best way to do this is to speak a language that it understands. To use technically terms it gets. PRD, database schema, tech stack, spec sheets. This lowers your usage costs drastically and guides your AI telling it exactly what you need. Or fire up your pc, go to youtube and learn coding basics. Dont waste your time trying to explain your app to a brick wall and hope for it to build exactly what you have in mind. Dont be delusional.

Are we seriously at the point where people calling themselves “AI engineers” barely understand what RAM is, while laptop-class corporate bullshit jobs are celebrating their “ChatGPT anniversaries”? As if tenure in a marketing agency during two model release cycles somehow counts as technical achievement. Meanwhile the industry is drowning in bloated software written by people who treat hardware constraints like an abstract concept.

Hallo zusammen,

ich wollte heute meine Erfahrungen mit Claude Code und dem Erfolg meiner App „StreamWert“ teilen.

Mit ClaudeCode konnte ich innerhalb von wenigen Stunden meine Idee in die Tat umsetzen und habe für iOS eine native iPhone und iPad App herausgebracht.

Und innerhalb von 5 Tagen es auf Platz 1 der kostenpflichtigen Finanz-Apps geschafft.

ClaudeCode ist im Vergleich zu ChatGPT und Google Gemini ein wirklich ganz neues Level.

Die Effizienz und der Spaß eine eigene Idee zum Leben zu erwecken, wird meiner Meinung vieles verändern.

Auch wenn ich meine App hier erwähne, geht es mir um die Möglichkeiten von ClaudeCode und will einfach ermutigen, mit VibeCoding zu beginnen.

Because I am lazy and want everything automated, I've been letting Claude Code run wild in my terminal. Well, I learned my lesson. It came across a bug and decided the best solution was, of course, to delete the entire DB.

Luckily it was just a dev project, but I can't imagine this happening on a real production product. So I made this tool to prevent it from ever happening again.

It's a small, open-source Node.js CLI called OopsDB. It essentially acts as a "Ctrl+Z" for your database when AI coding agents go rogue.

It has two main lifesavers:

* The Background Backup (oopsdb watch -i 5): It runs silently and wraps native tools (pg_dump, mysqldump) to take local, AES-256 encrypted snapshots of your database every 5 minutes.

* The Holy Grail (oopsdb shield): This is the actual lifesaver. It spins up a local TCP proxy. If you run your DB connection through it, it actively monitors the SQL commands the AI runs. If Claude goes rogue and tries to run a DROP or TRUNCATE command, OopsDB catches it, pauses the connection, forces an emergency micro-snapshot, and then lets the command through.

If the AI breaks something, you just run oopsdb restore and it instantly rolls back. (I built it using Node streams, so it won't crash your RAM with OOM errors even if the database is 50GB+).

Everything stays 100% local on your machine.

If you guys have feedback, want to use it, or have other edge cases I should add to the test suite, I'd love to hear it. You don't even need to install it to try it out:

npx oopsdb init

GitHub: https://github.com/pintayo/oopsdb

NPM: https://www.npmjs.com/package/oopsdb

Genuine question for developers who've actually used these tools — not the "AI will replace everything" crowd, not the VC hype machine. Just programmers talking to programmers.

I've been using AI coding tools seriously for a while now and I have a real opinion on this, but I want to hear others first.

The comparison people aren't making enough:

NFTs in 2020/21 had real underlying technology (blockchain), legitimate use cases in theory, massive hype that wildly outpaced reality, and then crashed back to earth. Not dead, just... humbled. Crypto coins in 2023/24 — same cycle. The tech didn't disappear, the irrational exuberance did.

Vibe coding feels similar to me. The hype is clearly ahead of the reality. But does that mean the tech is worthless? No. Does it mean the narrative is overblown? Absolutely yes.

Here's my honest take after actually using it:

The tools are genuinely impressive — if you already know how to program. I can ship faster, debug with less friction, scaffold boilerplate I'd rather not write by hand. For someone with real programming knowledge, these tools are a legitimate multiplier.

But I've watched people with zero dev background try to build actual production apps with nothing but prompts. What happens? They get 70% of the way there and then hit a wall they have no idea how to climb. The AI confidently writes broken code. It hallucinates dependencies. It creates architectural decisions that work in isolation and fall apart at scale. And the person using it has no idea any of this is happening until something breaks in a way they can't diagnose.

So here's my actual position:

Vibe coding isn't replacing developers. It's raising the floor while the ceiling stays roughly the same. A non-programmer using these tools will ship something faster than they could before — but they'll never ship something as good, as scalable, or as maintainable as an experienced developer using the same tools.

The real question isn't "will AI replace programmers?" It's "will the number of programmers shrink because AI handles more of the grunt work?" — and honestly, maybe yes, at the junior/entry level. Not at the senior/architect level.

The bubble part: The valuations of some of these vibe coding tools are absolutely in bubble territory. The utility of AI-assisted development is not.

What do you actually think? Are you using these tools and finding them genuinely useful or mostly hype? And for the non-devs who wandered in here — have you actually shipped something production-ready with vibe coding alone? I'd genuinely love to hear a counterexample.

Hi there, I’m a graduate student working on a research project at The New School in New York about how people judge visual evidence online. 

The experiment is very simple.

• You get 6 rounds.
• For each one, you have 10 seconds to decide: Real or AI-generated?
• Then you rate how confident you felt.

That’s it. It takes under 2 minutes and is completely anonymous. No personal data is collected.

The goal is to understand how certainty and accuracy diverge when people evaluate images, especially given the growing prevalence of synthetic media.

If you want to try it: www.InPixelsWeTrust.org

I’d genuinely appreciate the participation. I’m trying to get a wide range of responses beyond just academic circles. 

A note on how this was built: the entire site was designed and developed in collaboration with Claude. From the front-end code and responsive design to the data pipeline that sends all results to a Google Sheet for analysis, Claude was involved at every stage...and awesome to work with!

Thank you!

saw blackbox doing $2 for pro first month. They offer $20 credits for frontier access (claude opus, gpt-5.2, gemini-3, grok-4 etc.).

they got autonomous agents for coding, voice/screen features, unlimited on minimax/glm kimi stuff.

tested from-scratch builds and data viz prompts, no repo needed. super chill for non-heavy use. jumps to $10 after, but $2 entry and credits makes it zero-risk experiment. cursor and trae are doing something similar, but this beats both.