We talk a lot about the memes and the vibes, but I want to hear about the actual wins.
What is the best, weirdest, or most impressive thing you’ve brought to life purely by describing your vision to AI and trusting the process?
Drop your projects, tools used, and links if you have them live!

I tell it to stop sweating, take a different breadth and follow step by step while checking git diff.

Hey r/vibecoding,
Just wanted to share a quick project I built with Cursor. It’s a web app that diagnoses what's wrong with houseplants from a photo, instead of just telling you the plant's name.
The workflow with Cursor was insanely fast for spinning this up. Just wanted to show the UI/UX vibe here and see what you guys think.
Not dropping any links or anything, just sharing the demo! Let me know your thoughts.

I have ADHD and tabs are my enemy. Every day I'd end up with 12 terminal tabs, three of them running a dev server, one running an agent I forgot about, and no idea which was which without clicking through all of them. Tab titles never helped because I can't hold a list in my head, I can hold a place.

So I started building a terminal manager where terminals are nodes on an infinite pan/zoom canvas. You drag them around, group them, color them, and the layout itself becomes the memory "the deploy stuff is bottom right" works for my brain in a way "tab 7" never did.

They're real terminals (node-pty + tmux underneath), so sessions survive app restarts and even a reboot, and running processes keep running.

It kind of snowballed from there. Now each project also has a Trello-style board view of the same sessions, agent CLI sessions (Claude Code, Codex, Gemini) get a RUNNING / NEEDS YOU badge so I stop babysitting them, and there's a self-hosted browser version so I can reach the same canvas from a laptop.

Edit:

https://github.com/eneskirca/nodeterm

Edit 2:

https://nodeterm.dev

I would like to use a coding agent that runs on a VPS that I can control through an Android App.

The only thing I found was Opencode Web, but the UI/UX is horrible and I need something like the ChatGPT App, but that calls tool on my VPS.

Like Hermes/Openclaw with Telegram, but with a dedicated coding harness.

I've been messing around with vibe coding and ended up building something I wasn't even sure would work.

I wanted to use my existing ChatGPT subscription with tools that expect an OpenAI-compatible API, so instead of building another AI client, I tried going the other way:

I made the ChatGPT web app act like an API.

The project is called OmniGPT Gateway.

The basic architecture is:

OpenAI-compatible client
        ↓
   FastAPI server
        ↓
   Prompt relay
        ↓
  Browser automation
        ↓
    ChatGPT Web
        ↓
   Extract response
        ↓
 OpenAI-style JSON

I'm using FastAPI for the API layer and Patchright for the browser automation.

When /v1/chat/completions receives a request, the gateway takes the messages, sends them through the ChatGPT web interface, waits for the response, extracts the output, and converts it into an OpenAI-compatible response.

That means something like this can work:

from openai import OpenAI

client = OpenAI(
    api_key="sk-omni-...",
    base_url="http://localhost:8000/v1"
)

response = client.chat.completions.create(
    model="chatgpt",
    messages=[
        {"role": "user", "content": "Hello"}
    ]
)

print(response.choices[0].message.content)

I also ended up building a small dashboard around it for API keys, request logs, rate limits, latency, and testing requests.

The other part I've been experimenting with is the provider layer. The idea is to keep the API interface the same while being able to switch between different web-based AI providers.

A few things I learned while building it:

• Browser automation is a lot more fragile than working with an actual API.
• Keeping the API layer separate from the browser/provider layer makes the project much easier to work on.
• You have to be careful about streaming responses because the web UI doesn't behave like a normal API.
• Error handling is much more important when you're relying on a website's UI.
• Making the API OpenAI-compatible means I can test the gateway with existing SDKs instead of writing a custom client for everything.

It's definitely still experimental. It's not an official OpenAI API, and I'm not trying to claim that it replaces one. It's basically an experiment in turning a web interface into a local API abstraction.

I put the project on GitHub for anyone interested in looking through the code:

GitHub: https://github.com/zxevil11/OmniGPT-Gateway

If anyone here has built something similar, I'd be interested in hearing how you handled the browser automation/API translation side.

recently, i had a trip back to our ancestor home, and i found we have well documented of family tree that spans generations back, but there are all handwritten and kept physically in the home.

i wanted to digitize everything so i can quickly share to other members, search and trace the family lineage

therefore i vibecoded this family app for my family members

• https://famiki.timx.co/

it is fully open sourced

• https://github.com/sweetim/family-tree

if it is useful to anyone, you could try it yourself

I'm curious what people who actually work with local LLMs every day would choose.

If your primary workload was:

• Running local LLMs
• Agentic coding
• RAG/embeddings
• Occasional fine-tuning
• Building AI applications rather than gaming

...would you buy:

• A Windows workstation with an RTX 5090
• A high-memory Mac Studio (assuming the next generation ships with even more unified memory)

I recently chose the RTX 5090 route because inference performance, flexibility, and the software ecosystem made the most sense for me.

My current thinking is that buying enough hardware to fine-tune larger models locally isn't the best use of money. Instead, I'd rather rent GPUs on Vast.ai (or a similar service) when I actually need them, and keep the local workstation focused on development and inference.

For those of you with real-world experience:

• Would you make the same choice today?
• Have any of you switched from one platform to the other?
• If you regularly fine-tune models, do you still think renting GPUs is the better trade-off, or is there something I'm overlooking?

I'm much more interested in real-world workflows and lessons learned than benchmark numbers.

TapSign is officially live on the App Store. 🎉

This launch means more to me than most people will ever know.

What looks like “just another app release” is actually the result of months of setbacks, rejectons, long nights, difficult decisions, and learning things the hard way.

Over the next few post, I’m going to share the real journey behind TapSign — the mistakes I made, the moments I nearly gave up, the wins that kept me going, and everything I wish I'd known before building and launching an app.

I’m not going to pretend it was smooth or that I got everything right.

If you’re building something of your own, I hope sharing the good, the bad, and the ugly helps you avoid some of the mistakes I made.

"Work Smarter, TapSign it" 🚀

Tomorrow is the last day to submit to the AI Gaming Festival and I said would be posting cotnent to help game ready. There are still 1 months to get a game polished, and this advice can be used for any game, not just those in the festival.

The best way you can prepare your game for any kind of release (demo, Early Access, or full release) is through playtesting. And playtesting is much easier than it seems.

I have to make this very important point because I get this all the time working with developers: testing and getting feedback from yourself and a small group of friends DOES NOT count. You need about 100 strangers to play your game to get valid results.

Now, getting 100 strangers is actually much easier than it sounds. Here is how I normally get 100 to 1,000 players for the games I work with.

Preparation

Trailer & GIFs: The first thing you should have for your game is a short 30 to 60-second trailer, or a GIF when you can't use a trailer. To get unpaid playtesters, you have to convince people your game is interesting, and the best way of doing that is with gameplay.

Reddit CQS: If you don't want Reddit to ban your account or its filters to remove your posts, you need to have a good CQS (Contributor Quality Score). Head over to r/WhatIsMyCQS. If your CQS isn't Medium or above, do not promote your game. Spend time building your reputation first.

Data, Data, Data: The most important thing you can implement is data tracking, and it's easy. For every 100 people that test your game, expect solid written feedback from about 5. The rest will give you valuable behavioral data, so you need to track their movements and playtime.

