Anthropic just shipped Opus 4.7 today and i had to write about it somewhere because the jump is weird.

I ran the same backlog task on 4.6 and 4.7 back to back. same repo, same prompt, same tools. 4.6 looped on a bug for 25 minutes and was not going to solve it. 4.7 closed it in eleven, and the part that freaked me out is that it paused in the middle to sanity-check an assumption i had not asked it to check. literally wrote "before i write this migration, let me verify the actual shape of the response object, because my assumption here might be wrong" and then went and verified it. unprompted.

That self-verification behavior is the thing. Vercel is reporting it does proofs on systems code before starting work. Hex says it flags missing data instead of making up plausible-but-wrong fallbacks. Genspark measured loop rates on hard queries and 4.7 basically stopped looping. different teams, different harnesses, same pattern.

the numbers are nuts too:

Real question for anyone running coding agents daily.

I started counting how often Claude Code and Codex ask for permission during a typical session. It's around 100 prompts per hour. Read file? Yes. Run test? Yes. Lint? Yes. git push --force? Also yes if you're zoned out.

Spent the last few weeks building three connected apps and shared microservices with Lovable/Cursor. The first 80% went shockingly smooth, the demo-stage stuff always does. Then real usage started, and the integration between services and the admin dashboard started throwing constant sync errors. A few different AI coding tools could patch individual symptoms but never quite nail the root cause.

For anyone who's taken an AI-built app past the demo stage: what was the first thing that actually broke once real users or data hit it, auth, data consistency, service integration, something else? And did you end up digging into the code yourself, or bring in outside help to sort it out?

Most of the vibe coding conversation is about speed and quality, how fast you can build and how good it turns out. Nobody really talks about the exit question. If you build inside a platform that hosts everything for you, how easy is it to actually leave.

Some tools give you a clean codebase you can download and run anywhere. Others keep the important parts, database structure, auth, backend logic, wired into their own infrastructure in a way that's hard to fully untangle. You don't notice this while things are going well. You notice it the moment you want to switch tools, bring in an actual engineer, or move to your own hosting and suddenly realize how much of your app doesn't travel with you.

Has anyone hit this wall for real. Did you end up rebuilding from scratch somewhere else, or did you manage to get everything out cleanly. And if you checked this before you started building, what did you actually look for.

Here's my hacked-together, messy, voice-based dev environment:

1. Voice-driven loop with screen-shotting so the LLM in the loop can see what's in my terminal and editor. The prompt varies depending on what I'm trying to drive with this loop.

2. A few tool definitions that give read access to files and URLs.

3. A tool the LLM can send a block of output to that generates keyboard events, so the LLM can drive any editor/terminal.

4. A separate process watching a directory and constantly making LLM-driven git commits. (git autosave).

I have some pieces of this running most of the time. But I'm lazy, and doing other stuff, and I also try to use a variety of editors and tools, to see what's good lately. Which ... no stability, so my hacked-together stuff is always broken.

I don't want to replace @Windsurf / @Cursor / Claude code. A seriously good agent and expert-system dev toolkit is a lot of work.

Hey everyone,

I don't actually like using the term "vibe coding". We've been software developers for over a decade ,are not one-shotting features, and have a very opinionated and strict dev process.

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?

I work at an early stage startup and I'd estimate 70-80% of our codebase is vibe coded (510k lines). To be clear, it's not 1 shot "build this feature." More like, "implement get_slim_documents for Jira in the exact same way we did it for the Confluence connector."
Comfort with AI coding tools is actually something we gauge during interviews/work trials. Looking at our peer companies, it's exactly the same.
My hypothesis/assertion is that companies founded ~2022+ are fundamentally intertwined with "vibe coding." In 5 years, programming will connote vibe coding more than it will connote non-AI assisted work.
Am I crazy? Pigeon-holed in the SF startup world? Naive? Would love to hear more thoughts/diverse perspectives on this.

After having hit 30k+ ARR with a vibecoded app, I now have to ask myself:
what s the most dangerous thing AI coding tools make look easy?

My top 3 picks:

• Auth

• Payments

• Database permissions

I'm a senior developer in Seoul. My commute is long and the subway is always packed. Here's how I tried to make mobile development work and where it fell apart.

Seoul subway is not quiet. You're standing, one hand gripping a bag, the other holding your phone. Coding the traditional way IDE, terminal, file trees is physically impossible. The screen is too small, your fingers too fat, and the text too tiny to read without squinting.

---

The problem in a nutshell: