I’ve had this stupid running joke with my buddies about making a “Dario Hate Club” for a while, so I turned it into a small merch design experiment.

To be clear: I didn’t vibe-code the store itself. The storefront is just running on Fourthwall. The part I used AI/vibe-coding for was the design process: generating, rejecting, iterating, and cleaning up merch graphics until they stopped looking like generic AI slop.

The workflow was roughly:

1. Started with the basic joke and brand direction.

2. Used AI to explore rough shirt/poster-style design ideas.

3. Rejected most of them because they were too cringe, too fake-edgy, or too obviously AI-generated.

4. Kept pushing the prompts and references toward simpler black/white/red streetwear-style graphics.

5. Cleaned up the better concepts into usable merch designs.

6. Uploaded the final pieces to Fourthwall as a quick way to test whether the idea actually works as merch.

The biggest takeaway was that AI was useful for fast visual exploration, but not for taste. The actual work was mostly deciding what not to use and forcing the outputs toward something less embarrassing.

Here are a few of the designs:

Note before I start this: I have a problem with over engineering things. It’s can be a problem.

I love the fact I have software written and not have to worry about sifting through overly seo'd web pages just to find syntax. I never intend to have public releases or commercial products as I don't want to be a slave to customer support. I do that all day long for a gov't entity.

So here is my vibe coding setup at home for personal use. Let's me start with the idea and then work to the final product:

1- Project in Claude AI that describes this process. This project connects to my home network via MCP. I use this to work on planning, tech issues, and etc.

2- Once the plan is solid, Claude.ai connects to my local machine and communicates with the tracker. The tracker is like a Project Manager that parses out the project and creates tickets, sets up an epic and sprints, and assigns tasks to each of the other Claude Code instances. Think of a basic Jira but built in Drupal. Each machine updates the ticket as needed.

3- Each of the other instances on the network run a monitor that checks for new tickets assigned to that instance, sets the order of operations, and sets the project in motion.

4- Their are multiple machines in this network. Here's the breakdown for each machine:

- tracker and backend coder
- UI, usability, and WCAG AA creation and testing
- ingestion and context-based DB creation with access to Runpod for large projects my 3060ti can't handle. This also handles custom queries using the same service
- Mac for iPhone app if needed
- Android app creation (this also doubles as my plex server)
- Kali Linux for pen testing (this is still being on boarded)
- dedicated Pi to connect to a Digital Ocean droplet running a heavily walled off Drupal install with a next.js front end

Each instance runs a dedicated agent that monitors the tracker for emergency comms. This could be improved but it works well enough for now. New projects run in their own containers on the coding box. I need to move this to another machine to keep seperation of duties clear. In the case of failure, I can use Claude.ai to connect to each machine independently but this is a very rare need.

The kicker is that we are process of moving so some of these machines sit in one state and some sit in another state. Tailscale is used for connection and mobility.

I also run tailscale to connect to my iphone and steam deck for fun. Nothing exciting yet. Lol.

The only reason I have these machines is because I got on a kick a few years ago and bought off lease desktop machines for cheap. They chug through this pretty well. The 3060ti machine is a newer machine that I use as my main PC when needed. Gaming stays on consoles.

I probably will reconfig this system in time as this was put together with no plan.

The DO droplet is the newest edition. I needed a public front end for things like a household inventory tracker that give the location of items in the basement and in the cupboards. This helps my autistic wife to find things before a breakdown happens.

Basically I mimicked what I'm used to working on inside a production team.

Anyway, that's my setup. I thought I would share here. It's not perfect.

The most important step is the planning process and I can do that from my phone allowing me to marinate in decisions as needed.

Honestly, lately I’ve been feeling super anxious about whether vibe coding is still worth investing my time into, especially with all the AI advancements and no-code tools. But I stumbled upon a thought today that really resonated with me, and I wanted to share it with everyone for some mutual encouragement:

Just because anyone can bake bread at home doesn't mean bakeries are going out of business. It’s the same with web dev. Sure, anyone can learn to code, but there will always be a massive market for top-tier, professionally crafted products. Quality sells itself."

Just wanted to drop this here to encourage anyone else who might be doubting their path right now. Keep shipping and iterating!

I see posts across the different subs of people spending insane amounts of tokens and money building things. Over the last few months I've made a bunch of stuff and deleted 3/4 of it, but I rarely even hit my limits much less have to spend more than my subscription.

So wtf are you guys building that's using so many tokens? Please don't turn this into a bunch of advertisements.

I keep seeing posts on here from people saying they completely lost everything they built after an AI went off the rails. (I know some are bots, but still).

Seriously, do you guys not know how to use local Git?

Just initialize a repo. Commit your stable code before you start building out a new feature. When the AI inevitably breaks something or turns your codebase into spaghetti, just revert back to your last working state and learn from it.

It takes two seconds and saves hours of loss work.

Edit:

For those who actually don't know the commands, it’s just three lines in your terminal once your code is working:

1. ⁠git status⁠ (to see what files were modified)

2. ⁠git add .⁠ (to stage all the changes)

3. ⁠git commit -m "working state"⁠ (to save your progress)

Done. Now you have a restore point for when things go south.

I've been seeing a lot of threads about the fix-one-break-ten problem and the common answer seems to be: plan your architecture carefully before you build, think about structure upfront, be intentional about how you prompt.

That makes sense. But as someone without an engineering background, I don't always know what "planned architecture" even looks like in practice. I can't evaluate whether the AI's structural decisions are good or not. I don't know what questions to ask before I start.

So I'm curious what non-engineers have actually figured out. Not the theoretical answer about planning better, but what you've actually found that works day to day when you're building with AI and don't have a CS background to fall back on. Is it a prompting pattern? A review step? Keeping things smaller? Something completely different? What's actually made a difference for you?

I use the api in vs code's extension openchamber and it's surprisingly fast

ok so this started because i got locked out of a recipe site at 1am. the wall pops up, "please disable your ad blocker," and i just sat there like im not turning anything off to find out how much cumin goes in chili. so naturally instead of turning off my adblocker like a normal person i decided to build my own. classic.

the dumb realization that kicked it off: the reason sites catch your adblocker is that the popular ones are basically famous. ublock, adblock plus, theyre so well known that sites just check "hey is this specific thing here" and bam, caught. its not magic detection, its just recognizing a celebrity in the crowd.

so the whole idea became: what if the blocking happens BEFORE the site's bouncer even looks.

how it actually got built (the vibe part):

• started with me asking claude to explain manifest v3 like im 5. it did not explain it like im 5. manifest v3 is where dreams go to die btw. chrome changed how extensions inject scripts and the docs read like theyre actively mad at you.

