r/vibecodingcommunity

So I’m obsessed with debate, I’ll be honest, and I’ve noticed, as I’m sure we all have, that discourse in recent years has gotten really toxic.

It’s either a dogpile, throwing insults, being condescending, I don’t need to rehash what I imagine we all already know.

I built an app where people could swipe on topics, get matched with someone who disagrees, and get a score on their civility. The idea was that if you’re always an asshole, your shitty civility score would follow you and no one would want to talk to you.

I added a feature in passing called toxic mode that did not judge your civility. Spew your venom, no holds barred.

That was the idea.

Every time I got an install on the app, every single user immediately jumped into toxic mode. Out of 100+ downloads, not a single person wanted to have a civil discussion. They wanted the messy version. The heated version. The version that felt more like a chaotic internet argument than a polite debate club.

So I stopped fighting it and built a lightweight browser version where you can just pick a topic and jump in:

https://thinklavender.com/ragebait

The goal is still to get people talking to people they disagree with. Maybe the first step is not making everyone perfectly civil. Maybe it is just getting them in the same room.

And if that room has to be a little toxic to get people through the door, so be it.

Would love feedback on the idea and whether this feels like something people would actually try.

character created by me and environment downloaded from sketchfab

Try it for yourself if you have characters you made on Meshy or Tripo3d, or download a character from sketchfab for free and pop it in the viewer and if it has walk or run animations they will work. https://glb-game-environment-sandbox-362548902392.us-east1.run.app

Let me know what you think or if you think I should add something drop a comment or shoot me a message

Working with agents got to be sexier. GitCity lets you visualize the agents working on your codebase, live.

Try it here: https://gitcity.in

Early Access: To directly use it on your codebase, DM me.

Story: Me and my roommate, both designers and vibe code enthusiasts, have always felt there was a better way to interact with agents. We built GitCity to be able to 'feel' a codebase being edited. It is superfun to finally get a visual sense of all your code, especially given we don't look at it anymore. If anyone feels disconnected from their code lately, this one might be for you.

The more complex the repo, the more beautiful the city. Can't wait to see people's repos with GitCity!

r/StableDiffusion, r/comfyui, r/Cursor, r/SideProject

TL;DR: Paid Cursor workspace + Python pipeline for character libraries. One identity file, each new pose chains from the last registered image, outfits dress the reference instead of redrawing. Includes 7 characters with real PNGs. No cloud API — GenerateImage runs in your Cursor subscription.

---

I kept running into the same problem:

• New prompt → new face
• New pose → outfit breaks
• New angle → accessories vanish

So I stopped treating every generation as a fresh character and built a character library workflow instead.

What it actually does

AI Character Production System — create one character once, reuse it forever. http://mskt.gumroad.com/l/jygfmp

Not another image generator. A repo you open in Cursor:

• One identity file (SSOT) — species, materials, proportions locked in YAML
• Pose chaining — each new pose builds from the last registered active.png
• Outfits — dress the reference, don't redraw from scratch
• One change per generation — pose or outfit or angle, not all three at once

Outputs are yours to take anywhere:

• YAML prompts → paste into Midjourney, ComfyUI, Flux, etc.
• active.png per pose → img2img, video, your own app
• Pick front / side / full body so accessories stay coherent

What's in the bundle

Piece	Detail
Cursor workspace	Slash commands: /new-character, /add-new-pose-hamster, /character-pose-grid, …
Docs + agent rules	Step-by-step workflows, not vibes
Python pipeline	Register, lint, 59 tests — scripts never call a model API
Image gen	GenerateImage in Cursor — your subscription

7 ready-made characters (real YAML + PNGs, not empty scaffolds):

• hamster — 15 images (richest example: poses + outfits)
• stork — 10 (costumes)
• frog, lion, tiger, tanned_girl — 9–13 each
• scooter — 3 (minimal bootstrap)

Totals: 7 characters · 55 pose prompts · 69 canonical PNGs · 92 saved generations · 11 pose grids

What it's not

