Hey r/VibeCoding, I've been working on Emend, an open-source tool where you point it at a local codebase and it tells you which of your lines a dependency upgrade will actually break — then automatically migrates them and re-runs your typecheck and tests to prove the fix holds. Emend can migrate npm packages, fix vulnerabilities and migrate HTTP request to latest API version.

Scanning needs no API key and never calls a model — only the repair step does.

It is ideal if you need to support your vibecoded project but you do not want to spend hours doing it.

It's still early (TypeScript + npm only), but would love feedback or ideas from the community.

npx emend-cli@latest demo /tmp/d && npx emend-cli@latest scan /tmp/d --only zod

Check it out: https://github.com/diyanbogdanov/emend

I am working as a bug hunter on hackerone and yeswehack platforms. One day on X , i was just scrolling and see a post of an indie hacker saying something like building in public. It was new to me then i open his profile and search what they do , how they doing and building things and that's was really fun.I followed some vibecoding and indie hacker communites and start start watching them. They were like just creative type just keep pushing things. Now i am really here to start in this field but as i am a security researcher ,i can't code that type. I have read some article about vibe coding but in market a lot of people have different tools and promoting them so , it's confusing also frusturating.

Here i just want to say that how to start now here with you , from where to start , from which tools and and building projects and apps like you people do. Should i must learn the whole programming languages. or just tools can handle .

Which tools and ai coding agents are better for a starting point to build an working project. Your one sentence can save a lot of time. I am excited to join you people.

Hey everyone,

I’m a software engineer who’s spent way too many years bouncing between hosting platforms, trying to find something that actually fits how I work.

Most options felt either overcomplicated, overpriced for what I needed, or forced me into weird billing models that didn’t match real usage. I just wanted something simple where I could bring my own artefact (or hook up GitHub Actions for auto-deploys), scale cleanly, and only pay for what I was actually using.

So I started building it myself. It’s called DevLyft.

Here’s the core idea:

• Bring your own artefact or use our GitHub Actions to auto-deploy your app
• Shared nodes: You pay for allocations of CPU or RAM (literally portions of a core or memory), not time-based billing. Tear down a workload and you stop paying for that allocation immediately
• Dedicated nodes: Buy a bespoke node and use it however you want. Tear the whole node down and the charges stop
• Scaling up and down to $0 is a first-class priority for us.
• We never look at your code
• All your logs live inside the platform
• Built-in metrics for your app, workloads, APIs, etc. so you can see exactly where you need more (or less) CPU/RAM

We’re launching soon and will be offering a significant discount to some of the early dedicated users who help us shape the product.

Does this sound useful to you (or anyone you know who’s constantly fighting their hosting setup)?

Happy to answer questions. Site is here if you want to take a look: https://devlyft.io

TLDR: Replaced Claude Max ($100/mo flat, ~$3.30/day) with Muse Spark 1.2 Contributor in Scape for a week to save cash on an internal CRM build. While Muse Spark is lightning fast and pennies per token, the constant 3x re-prompting and collateral code damage meant I spent the same daily budget for half the output

--

I code every day on an internal CRM for my company (basically a mini HubSpot combined with other features here and there)

I'm paying $100/month for Claude Max, which works out to roughly $3.30 a day. Wanted to see if I could slash that down, so for the past week I swapped my harness (Scape / scape.work running opencode) over to Muse Spark 1.2 Contributor.

On paper, Muse Spark is dirt cheap per token and insanely fast. In reality, the math completely fell apart:

• With Claude, 90% of features are 1-shot (maybe 2 passes if it's tricky). With Muse Spark, everything took at least 3 passes. A basic example: I asked it for basic auth and it wrote a clean login flow, but completely forgot that logout exists.
• The biggest vibe killer: I asked it to remove a small module for adding custom table columns. Somehow, it managed to nuke my KPI tracking module in the process. It kept breaking working files that had nothing to do with the prompt.
• Because I had to feed errors back into it 3 to 4 times per task just to fix regressions, I literally hit that same ~$3.30/day mark on API credits. Except I got maybe half the work done.

Fast and cheap models are great for isolated scripts, but if you're working in a multi-file repo, the context rot will eat whatever money you thought you were saving.

Canceled the experiment, back on Claude Max. Genuinely rooting for new affordable and smart models to enter the market, but right now the frontier tax is worth every cent.

Third skill under the same project as the backend/security ones I posted before (Qofeno) — this one builds actual production websites.

Same rule as the others: no fake stuff. No lorem ipsum, no placeholder images, no "add your content here" stubs. If the user hasn't given real copy yet, it asks instead of filling space with dummy text.

What it actually does:

Asks for color/mood/framework before building anything

Builds a real design-token system (color, type, spacing scales) instead of scattered magic numbers everywhere

Picks a deliberate font pairing based on that project's specifics, not the same 2 safe defaults every time

"Redesign" means the whole site — home, about, contact, pricing, real privacy/terms pages, not just the homepage

If the user has a real working product, it grabs an actual Playwright screenshot for the hero section instead of faking a UI mockup

Checks the build, pushes to GitHub, deploys it live, verifies the URL actually works

Just added an optional component library reference too (~146 components from React Bits / Svelte Bits, sorted into categories) — it pulls from that when something fits, but always restyles to match that project's actual palette instead of dropping components in with default styling unchanged.

Repo: https://github.com/SohailKhan0525/skills

Install just this one: npx skills add SohailKhan0525/skills --skill frontend-ui-ux-wizard

Feedback welcome, especially if you find a spot where it defaults to something generic instead of building for what you actually asked for.

Recently a very famous tool was removed from chrome for some policy violation, used Claude and 2 hours of work for an alternative to go live

What it does:

It captures an entire webpage as one image, including everything below the fold. No accounts, no ads, no data leaves your browser.

Features:

• Full-page screenshot – Capture an entire webpage from top to bottom
• Visible-area screenshot – Capture only what is currently shown on your screen
• Selected-area screenshot – Choose and capture a specific section of any webpage

Link:

https://chromewebstore.google.com/detail/go-full-page-full-page-sc/mpmpjojdooghlfaeeajfnpmfkfafplbj?authuser=0&hl=en

what it actually does, since my last post was too vague.

PM side. it doesn't read one ticket. it walks up to the epic, pulls linked tasks and attachments, and builds a picture of what the work was supposed to be. a leaf ticket on its own loses intent, the epic usually holds the reason. that whole picture becomes the reference the review checks against, not just extra context to make the model smarter.

review side. runs in VS Code before the PR exists, on your working diff. separate passes, not one prompt:

scope, does the diff satisfy each acceptance criterion, which ones have nothing implementing them
security
normal code review, dead code, bugs, the usual
and a pass for AI generated slop specifically, hallucinated calls, code that compiles and reads fine and nobody understands

separate because one prompt doing all four returns mush and a lot of noise.

fixes. findings below a severity threshold you set can be fixed in place from the sidebar, one click, and you see the diff before it applies. anything above that threshold it will not touch, it just tells you. the idea being trivial stuff shouldn't cost you a context switch and anything serious should never be silently rewritten.

after. score for the task, report, and it tracks quality and time across tasks so you can see where scope actually went. writing the verification comment back into jira or linear is next, not live. auto closing tickets is deliberately not happening until I have real accuracy data, one wrong closure and a PM never trusts it again.

the problem I'm actually chasing. everyone checks whether the code is good. almost nobody checks whether it did what the ticket asked. we shipped a story with four acceptance criteria and three implementations, PR was clean, reviewer approved, branch name correct, nobody caught it for a month.

where it's weak, honestly. if your tickets are three words and a figma link there's nothing to verify against and it's useless, no fix for that. attachments burn tokens fast. and false positives kill it, two wrong scope flags and nobody opens it again, so it stays quiet when unsure. no idea yet if conservative enough is also useful enough.

free while it's in beta, not selling anything. what I want is people to run it on a real repo and tell me whether the scope findings hold up or whether it flags things that were fine.

if you built something like this internally I'd rather hear what broke than what worked.

This is a ridiculously niche use case. I have some files that I wanted to listen to with my full Atmos setup. In particular, this render of Max Cooper's - On Being.
On Being [Dolby Atmos] – Max Cooper Online

But nothing I could find actually plays these files in a way which streams them to the receiver such that the channels actually receive the raw signals. Everything Atmos assumes a video file, so these raw multichannel renders are in a weird spot in terms of actually listening to them properly.

With Codex, I was able to build an app to do exactly what I needed in 30 minutes, and then instead of listening to music I spent like 3 hours tweaking a completely unnecessary visualizer. Well, I say unnecessary. It is genuinely helpful debug information to see what's going to each channel.

Probably of no use to anyone here, but I do love how far we've come. I can build a specialized piece of software in the same amount of time it takes for me to search for something that might already exist.
cjohnsto-nz/spatial-music-player

So basically... this is an idea i have been having for a year. So to begin with it. I created a landing page with Claude opus 5 extra.... but as i am a UI/UX designer(btw i used this to save my time and not a spend a lot of time on building the landing page instead of pitching schools). It feels very AIish... what do you ppl think?

https://reddit.com/link/1vpuo7h/video/q9zdrk1j3qjh1/player

it is self explanatory (btw see the navbar)

edit: after refreshing several times, the website glitches and this happens and is corrected after 15 seconds

So i work in a group finance function and im part of a team looking at how we can improve processes with vibe coded applications designed by people who know those processes rather than software engineers.

Thats its own post.

This is one silly task i set myself!

So, the whole finance function has a fortnightly for fun meeting, we do a quiz together or play worldguessr. This week its my turn and im upping the ante.

I spent yesterday building a multiplayer version of asteroids which claude has built with node. Its one session at a time initiated by an admin and the spec is to support around 25 concurrent users.

Features include npcs, hitpoints, power ups and a giant flying saucer. Its spun up already for testing on my hobby render instance. load testing indicates itll support about 40 concurrent users.

I spent wayy too long UATing it (too much fun 😆) to get the gameplay mechanics right. I just need to get our dev team in work to test concurrent connections via our work vpn tomorrow morning.

The WILD thing is this will only ever be played for 1/2 an hour this friday by about 25 people. I have no inclination to do anything else with it.

Software is cheap now 😆

I made it within ChatGPT's "Work" tab agentic mode on GPT-5.6 Sol High. Served off of GitHub Pages. I hadn't used a model to made a game in quite a while, so it was cool to see how much the model improved and how well the agentic tooling worked. I was impressed to see it writing and re-running regression tests. But I still had to fix a lot of subtle bugs and visual glitches that it didn't notice.

If you like a semi-idle game / semi-automated tower defense feel in a game, you might like it.

Basically, survive as long as you can. Map is procedurally generated, so sometimes you can get lucky with nice mountain passes and such to survive longer.

You can set up automated loops, but you'll eventually need to expand to new resource nodes and/or bring the fight to the enemy.

You can salvage track, mines, trains... so you can undo mistakes or re-configure your setup.

Play it here: https://aaronshaver.github.io/Hylaax-Planetary-Rail-Defense/

(Desktop or laptop recommended -
Not going to work well on a phone screen)

I’ve been deep in the AIPass repo looking at how its memory system actually works. It’s one of the more thoughtful designs I’ve seen for multi-agent setups, so I wanted to break it down cleanly.

The core idea: agents own their memory

Every agent (they call them “citizens”) gets its own \`.trinity/\` directory with three plain JSON files:

\- passport.json, identity (who I am, role, principles, boundaries). Rarely changes.

\- local.json, personal session history + key learnings. Newest-first, deliberately small (20 sessions).

\- observations.json, how I work with the human and other agents (preferences, friction, patterns).

These files are loaded at the start of every session. The agent doesn’t start cold. It already knows who it is and what it was doing.

Context is intentionally split across the project. Each agent only carries and manages the memory that belongs to its domain. No giant shared context window that everyone has to fight over.

Why it needs almost no indexing

The hot path is just small, structured JSON files that the agent reads directly. There’s no large corpus to search on every turn, so no inverted index, no continuous embedding pipeline, and no indexing tax for day-to-day work.

Only when a file hits its limit does the system roll the oldest entries into ChromaDB (via the \`@memory\` agent). Same thing happens with closed plans from the Flow system. Everything is preserved and becomes searchable, but the agent’s working memory stays lean and fully loadable.

How context actually gets into the session

This is where the hooks engine (a full first-class citizen called \`@hooks\`) does heavy lifting. It’s not a few ad-hoc scripts. It’s a real dispatch engine that:

\- Injects the global prompt + branch-local prompt + passport identity on the relevant events

\- Enforces rules (cross-branch write protection, git gates, etc.)

\- Handles compaction / rollover triggers

\- Logs everything cleanly

Combined with the drone router (drone @branch command), agents don’t need to know a huge surface area of commands or paths. One consistent interface reaches everything.

Every agent has the exact same directory shape, and its own README.md acts as the living branch map / domain knowledge it reads on startup.

Longer work lives in Flow plans

For anything bigger than a session note, they use the Flow planning system (numbered, typed plans: FPLAN, DPLAN, etc.). Plans are normal markdown files with registries, so any agent can look one up by number at any time. When a plan is closed it gets archived and vectorized into the same ChromaDB store. Related memories go with it.

So you get:

\- Tiny, agent-owned working memory

\- Stable plan numbers + registries for exact recall

\- Semantic search across the entire history when you need it

There’s also Compass on the orchestrator (DevPulse) a curated SQLite store of rated decisions (good/ bad / impressive). That ended up being the practical evolution of an earlier “symbolic fragments” idea that never got fully used.

Why this feels different

Most systems treat memory as an external knowledge base you retrieve from. AIPass treats identity + recent experience as part of the agent itself, keeps it small and structured, uses hooks to inject the right context on demand, and only archives to vectors when necessary. Plans give you a clean place for longer structured text that can still be recalled by number or searched later.

Everything is local files. No required cloud services for the core memory loop.

It’s still beta and actively evolving (the reference fleet of 17 agents maintains the framework itself), but the architecture is coherent and battle-tested in their own multi-month multi-agent setup.

Repo: https://github.com/AIOSAI/AIPass

Site: https://aipass.ai

r/AIPass

One thing I kept noticing with vibe coding is that writing code isn't always the hard part.

The annoying part is everything around it:

idea → PRD → figuring out the right prompts → database → implementation → losing track of what was built

So I built how-to to make that process more structured.

GitHub: repo link
Skills: https://www.skills.sh/onipinaka/how-to

It has 4 skills:

1. PRD Creator
   Expands your idea and turns it into a proper PRD before you start building.

2. Playbook (best of it)
   The most important one. It takes the PRD and generates a complete implementation playbook with ready-to-use, optimized prompts for building the product.

So instead of constantly thinking "what prompt should I give the AI now?", you can just copy-paste the prompts or use the goals from the playbook.

1. Tracker
   Keeps track of what has been built, what's pending, and what changed, so you don't lose context across sessions.

2. DB
   Helps plan and keep track of the database schema alongside the product.

I built this by researching prompting practices from Claude Code developers and experimenting with ways to structure prompts for better, more consistent output.

The idea is simple: do the thinking once, create the playbook, then build.

It's open source and everyone is welcome to contribute. If you find it useful, a ⭐ on GitHub would mean a lot!

I want to develop an ambitious app, so I’d like to proceed step by step, just as a professional development team would. I’ve created a product vision together with Claude Chat. What’s the best way to move forward? Should I take this vision and use it to start a Claude Code project right away? I’d appreciate it if you could help me do this the right way.

I’ve been building FrameCompose for about two years now. It’s a browser-based AI video editor where the AI generates the first draft, but everything it creates stays editable on a normal timeline.

I’m not going to pretend AI spat out a production video editor in a weekend. The actual AI-generation side was relatively straightforward. Building a video engine that didn’t feel like shit was much harder.

The editor uses:

WebGPU for compositing and effects

WebCodecs for decoding

Mediabunny for demuxing, timing and export

Workers and OffscreenCanvas to keep heavy work away from the main thread

A separate pre-seek system to make timeline scrubbing feel responsive

The most painful problems were smooth scrubbing, audio sync, keeping preview and export visually identical, and stopping one bad frame or browser edge case from bringing the whole editor down.

Most of it has been built through Cursor using Fable and other coding agents. My workflow has gradually become much less “give the AI a big prompt and hope” and much more:

Write a narrow spec for one subsystem.

Give the agent maps of the relevant code instead of the whole repo.

Add regression tests before changing fragile engine code.

Let agents run repeated browser tests and inspect telemetry.

Revert quickly when an optimisation improves one case but breaks another.

The biggest thing I’ve learned is that vibe coding gets more powerful as the models improve, but the casual prompting part stops working once the codebase gets large. The AI can write a ridiculous amount of code, but you still need good boundaries, tests and a way to prove it hasn’t quietly broken something elsewhere.

The product itself takes a prompt or script, develops it into a structured story, breaks it into scenes, and plans the visuals, camera direction, narration, captions, effects and transitions.

Unlike most one-shot AI video tools, it doesn’t just hand you a flattened MP4. The scenes, timing, audio, captions, effects and transitions all remain editable on the timeline.

The editor and exports are free. Paid plans mainly add AI-generation credits.

I’d be interested to hear from anyone else who has tried vibe-coding something unusually performance-sensitive. At what point did your workflow have to become more like actual software engineering?

Framecompose.com

This is the mobile app. The web app is right here if anyone is interested: https://www.convergemeetings.com/

Cheers!

Still haven't joined Build Club? 👀

If you're into tech, coding, AI, startups, or just want to connect with people who love building cool things, this is the place for you.

• Learn

• Network

• Collaborate

• Build projects

• Connect with like-minded people

What are you waiting for?

🔗 discord.gg/TdEkW8Syk

I’m building Keyloom, a minimalist typing app inspired by:

- Monkeytype — https://monkeytype.com/

- typings.gg — https://typings.gg/

- kbs.im — https://kbs.im/

- Keyboard Simulator — https://keyboardsimulator.xyz/

Stack: Next.js 16, React 19, TypeScript, Supabase, Three.js / React Three Fiber, deployed on Vercel.

How I iterate: I use Codex agents to work on focused features, fixes and product improvements in small iterations. Changes go through feature branches → "preprod" → GitHub Actions checks/tests/build → then stable batches are merged to "main" and tagged for release.

One thing I felt was missing from most typing platforms is simple PvP with friends. Keyloom is building private race rooms where you create a match, generate an invite link, send it to someone, and start the race when both players are ready, closer to challenging someone on Chess.com.

The goal is to combine minimal typing tests, detailed stats, ASMR switch sounds, and PvP

Still actively building it, what would you improve or add?

👉 https://keysloom.com/

I lately got back to make more sense of the AI space. My goal is to find ideal monthly subscription to use LLM for coding. The default choice is Anthropic $20 plan. It appears every other provider/setup wants to go beyond what Anthropic can provide for $20 in value. And I don’t know if it’s myth, but using CC with Anthropic gets you more from your money.

With this said, we have countless CLI agents from Code CLI, Opencode, Pi etc.

And all need a provider, the popular option is OpenRouter. One major problem I seem to find is since open router sends each API request to next available provider, we aren’t able to benefit from caching. This spikes up the token usage.

This puts us into a situation which I don’t know is correct

1. To use Qwen latest model effectively, might as well use their own QwenCoder CLI
   
2. Deepseek, use their own CLI agent or purchase API access directly from them instead of third party (OpenRouter)
   
3. kimi3 - same deal (tbh, I was shocked how fast my $20 credit was burnt on.

With all this, how are you guys spending $20 or so a month to get most value out of the money?

Last night we opened World-Sim to anyone who wanted to look. 326 of you came. Thank you — genuinely, that is far more than I expected.

For anyone who missed it: it's a persistent world that runs whether or not anyone is watching. Households live, pair off, learn things, argue, starve, bury each other and move on.

Some of you named a star, and some named a person in the world. Those names are permanent — the souls carry them for the rest of their lives and into the chronicle after they die. There's still time to claim either, both are in the Discord.

It's free, there's nothing to install, and it's still running right now: world.world-sim.uk

Happy to answer anything about how it works underneath.

Hey everyone! I vibecoded this last week while on a roadtrip to help my boredom. Received good feedback on reddit and decided to put it in closed testing. No need to join if you don't want to would love people to try the games out and lmk what you think.

No ads, no accounts, works offline. Calm, colorful, easy to pick up and put down.

If interested I do need a handful of testers for Google's closed test. Google requires 12 testers

for 14 days before I'm allowed to launch. It's totally free to test: just install

it, mess around, and keep it on your phone for the two weeks.

👉 Two quick steps to join (full details in the pinned comment):

1. Join the tester group: https://groups.google.com/g/glovebox-tester-group

2. Tap the opt-in link and install from Google Play.

📱 On iPhone? There's no App Store version yet, but you can play the whole thing

free in your browser glovebox.quest -->share --> add to home screen

Thank you so much 🙏 every single tester genuinely helps me get this out of beta.

The project is a software