• the core trick is two content scripts. one runs in the MAIN world (the page's own context) at document_start, before the page's own scripts wake up. the other runs in the ISOLATED world for the safe stuff. the timing is everything. if your blocking fires one beat too late the detection script already took attendance and youre busted.

• spent legitimately like 3 days just on "why does my script run after the page script sometimes." answer: run_at and world settings in the manifest. i had them slightly wrong. i aged a year.

• network blocking is done with declarativeNetRequest rule lists instead of the old webRequest way, because mv3 killed the old way. this part vibe coded smooth honestly, just feeding it filter rules.

• youtube was its own boss fight. the ads aren't just network requests, theres a detection script too, so you have to handle the player at the content layer or it just sits there buffering forever to spite you.

stuff i learned the hard way:

1. "just ask the ai to fix the timing bug" does not work when YOU dont understand the timing. i had to actually learn what document_start meant before the ai could help. vibe coding has a floor and the floor is you knowing what youre even asking for.

2. test on the annoying sites early. it worked on my test page on day one and i got cocky. real news sites humbled me immediately.

3. permissions matter for trust. kept it to declarativeNetRequest and storage so people can actually look and go "ok thats not a keylogger."

its free, no account, gpl-3.0 so the source is going up on github (someone on another sub rightly roasted me for not linking it yet, fair). will drop the repo so people can tell me everything i did wrong, which on this sub i assume is a lot and i welcome it.

heres the thing if you wanna poke at it:

anyway ask me anything about the mv3 nightmare, i have trauma to share

small update: you called me out for saying open source with no repo, fair lol. its up now:

if you try it and it works, a quick review on the chrome store would help a ton, listings brand new. even one honest line, good or bad

Day 1 — 2 startups. 146 impressions. 1 click.
Day 2 — 3 startups. 389 impressions. 3 clicks. (Got an acquisition offer.)
Day 3 — 5 startups. 482 impressions. 5 clicks.
Day 4 — 5 startups. 508 impressions. 4 clicks. (The site was down, but I still got an $8k acquisition offer. I said no.)
Day 5 — 6 startups. 621 impressions. 10 clicks.
Day 6 — 5 startups. 742 impressions. 15 clicks. (Had to remove one startup — they pulled the code. No code = no network.)
Day 7 — 7 startups. 1,196 impressions. 41 clicks.
Day 8 — 7 startups. 1,535 impressions. 74 clicks.
Day 9 — 8 startups. 1,947 impressions. 135 clicks.
Day 10 — 3,500 impressions. 318 total clicks. (Yesterday alone: 1,400 impressions and 178 clicks in a single day.)

Something is working.

Still free. Still growing.

"Consistency compounds. The results you want are hiding behind the days you don't quit."

Built with lovable and Claude Code

It was a 4 player online game, worked on it for 2 months in my spare time and found a buyer!

It amazes me that software actually got built. The sheer complexity and the amount of ways things can go wrong just blows my mind. The people who did this work for the last 50 years are magicians and miracle workers IMO.

I just wanted to share a quick personal win that has me feeling incredibly happy today.

To be completely honest, it hasn't earned me a single cent, and it will probably stay that way. But that’s not even the point right now. For the longest time, all the talk about AI felt like an abstract concept that was only relevant to big tech companies or expert developers.

But actually sitting there, guiding the AI, fixing errors together, and seeing my ideas slowly come to life on the screen made me realize that this technology is actually accessible to someone like me. For the first time, I felt like a creator rather than just a bystander. The feeling of making something functional from scratch is amazing.

You know the loop.

Tell Claude Code to build something. It works for a while. Then something's broken. You paste the error. It fixes that, breaks something else. You fix that, three new errors. 45 minutes later you delete everything and start over.

The worst part? The AI didn't fail at the end. It made one wrong assumption at step 3 of 14. Every single thing after that was doomed. You just had no way to know until the whole thing collapsed.

Right now your only options are blindly re-prompting (burning tokens on guesses) or restarting from zero (burning tokens on work that was actually fine). Neither option is "find the exact step that went wrong and fix just that."

I want to build a tool that watches your agent session silently, detects when it starts going off the rails (scope creep, wrong files touched, same fix attempted twice), and stops you before you're $30 deep in a broken loop.

Two questions:

1. Does this happen to you regularly or am I just bad at prompting?

2. Would you actually use something like this or do you already have a system that handles it?

Worst token burn on a session you ended up deleting? Mine was $34. Curious if that's normal.

So I've used AI now to develop 4 apps for my personal use. I may refine and iterate them into products to bring to market at some point.

From my experience:

1. You can't just vibe code any app in market and in 2 hours have a full replacement. There is a lot of effort and time needed to get an AI developed app to the precision and quality and functionality of most live apps with any decent feature scope. I've been working on one of my apps for about a month now for example to get it to market quality.

2. The value proposition matters more now than ever if you want to bring a solution to market. Tons of apps exist and will exist. How will yours really matter to customers?

3. Most problems are solved in the market today. So while some niche ideas or unique solutions may get created, most new apps must be an improvement on what exists in a meaningful way.

4. Most of what I see in vibe coding is AI slop, just using AI to quickly make something thinking people will use it and pay for it. So insane.

As a newcomer to the field, I'm a bit hesitant to share my early-stage project. While I've gathered some feedback from friends and family, I haven't had the chance to connect with actual users yet. I'd really love to learn more about how other makers are approaching this and sharing their work.

Probably a month ago i was checking that do people vibe code and deliver e-commerce websites but eventually dropped the client and i thought its too risky - i had security features in mind but still i thought it was risky

But now i think shopify is the best thing for this

I can make a shopify store and even get the website looking as i want it to right by coding it right?

If you guys know how i can code my websites layout and frontend and use it on shopify please do let me know

And also if that was a wise decision or i just lost a 500$ client.

Hello, I have 24GB of RAM on my new VPS with Ubuntu and wanted to try pentesting and other cybersecurity things.

What could be the best LLM for that?

And also, if you have any tips about cybersecurity with LLMs, let me know!

(Mainly for my studies)

If I open , the spell breaks and the app dies. The vibes are the only thing holding the database together right now. Who else is living on the edge?

tl;dr: An open-source orchestrator that scales to 10,000+ parallel agents. By using continuous beam search across reasoning trees and aggressive trajectory compression, it hits 91% correctness on harness-bench (vs 64% one-shot) using cheap models in parallel.

Cheap Parallelism over Frontier Models

We spent months trying to force higher accuracy out of single agents by using bigger models, better prompting, or naive sequential retries. We found that:

• Single-agent tasks fail ~36% of the time on harness-bench.

• Sequential retries ("try again") hit diminishing returns hard after generation 2.

• Throwing a single helper at a stuck agent often yields the exact same failure mode.

The Swarm Alternative:

What if instead of one expensive model trying to be flawless, you run 100 cheap, fast agents in parallel, let them explore different reasoning paths, disagree, and vote on the final output?

• 1 frontier agent @ $0.001/call = $0.001 (36% failure rate)

• 100 micro-agents @ $0.00001/call = $0.001 (9% failure rate via voting / beam search)

For the exact same token budget, accuracy jumps from 64% to 91%. This only works if your orchestration layer has negligible latency overhead and can manage thousands of concurrent states without falling apart.

This has been tried time and time again as LLMs have progressed, and have typically yielded poor results. But it seems we're at a point now where the performance of models that we consider cheap has tipped into a land where swarms actually work.

Interesting Things We Made and How

1. Pipelined Beam Search

Most multi-agent frameworks spawn N branches, wait for all of them to finish execution, evaluate them, and then spawn the next generation. The slowest agent bottlenecks the entire pipeline.

sshop uses a continuous, pipelined approach. Fast-completing branches seed children immediately; evaluation and pruning happen on a rolling basis.

Standard: Gen 1 (Wait for all) ──> Gen 2 (Wait for all) ──> Gen 3
sshop:    Gen 1 ──(fast branch)──> Gen 2 ──(fast branch)──> Gen 3
                └──(slow branch)──────────────> (Evaluated late/pruned)

• Latency: Reduces from $O(\text{generations} \times \text{branches})$ to roughly $O(\text{max\_branch\_depth})$.

• Throughput: ~4.5× improvement on complex reasoning workloads.

The Benchmark Results (harness-bench, 112 tasks):

• Gen 1 (One-shot baseline): 64.1%

• Gen 2 (Critique/Branch stage): 86.8%

• Gen 3 (Consensus/Polish stage): 91.2%

The massive jump happens at Gen 2 (+22.7 points), showing that parallel critique is where the real value lies. Gen 3 offers diminishing returns, meaning you can aggressively prune deep trees early to save tokens. We would like to retry with a larger gen limit.

2. Trajectory Compression & Plan Caching

Running hundreds of agents eats tokens. To keep this cheap, we implemented two strategies:

• Plan Template Caching: We map task structures using an SQLite FTS5 index. If an agent is building a REST API, it doesn't decompose the task from scratch. It pulls a cached decomposition template (60–80% reuse rate), cutting initial generation costs by over 60%.

• Multi-Turn Trajectory Compression (MT-OSC): Instead of feeding a massive, 10-step raw execution log back into the context window, we offload logs to dirt-cheap models (like Haiku) to synthesize them.

• Simply using the cheapest providers we can find.

The compression prompt turns raw logs into a dense summary (We do prefer to avoid summaries though, we typically run Suit Shop with summarisation disabled). This dropped token overhead by 41–72% with minimal drops in task accuracy ($p=0.118$).

Open Engineering Questions We're Solving

1. Predictive Pruning: Can we reliably predict when a reasoning path will plateau at Gen 2 vs. when it requires a deep Gen 4 crawl? Right now, rule-based tasks plateau early, while abstract engineering tasks scale deep.

2. HBM Caching Limits: At what parallel context size does the GPU memory overhead of holding multiple agent states exceed the cost of just re-computing shorter compressed contexts?

What’s Next on the Roadmap

• Visual Beam Search Dashboard: A web UI to replace our TUI to make Suit Shop more accessible

• Cross-Agent Knowledge Transfer: Allowing parallel branches to pass localized "lessons learned" to competing branches mid-flight.

Let us know what you think. We're actively looking for contributors who want to move past simple single-agent wrappers and dive into heavy concurrent orchestration.

GitHub:

edit:

Github was being annoying and not letting me make the repo public, temporarily switch to Gitlab while I resolve that -

I’ve currently got about eight active projects sitting in my /workspace folder. As the count keeps growing, I've been seriously looking for a single-pane-of-glass main view to reduce the cognitive load of deciding what to focus on next, what to drop and stop wasting mental energy on shifting priorities.

After looking into a few frameworks, I decided to start with a meta-project control plane that lives right inside the workspace as its own folder. It acts as a single source of truth for tracking project statuses, priorities, standards, and cross-project coordination. My current philosophy is a strict "markdown-first, ask questions later" approach based on LLM-wiki and open-knowledge principles. That means no databases, no APIs, and no complex build steps. .md files and a lean script command over a webview UI.

This setup feels pretty good for a lightweight start, and it has given me a perfect excuse to zoom out and normalize documentation standards across all my repos. However, I am highly aware that I might just be entering a classic "works great until it horribly scales" honeymoon phase.

Now that I have this starter meta-organizing layer, I am curious what this sub is utilizing as you spin up dozens of mini-apps. What are you using to track everything? I'm trying to decide on the tooling trade-offs between moving to native tools like Linear and GitHub Projects early versus to an Obsidian Kanban setup. I'd also love to know if formal frameworks like RICE scoring actually hold up when vibe-coding, or if you all just default to a pure "build whatever feels right today" priority system.

TL;DR: Videographer, not a coder. Got sick of opening a whole Premiere/DaVinci project just to review my flat gray LOG footage in color (QuickTime and VLC are useless for this). So I vibe coded a native Mac app (Loglux) that plays your footage with your LUT applied instantly, and allows you to grab a high-res color still frame in one click. Now on the App Store.

I've shot video professionally for about 20 years, and I've been working with AI coding tools for roughly a year. Loglux is the first real app I've shipped, and this community was a big part of why I believed it was possible. I wanted to share how it came together.

A bit of background for anyone who doesn't shoot video: Most professional cameras can record in a "LOG" format, which captures a flat, gray, low-contrast image. It looks washed out and lifeless on purpose, because that flatness preserves the maximum amount of detail in the highlights and shadows for color grading later. To make LOG footage look normal (or cinematic), you can apply a LUT, which is essentially a color preset that does a bunch of math and maps those flat values into a finished-looking image. The catch is that until you apply a LUT, you're staring at gray, murky footage that doesn't represent what you actually captured.

The problem I was solving: Reviewing LOG footage is genuinely painful with the tools most people have. QuickTime shows you the flat gray version with no color and basically no controls. Preview is worse; it lags when scrubbing and often won't even play clips smoothly. Neither can apply a LUT. So the only way to see footage in real color is opening a full Premiere or DaVinci project, start a new sequence, and apply color correction just to look at your clips. That's an enormous amount of friction for something I do constantly.

I wanted to open a file and immediately show a client their footage looking the way it's supposed to, in full color, on the spot.

What I built: Loglux is a simple, native Mac app that plays your LOG footage with your LUT already applied, so you see real color the moment you open a clip. Smooth scrubbing, no lag, and it uses familiar Mac and editor keyboard shortcuts so it feels native rather than foreign. You can also adjust exposure and white balance directly to see what you'd want to correct in-camera.

Sometimes you just want one clean frame, maybe to send to your colorist or post on social. The old way meant opening your NLE, creating a new sequence, dropping in the clip, applying your LUT, fixing exposure, and then exporting a single frame. Or using VLC's frame grab and making adjustments in Photoshop or Lightroom. Either way it's a ten-minute detour for one image. In Loglux, you open the clip, your LUT is already applied, and you grab a full-resolution still in a single click, color and all. After years of doing it the hard way, it feels like a cheat code.

The honest version of the build: I'm not really a developer. I relied heavily on AI coding tools and a lot of trial and error. The hardest parts weren't the fun UI work; they were the boring landmines, like getting the video and LUT rendering to feel smooth and native, and then the App Store gauntlet (Paid Apps Agreement, trader status, tax forms, rejections and resubmissions). Nobody warns you that shipping is roughly 20% building and 80% paperwork and polish.

Happy to answer anything about the process: the tools, what broke, the App Store process, whatever's useful. (It's a paid app, so I'll drop the link in the comments to stay on the right side of the self-promo rules.)

A small milestone for other, but HUGE for me: my app has now passed 100 users. 113 to be precise.

I originally started building it as a simple way to keep score during padel matches on iPhone and Apple Watch. With a lot of AI-assisted development, experimenting, breaking things and rebuilding them, it slowly became a much larger project with match history, a ranking system, statistics, tournaments, social features (beautiful match sharing features) and so so much more.

The most valuable part so far has been the feedback from actual users. A lot of the improvements and fixes came directly from people testing the app and telling me what felt confusing or what they wanted added. I try my best to think and test everything but it's impossible to take everything in consideration.

To make that easier, I built very early on a complete support and ticketing system inside the app. Users can report bugs, suggest features, follow the status of their tickets and receive replies directly in the app. Today I’ve started working on the Android version, which will probably be the next big challenge. I am trying to find friends with different models of watches, samsung, xiaomi, anything that can be used for this.

It’s still early, but seeing real people use something I built mostly through vibe coding feels pretty surreal.

I’d really appreciate any feedback, especially about real usage, in game, the UI, onboarding or the general idea.

App Store:

Website:

Feels like the cost performance ratio is getting worst for Anthropic with a small performance gap.

My last few projects has been with Lovable as the platform and scaffolding - and claude for the heavy lifting, but I decide to do a new one, and start some where else.

After a bit of talk with Claude, we decided to go with supabase for the backend and cloudflair for the front. Deployment through github.

Went a lot smoother then expected - I focused on getting the mcp's and api's authenticated, to allow claude to do most of the things that need doing. There was still some manual setup in supabase (google authentication and email mostly), but I think the only thing I did in cloudflair was buy the domain.

I'm building a and to test it I made a small demo search app over 11M codeforces/leetcode solutions and their tasks.

It's two kinds of search:

• over the solutions code: github-like code search

• over the coding problem: hybrid, i.e. bm25 + semantic, as here it's natural language so meaning search makes sense.

So you can find a problem by meaning and find solutions by exact code patterns. Say you want a task about "a solution with sum of two numbers in an array" where "heapq" is used in the solution.

Everything is done with Claude under ~15 min (I gave him docs). He pointed database to the remote data (from hugging face), created indexes and wrote queries.

Demo (no signup, open source):
Repo:

I'm kind of biased because it's my project, but the demo is live. You can also connect you AI agent directly to the search app via so it can query and analyze data solutions for you. I played a bit and found it quite funny.

I built a small open-source tool called Design Governor by UN1C0RN.

It is for AI/vibe coders who run into this problem:

You ask an AI coding agent to change one part of a website, and it accidentally changes another part you already approved.

Design Governor lets you define approved UI sections as “design contracts.” Before an agent edits, the change request has to name what contract is allowed to move. If the change touches a locked contract outside the request, it blocks.

It also has:

• Plain-English output by default

• Expert mode for real developer details

• JSON/CI mode for automation

• Policy checks for selectors/rules

• Visual proof support through Playwright/Chromium

• GitHub workflow and pre-commit starter files

This came out of trying to make AI-assisted building safer, instead of just faster.

Repo:

title pretty much sums it up. I noticed there are A LOT of indie devs making games I think deserve more recognition so I wanted to do my part in helping the community as a whole.

If you have a web game (website link) and don't mind having it embedded. Feel free to send it over and I will include it on the page to allow others who visit to play! Working on accounts and visual overhaul

Are you vibecoding something, but not a software engineer yourself?

I'm offering free 30-minute calls. No specific topic needed: bring whatever questions, worries, or confusion you've got. I've been shipping production software for 20 years, so chances are I can help with whatever it is.

Why am I doing this? Simple. I'm researching this space. I want to hear first hand what challenges people are running into. You get some free expert time; I get useful information. I've got nothing to sell.

Drop a comment or DM if you're interested.

Does anyone here with solid senior development experience have an AGENTS.md file they're willing to share?

I'm looking for an AGENTS.md that defines development rules and best practices for AI-assisted (vibe coding) development, with a strong focus on keeping projects clean, organized, maintainable, and scalable as they grow.

I'm especially interested in conventions around:

project structure

coding standards

architecture

documentation

testing

AI workflow and guardrails

anything else you've found essential for long-term maintainability

I'd love to see real-world examples rather than theoretical advice.

Thanks!

When you use Claude/Cursor/Copilot to make changes, sometimes the agent does more than you asked — adds deps you didn't request, creates env vars, new endpoints, etc.

npx overreach reviews the diff against your original prompt and flags everything out of scope.

How it works:

1. Run npx overreach in your project

2. It detects your git changes automatically (staged, unstaged, last commit — you pick)

3. It asks "What did you ask the AI to do?" — just paste your prompt

4. You get a review checklist: what's in scope, what's not, grouped by risk level (high/medium/low)

No install, no config file, no API key needed. It parses the diff with regex, not another AI — so findings are deterministic, not opinions.

What it catches:

• Unauthorized dependencies added to package.json/requirements.txt/etc

• New env vars you didn't ask for

• API endpoints that weren't in your request

• Cron jobs, listeners, out-of-scope files

Try the demo without any project: npx overreach demo

I've been struggling with a really complex auth issue upgrading my legacy shopify app auth flow to the new session / non-session token flow. Opus 4.8 and codex5.5 both were unable to Crack the issue and introduced more bugs.

I tried using fable 5 today. Watching it work was absolutely beautiful. It came up with a elegant and clean solution to my problem in 1-shot.

I went to test it and it still didnt work, caused regressions, and cost me 3x Opus 4.8, but man it was beautiful to witness.

So, I'm just getting into vibe coding. I have zero coding or software development background. I was just frustrated with being unable to find apps that had the features I needed/wanted, so I thought "I'll do it myself". Over the past few days, I've been using the free tier on a few different platforms as a distraction while detoxing at home from alcohol after a relapse, and found it to be a lot more fun than I expected it to be. As of right now I have the following projects I'm working on:

-An addiction recovery app through bolt

-A joint pain and symptom tracking app through base44

-A daily water intake tracking app through emergent

-A daily wellness tracking app, where habits done correspond to taking care of a pet (similar to finch but not a bird) on reliant

None of these are intended for commercial use at any point, just things I'm working on for fun and my own self care. A lot of the posts I see on here though still can get overwhelming with the language. I was looking for some guidance though on which platform would be best for a hobbyist if I wanted to purchase a basic level tier, so I could use it more often (ignore what I listed for apps, I have other project ideas). It's just frustrating only being able to work on it for three prompts, for three days, and then being told I have to wait until next month. I figured if I've spent 'X' amount on drugs and alcohol in the past, budgeting for a hobby like this to keep me occupied isn't the work thing ever. The only app that MIGHT, ever be shared is the addiction recovery one, because I have a lot of friends in recovery who expressed interest.

TL;DR: I accidentally built an internal web app that overlaps with my company’s upcoming ERP project. Now leadership wants to work with me, and I’m trying to figure out the best way to approach it.

I started a new Project Manager role at my company about two months ago. Coming from the shop floor, I immediately noticed a lot of pain points in how our administrative processes work.

Right now, a huge amount of our workflow revolves around forms being emailed between departments—job creation forms, budgets, purchase orders, work orders, approvals, etc. We have around 12 departments that all interact differently depending on the job, so information gets duplicated, lost, or manually re-entered constantly.

As a side project, I built a web app to solve many of those problems. It’s definitely not a full ERP, but it automates a lot of repetitive work, generates forms, handles printing, connects information together, and introduces some pretty cool ways of using the data that weren’t possible before.
Then I found out the company has actually been developing its own ERP system that’s supposed to launch in a few months.

Today I demoed what I’d built to one of the higher-ups. He seemed genuinely impressed, we ran out of meeting time, and he wants to continue the conversation. He also got me access to the company’s enterprise Codex account (which saves me the $100/month I’ve been paying myself), and it definitely feels like they’re interested in having me involved somehow.

I’m excited, but I’m also trying to be smart about how I handle this.

Do I:

Position myself as someone who can contribute ideas to their ERP project?

Offer my app as a prototype or proof of concept?

Keep expectations low and just see where the conversations go?

Ask about taking on a larger role if they see value in what I’ve built?

Has anyone been in a similar situation where you independently built something that ended up overlapping with an internal project? How did you navigate it without stepping on toes while still making the most of the opportunity?