No kitchen scenes, full compose pipeline, cloud hosting, or unlimited auto-gen. Character libraries only — by design.

Day one in Cursor

Paste this after opening the folder:

> Get familiar with this project. Read README.md and AGENT_START_HERE.md, then start creating new characters or experiment with the existing ones.

Disclosure

This is a paid bundle I'm selling (Gumroad / store link in comments). I'm sharing because character consistency comes up constantly in these subs and I wanted to show the approach, not drop a link with zero context.

Happy to answer workflow questions in comments — even if you never buy it. What do you use today for keeping characters consistent across poses?

I’ve been working on Curion, a memory system for AI agents built around a simple idea:

The main agent should not have to manage memory manually.

Most AI agents are useful inside a single session, but they still lose important context between sessions. Project decisions, implementation history, constraints, unresolved tasks, and previous reasoning often disappear unless I manually write long handoff notes.

At first, the obvious solution seems to be giving the agent memory tools: save, search, update, delete, edit.

But that creates a second problem.

If the main agent has to manage memory by itself, it can easily receive too many raw memories. Some are relevant, some are stale, some are only partially related, and some may conflict with newer information. The agent then has to spend context and attention deciding what matters.

That creates context bloat.

Curion takes a different approach.

I think of Curion as a librarian for AI agents.

A good librarian does not just throw every possibly related book at you. They understand the question, know how information is organized, filter what matters, notice conflicts, ask clarifying questions when needed, and return the most useful context.

That is what Curion is meant to do for agent memory.

The main agent only needs to say:

“I want to remember this.”

or

“I need to recall something about this.”

Curion handles the rest.

When saving memory, Curion can decide how information should be stored, whether it relates to existing records, whether something should be updated, and whether a conflict requires clarification.

When recalling memory, Curion does not just dump raw search results into the agent’s context. It retrieves relevant records, evaluates what is useful for the current task, synthesizes the context, and clearly says when nothing relevant was found.

The analogy I use is human memory. When we want to remember something, we do not consciously search through billions of memories. We ask for what we need, and the relevant memory appears automatically beneath the surface.

Curion is built around that same interface idea for AI agents.

It is project-first: Curion focuses on the project the agent is currently working in. It can also use cross-project recall when information from another project is actually relevant.

Curion is not just a save/search tool. It is a collaborative memory layer: a specialized memory librarian that helps agents remember responsibly, reduces context bloat, and gives the main agent only the context it actually needs.

GitHub: https://github.com/geanatz/curion

NPM: https://www.npmjs.com/package/@geanatz/curion

Portfolio: https://geanatz.com

Hey everyone!
I'd like to share a project I've been working on, it's called Orin and it's a coding agent.

I use coding agents constantly, and at some point I realized I had basically no idea what was happening between me hitting enter and code showing up.

Also I was tired of building apps I wasn't able to really debug because I didn't know how they were being built in the first place so I got busy studying: read a bunch of articles, still felt like a black box, so I just tried to build one.

Couple things worth saying before anyone digs in:

It's mostly AI-written code, no point in hiding that, but I don't think "written by AI" and "sloppy" have to go together.

I try to run all my projects in the most professional way I know of, following actual SDLC practices: spec first, then an issue, then the implementation, then a real PR review before anything merges, not vibe-coding where you just accept every diff.

Whether that shows in the actual code is for other people to judge, not me.

Also this isn't some original idea I came up with: I cloned and read through pi.dev, nanocoder, and opencode as primary references (and skimmed Cline/Kilo Code for patterns), and basically tried to take what made sense to me from each and put it into one implementation.

My whole idea was try and build something that took the best from each to make a coding agent that would perform well. I plan to benchmark it on SWE-bench Verified sooner or later, but I don't think it's ready just yet: there are rough edges and bugs, but its usable.

Some of the actual implementation stuff, for anyone who cares about those rather than the pitch:

