When I ask to develop BE and FE everything is going smoothly and better then I can do manually but just I want to develop and agent with another agent - the circus with monkeys comes in my town.
By agents ( developers) I mean Codex , Claude Code ( I tried KIMI Code as well ) and by other agents I mean , well, smth similar but running as web app. So these guys ( agent developers ) totally ignore my instructions and always tend to "test and harness" rather then implement what I am asking for, with maniac determination limit agentic routing with caps, input / output validators and similar stuff.
a week ago i asked one question here: how do you actually keep up with AI without drowning. i expected tool recommendations. i got something better.
almost nobody talked about which tools. they talked about how to learn at all. the patterns that kept coming up:
saving isnt learning. a bookmark is a parking lot, not a to-do list. it feels like progress and nothing sticks until you actually need it.
stop trying to learn every tool. the people who seemed sane picked a few tied to real work and let the rest go. let the project tell you which tools matter.
AI coding tools have dramatically lowered the barrier to building software. A person who couldn't code a year ago can now create a working MVP in a weekend.
But I wonder if we are entering a new bottleneck.
Building the first version is becoming easier, but:
I got burned by an AI tool that locked my finished app behind its proprietary hosting. Couldn't deploy it anywhere else, couldn't truly own what I'd built. That's when I realized: the future of AI app-building isn't about who builds fastest it's about who lets you actually own what you create. I'm diving into this conversation because I think builders deserve better, and I want to hear how many of you have hit this same wall.
Building apps with AI agents (Cursor, Claude Code, Lovable) feels like a superpower until the app works, but the underlying logic is completely flawed or duplicated behind the scenes.
When you're shipping at full speed, doing a full line-by-line manual code review defeats the purpose of vibe-coding. But relying purely on "if it clicks, it ships" is a ticking time bomb.
How are you all handling this? Do you:
Use another AI agent strictly for code architecture / PR reviews?
Vibe coding is great until your product has real users. Then the "vibe" hits a wall. Slow queries. Weird bugs. Features that break other features. You can patch it for a while. But eventually, the tech debt catches up.
At what point do you stop vibing and bring in someone who actually knows what they're doing?
Is it:
When you hit 10 paying users?
When the app crashes more than once a week?
When adding a new feature takes longer than building the MVP?
For the first few months of vibe-coding, I did what everyone does: describe the feature in chat, let the agent write it, fix what broke, repeat. Worked great for week one. By week three, every "small change" was touching six files I didn't expect, and the agent kept re-deciding architecture choices we'd already settled two days earlier - because the only record of those decisions was buried in scrollback.
What actually fixed it for me wasn't a better prompt or a bigger context window. It was writing a spec before touching the agent at all - a short doc covering what the feature needs to do, the inputs/outputs, the constraints, and what "done" looks like. Then I have the agent work strictly against that doc instead of my memory of a conversation from three days ago.
A few things I noticed once I switched:
Way fewer "wait, why did you change that file too" moments, because the spec draws the boundary of what's in scope.
Reviewing AI output got faster - I'm checking against written acceptance criteria instead of re-explaining intent in my head.
Onboarding a second AI session (or a human collaborator) mid-project stopped being painful, since the spec carries context the chat history used to.
Been building almost entirely with AI-assisted tools, and the thing I've found matters most isn't how fast the AI generates code, it's having a real, repeatable way to verify what it actually did before trusting it's correct.
A recent example: I had a security researcher report what looked like a real vulnerability. Turned out the AI-assisted fix from weeks earlier had shipped correctly, but the researcher's finding conflated two different things, the anon key being visible client-side (expected, normal) versus whether it actually granted unauthorized data access (it didn't, verified by literally running real requests against the live endpoint). Took actual empirical testing to tell the difference, not just reading the code and assuming it was fine.
Curious what others have landed on for verifying AI-generated work before it ships. Do you have an actual process, or is it more ad hoc? What's caught you off guard that a quick glance wouldn't have?
Working on a scrappy prototype to track brand mentions across ChatGPT, Gemini, and Perplexity. Going full "build for the vibe" mode, no perfect architecture, just shipping the core loop and fixing what breaks.
Curious how others here approach this: do you vibe-code the whole MVP, or do you draw a line somewhere (e.g., auth/payments still get done "properly")?