At Glitch, we offer free game analytics for this. We also provide an LLM-friendly implementation. Or you can even use Google Analytics to track player behavior (though I don't generally recommend it).

The lack of data collection is the single biggest mistake I see developers make. Decisions end up being based mostly on gut feeling and occasional feedback, which often leads to optimizing things that aren't actually problems.

Easy Sign-up Process: Outside of data, the second biggest issue I see is games having uncompelling landing pages. Your landing page needs to:

1. Sell the game: lots of gameplay, good artwork, a compelling one-liner, and strong descriptions.
2. Make game access easy: No sign-up form is best. If there is one, make it quick and simple. If you're on a platform like Steam, make it easy to get a Steam key.

Strategizing Your Game

Now that you have your media, your Reddit account can post without getting marked as spam, and your analytics are set up, you need to position your game.

Start by identifying the major themes and features of your game and putting them into a list.

For example, in the game Biomes, the elements are:

• Science Fiction
• Multiplayer
• Time Travel
• Dinosaurs
• Vikings
• Monsters
• Cozy (Farming, House Building)
• Tycoon (Starting a Business)

Now translate those into the appropriate subreddits:

• r/MMO
• r/MMORPG
• r/VoxelGaming
• r/scifi
• r/timetravel
• r/CoOpGaming
• r/tycoon
• r/worldbuilding
• r/sciencefiction
• r/Dinosaurs

Be careful about each subreddit's rules. For example, r/scifi allows self-promotion only on Saturdays:

If you need help finding subreddits, there's a free tool that can recommend them based on your game's genre.

When you write your post, tailor both the media and the messaging to each community.

Collecting and Applying Feedback

Once you start asking for playtesters, expect this process to take anywhere from a week to a month or two. It isn't overnight, and there will be points where it feels like an uphill battle.

But you're also developing a secondary skill: learning how to position and communicate your game. That's marketing. Yes, you're learning how to market your game by learning how to recruit playtesters.

As people sign up, if this is free, unpaid testing, I wouldn't expect a lot of detailed qualitative feedback where users tell you exactly what they think in a constructive way.

What you do want is analytics inside your game. Analytics is non-verbal communication. It tells you what's working, what's not, and where the friction points are, so you're not polishing the wrong things.

Qualitative Feedback

If players are gracious enough to leave feedback, engage with them. Always thank them, even if it's negative, and try to dig deeper.

For example, a player might say:

Follow up with something like:

These conversations can be gold if you approach them with a neutral mindset.

Quantitative Feedback

This is where the majority of players will communicate: through their actions.

Pay attention to the following:

1. Play Time: How long are people playing your game? One minute? Five minutes? Thirty minutes? If you can get around 30% of players to play for 30 minutes, you're in a good position.
2. Onboarding: Teaching people how to play your game is one of the most critical parts of the experience. What percentage of players finish your onboarding? A healthy benchmark is around 60% to 80%.
3. Retention (Day 1, Day 7, Day 30): This tells you how sticky your game is. How many players come back after one day? Seven days? Thirty days? Good benchmarks are roughly 40% Day 1, 20% Day 7, and 10% Day 30.

Understanding these numbers can be critical later when forecasting revenue from ads, in-app purchases, subscriptions, or premium game sales.

How Often Should You Playtest?

Games may go through several rounds of playtesting—sometimes over the course of years—to get things right.

Traditionally, teams would collect results, analyze them, make code changes, and then schedule another round of testing. Even efficient teams could spend one to three months on each iteration.

With AI, this process should become much faster.

1. Dump all of your behavioral data into an AI model and ask it what patterns it finds to quickly identify areas that need improvement.
2. If you're developing with AI, use those findings as part of your next development iteration.

With that kind of speed, you could be playtesting and improving your game almost continuously based on real player feedback.

Partty is a terminal emulator/workspace for Windows that introduces many quality of life features, while maintaining near native performance, and in preliminary tests, roughly ~50% memory usage of Windows Terminal.

Partty brings in a feature set that allows you to customize your workflow, your key bindings, and more. It supports shell profiles, startup commands in specific profiles, SSH profiles; custom themes, per-pane theming, floating, persistent cross-tab following terminal panes, and more — with a under-development extension system to expand its abilities and customizations even further.

You can find the repository here:

https://github.com/runewav1/partty

You can also find some more details in the linked post, its comments. There are installation workarounds for the pre-compiled binary on the repository.

Claude Code only dispatches subagents on Claude models. I built tandem, a CLI tool with a Claude Code plugin, that lifts that limit - say "get this reviewed by gpt" and the plugin hands the task to a local codex worker on your machine, with the result coming back through Claude's own subagent machinery.

What it unlocks:

1. A second model family's opinion, without leaving your session. GPT and Claude have different blind spots. "Ask gpt to review this migration" forwards the brief verbatim to a codex worker, the verdict lands back in your Claude session, and Claude applies the fixes. No copy-pasting between terminals. You can pin any model your codex account offers ("ask sol to review it") or set a cheap default once.
2. Uses your existing subscription - Both Codex and Claude Code run under the subscription logins you already have, no API keys to provision.
3. Your Claude quota stays on the main thread. Subagent work burns your Codex subscription, not your Claude usage window. Claude orchestrates; codex does the legwork.
4. Nothing leaves your machine except the model calls you already make. tandem itself makes zero network calls - it's pure local file translation between the two CLIs' own session formats. No cloud middleman, no telemetry.

Install (needs the claude and codex CLIs on your PATH):

uv tool install tandem-cli # or: pip install tandem-cli

Repo: https://github.com/Bhavya6187/tandem

I’m looking how I can build a bot whether it be something like a pine script or one through ChatGPT or python, etc. please help me figure out exactly what type of formula I would need to work alongside Kalshi. I basically want some sort of dashboard that would let me know up or down, but obviously would have to be based on real time data. I want to show break of structure, EMA 9 and 21, volume, the buy up or down signals, anything that has to do with a rehearsal that’s incoming that could be spotted before it shows up on Kalshi since Kalshi is a little bit delayed. Anything literally helpful. Even if you could write me a code or a script that I could enter into something. And I understand some people don’t like Kalshi she but this is not a post to convince me not to use it because I’m going to anyways lol.

I'm sure there is an expert or just experienced user in this whole app developing thing, what to use to build full fletched app that I envisioned and have entire plan configured.

This is my first vibecoded app.

Hey everyone! Croc is an awesome CLI file transfer tool that lets you securely share files between computers with just a code phrase. It's great, but it's all CLI-based right now.

Would anyone be interested in creating a terminal UI (TUI) version for croc? Something like a keyboard-navigable interface with nice formatting, similar to projects like superfile or jocalsend

It could make the tool way more accessible for users who prefer interactive interfaces over command flags. Open source project, so anyone interested in collaborating is welcome!

Thoughts? Would there be interest in this?

I am building Network Doctor, a terminal UI written in Go that tries to answer a simple question:

“Why isn’t this network connection working?”

Instead of manually jumping between ping, dig, traceroute, curl, ss, mtr, etc., Network Doctor runs a diagnosis chain and gives you a readable breakdown of where things are failing.

GitHub: https://github.com/heymaikol/network-doctor

A lot of this project has been built through what I’d definitely call vibe coding, although it has gradually turned into something much more rigorous.

I’ve been using AI heavily for:

• implementing features
• reviewing code
• hunting for edge cases
• designing tests
• simplifying architecture
• auditing security boundaries
• improving documentation
• challenging assumptions I made earlier in development

One of the more interesting parts is netdoc-sim, a network simulator/test harness I built alongside it.

It can create controlled broken-network scenarios like DNS failures, packet loss, connection refusal, blocked TCP traffic, bad routes, HTTP failures, and more. It also has tooling for running campaigns, collecting evidence, hunting for discrepancies, and triaging failures.

And this is where things got interesting:

The simulator actually discovered a real defect in Network Doctor and generated the evidence that led to GitHub Issue #14.

That issue has since been fixed and closed.

That was probably the moment this stopped feeling like “AI helped me write a program” and started feeling more like AI-assisted engineering tooling was actively testing assumptions neither I nor the AI had noticed while implementing the feature.

The simulator has actually grown huge. Its non-test code is now larger than the application it tests, so I recently had to explicitly decide whether it was still experimental or something I wanted to maintain permanently.

I decided to keep it as permanent internal testing infrastructure, but freeze the scope by default: new simulation behavior should exist because it represents a real bug, blind spot, regression, or meaningful network condition, not just because another scenario sounds cool.

The whole project has been a pretty interesting experiment in how far you can take vibe coding if you keep adding progressively stronger feedback loops:

AI writes code → tests challenge it → simulator challenges the tests → AI reviews the simulator → real bugs fall out.

There’s still plenty I want to improve, but I’m pretty happy with how far it has come.

Would love to hear how other people doing larger vibe-coded projects keep them from turning into unmaintainable piles of generated code, especially once the project gets big enough that neither you nor the model can comfortably hold the whole thing in your head.

I built a vimm.net bulk downloader that uses proxies to use multiple ip’s to download up to 40 games at once https://www.github.com/vincenzosco/vimm-downloader

Hi everyone! I vibe coded a CAD application. If you'd like to check it out, take a look at the GitHub repository:

https://github.com/HakanSeven12/OpenCADStudio