• The loop is just: stream a response from the provider, push it to message history, if there are tool calls run them, push the results back, repeat until there's nothing left to call.
• The loop is completely headless — it doesn't touch the terminal, it just emits events. The TUI (SolidJS on top of OpenTUI, just like opencode) is a separate subscriber to those events. You could swap in a totally different frontend without touching the loop at all.
• Another thing I got from OpenCode are edits: they go through a fuzzy replacer chain, not a single exact string match — if the model's oldText is off by whitespace or indentation, it falls through a chain of matchers before giving up. I had never thought about this and can confirm it's the kind of thing you don't appreciate until you actually try to implement it.
• There's a model routing mechanism that switches different models based on what the agent has to do:
  • explore runs on a cheap/fast model by default,
  • implement on a code-tuned model,
  • review on the main model.
• Another thing I borrowed from the web is a delegate_read tool that lets the main agent hand off read-heavy grunt work (scanning a big file, summarizing logs) to a cheap model so that content never bloats the main context.
  • It's basically a one off LLM call that only returns a distilled summary, seems dumb but works surprisingly well with capable models like Claude who know exactly what to look for and delegate super well to other agents.
• Tool selection isn't a static allow-list. Every turn runs a BM25 retrieval pass over the full tool catalog (including MCP tools) via a super cool library called Ratel, so the model only ever sees the tools relevant to what it's doing in that specific turn instead of the whole catalog every time. There's even an A/B flag to compare tool_pool=ratel vs tool_pool=default in your own telemetry to see if it even makes a difference (similar to how rtk gain works).
• Every file write gets snapshotted into a shadow git history before it happens, including stuff done through raw bash — allowing the agent to have a proper /undo /redo command.
• When I implemented subagents I wanted to explore different isolation mechanisms and ended up with 3 different ones you can configure yourself:
  • shared (edits land on the main working tree, safe because they run serially),
  • worktree (isolated branch)
  • sandbox (a real E2B cloud VM, edits get thrown away on dispose — for code you don't trust at all).
  • The lead model can escalate isolation for a given task but never go below the configured floor.
• I implemented hooks borrowing from nanocoder and opencode. This allows the agent to be expanded by third party code and I bundled some sensible defaults:
  • there's a before_tool hook that rewrites bash commands through rtk so that command output gets compressed before it ever reaches the model.
• In my daily work I build AI agents and vibe coded internal tools for my company and after a while I saw how much telemetry is crucial for debugging and actually understanding agent behaviour, so I decided that my agent would ship native OTLP tracing by default.
  • This means that by adding just one environment variable you can see full traces in your telemetry platform (Langfuse, Tempo, Jaeger, whatever you like) out of the box.
• Orin is also provider-agnostic (currently supports OpenRouter, OpenAI, Anthropic, OpenCode Go/Zen and Regolo if you want an EU-hosted option) — switching provider or model happens at runtime through a provider registry, no restart needed.

None of this is groundbreaking, it's just what I landed on after reading other people's code and deciding what to keep.

Try it:

git clone https://github.com/thetombrider/coding_agent.git

cd coding_agent

./install.sh

orin

There's also a deepwiki writeup if you want the architecture without reading source: https://deepwiki.com/thetombrider/coding_agent

I would really appreciate feedback in any shape or form. I'm learning and sharing my journey, hope it helps someone.

hey — i vibe coded something over the last stretch and put it in public beta.

it's called **murm** (always lowercase). idea is simple: say the stuff you wouldn't put on your real name. no profiles to flex, no downvotes, just quiet posts + "felt" / "same" reactions + opt-in whispers.

live at: https://murm.space

honest status:
- public beta
- guest login works (no phone required for now)
- UI is rough in places
- things will break
- i am not pretending this is finished product

i built a lot of it with AI in the loop (vibe coded, not a 10-person eng team). it works enough to use, not enough to brag about.

if you're into:
- product / design
- backend / security
- moderation / trust & safety
- or just "i'd use this and have opinions"

…drop a comment or DM. not looking for free labor speeches — looking for people who actually want to shape it.

if you try it: be kind in the feed, report anything weird, and tell me what feels off. especially the onboarding and reactions.

it's called **murm** (always lowercase). idea is simple: say the stuff you wouldn't put on your real name. no profiles to flex, no downvotes, just quiet posts + "felt" / "same" reactions + opt-in whispers.

live at: https://murm.space

honest status:
- public beta
- guest login works (no phone required for now)
- UI is rough in places
- things will break
- i am not pretending this is finished product

i built a lot of it with AI in the loop (vibe coded, not a 10-person eng team). it works enough to use, not enough to brag about.

if you're into:
- product / design
- backend / security
- moderation / trust & safety
- or just "i'd use this and have opinions"

…drop a comment or DM. not looking for free labor speeches — looking for people who actually want to shape it.

if you try it: be kind in the feed, report anything weird, and tell me what feels off. especially the onboarding and reactions.

Just launched the first version of a vibe-coded travel site for curated trips to Turkey:[https://letsgotürkiye.com/\](https://letsgotürkiye.com/)

Looking for brutal feedback on what to fix, what to polish, and any creative ways I can use AI/Claude to push the interactive design further. Let me know what you think!

I've spent the last few months building something and I'm finally at the point where I want to share it properly rather than just quietly hoping people find it.

The idea came from a frustration I kept seeing (and feeling myself): SQL tutorials teach the syntax fine but there's never a reason to care about the answer. You filter a table called employees, get a result, and nothing happens. Your brain doesn't bother keeping it.

I wanted to try a different approach. QueryCase teaches SQL through detective investigations. You get a briefing from Chief Fox (our mascot), a real database to query, and a mystery to crack. The JOIN matters when a suspect has an alibi. The WHERE clause matters when you're trying to find who entered the building at 22:13. The SQL is the tool for solving something, not the point in itself.

Here's what's actually in it:

• A structured learning path across 54 cases, going from Recruit through Rookie, Detective, Senior Detective, and Chief Detective. Each rank has drills and a level exam to pass before you progress.
• Sandbox mode where you can explore real datasets (IMDB movies, Spotify, sports stats, Steam games) and run whatever you want with no pressure and no mystery attached. Just free exploration against actual data.
• Everything runs in the browser using DuckDB WASM so there's nothing to install.

I'm a solo developer and this is genuinely early days. I'm sharing here because this community is exactly the kind of people I built it for, and I'd rather get honest feedback now than find out later I've built the wrong thing.

What's missing? What would make you actually stick with something like this versus what you've used before?

querycase.com if you want to take a look.

Any feedback appreciated!

Been thinking about the earliest stage problem for a while: you've launched something but have zero traffic and zero budget to get it.

Ads are expensive. Cold outreach feels gross. SEO takes months.

So I built something stupid simple a bar that sits at the top of your site showing another founder's startup. In return, your startup gets shown on theirs.

One line of code. No cost. No algorithm. Just founders helping founders get their first eyeballs.

Called it StartupBar. It's completely free, probably always will be.

Would love feedback from this community does this actually solve a real problem or is it a solution looking for one? Also curious if anyone here has tried similar traffic exchange approaches and what worked / didn't.

I built TestLaunch because I keep seeing Play Store developers posting that they need testers, feedback, or people to join their testing links.

TestLaunch is a free place to list your app, share your testing link, and let testers find projects that need help.

You can add your app name, platform, category, test duration, contact email, description, testing link, and what kind of feedback you are looking for.

The goal is simple: give Play Store developers one clean page to share instead of chasing scattered tester posts everywhere.

It is brand new, so feedback is welcome.

https://tipitylabs.online

Me at 2am, I just closed my laptop, I can't sleep

🤔... Why did I vibe code this on my phone? 😭😂

My current setup is proot-distro Ubuntu + freebuff...

So it all started with a guy asking if we can get the Gmail access.

I looked into it, spent 5 months, spent $1500+ dollars in getting security clearance, hours of man efforts and finally the application is out.

The fun part, I lost that linkedin post and the guy.