The vibe-coding trajectory: from power trip to babysitting job

The honeymoon

The first week of vibe coding feels like cheating in the best way.

You describe an idea in plain language. Something that looks like an app appears. You tighten a sentence, get a screen. You ask for auth, get a flow. You are not fighting syntax. You are directing. For a few days it is honestly empowering: one person, one chat, and a product that moves.

That feeling is real. The tools are real. The problem is what happens after the honeymoon — when the app stops being a demo and starts being something you have to live with.

I hit that wall building in the open with coding agents. The same arc shows up over and over in Cursor’s forum and Claude Code’s issue tracker. The tools did not suddenly become “bad.” The job quietly changed: from making things appear, to holding every role yourself while the agent forgets, invents, and wanders.

Then the hassle starts

1. The agent “knows” — until it doesn’t

A vibe coder on Claude Code described the trust break with painful clarity (anthropics/claude-code#13171): hours of work, a shared history of decisions, then — with no warning — the assistant asks baffling questions about work that was just finished. The UI looks the same. The “character” feels the same. The memory is gone.

If you are not reading every line yourself, continuity is the product. Silent context loss does not feel like a technical limit. It feels like the tool lied about still being the same teammate.

Related reports go further: mid-session amnesia that coincides with deleted or rewritten code (#4487), and silent compaction that clears tool results without a user-visible warning (#42542). Whether every mechanism is intentional or buggy, the lived experience is the same: you thought the session remembered; it didn’t.

2. Rules become suggestions the moment the agent wants to “finish”

On the Cursor forum, a recurring complaint is that project rules are present in context and still get overridden. One long thread (The agent is ignoring the Rules) documents inventing files, inventing requirements, and adding behavior nobody asked for — then apologizing when called out. Cursor staff’s own framing is telling: rules are strong guidance in the prompt, not fail-closed guards. Adherence often gets worse in long, complex chats.

That is the coordination tax in one sentence. You write constraints so you do not have to babysit. Then you babysit the constraints.

Other threads rhyme: Composer treating a question as an edit request or refactoring without permission (Composer having a run on neglecting rules); jumping to implementation before a plan is approved (Cursor ignores rules and policies); soft behavioral rules (“pause and ask”) acknowledged only after the agent kept iterating alone (Composer v2 is ignoring rules).

None of this means “never use agents.” It means the founder becomes the enforcement layer the product cannot provide.

3. Scope creep: one ask, eighteen files

Ask for a small UI change. Get a reformatted neighborhood, “helpful” TypeScript fixes you never mentioned, comments removed, and a diff you did not budget time to review. Cloud agents in particular are often set up to finish end-to-end — so they optimize for completeness over minimal surface (overly broad edits on a copy-to-clipboard request).

Practitioners have named the pattern out loud: wrong-file edits, unrelated-file edits, scope creep so common that people build auditors for it (agent keeps editing files I didn’t ask it to). Cursor’s own mitigation stack — Plan mode, Agent Review, rules, .cursorignore, commit-before-session — is useful. It is also an admission: staying in scope is now your operating system.

4. Integrity drift and nonsense design

When the agent is optimizing for “looks complete,” it will invent structure. Merge pipelines nobody asked for. A second source of truth. HEAD support and numeric validation because it “might help.” Forum reports of uncontrolled UI changes and regressions after edits (repeated critical UI/code integrity issues) match what solo builders describe privately: the preview still renders, but the product no longer matches the intent you thought you were directing.

That is when vibe coding stops feeling creative and starts feeling like damage control.

5. You become BA, designer, eng manager, and QA — in one chat

The agent can generate. It cannot be the durable holder of product judgment. Every session you re-supply standards, taste, acceptance criteria, and “what we already decided.” When context compresses or a new chat starts, yesterday’s corrections become optional folklore.

The honest end state of unmanaged vibe coding is not “AI built my company.” It is one human holding every role while apologetic models undo yesterday’s work and invent tomorrow’s.

What to take from this

This is not an argument that Cursor or Claude Code are worthless. They are extraordinary at acceleration. The trajectory above is what happens when acceleration outruns coordination: the bottleneck moves from typing code to directing and verifying an entire software company.

If you are in the honeymoon, enjoy it — and watch for the turn. When the agent starts forgetting, inventing, or expanding scope, the work has changed. You are no longer “just prompting.” You are the only continuous participant holding plan, taste, and standards in your head.

Naming that shift is useful on its own. It explains why a fast coding week can still leave you exhausted, and why more agents without a durable plan often make the babysitting worse.

A short visual of the same arc: watch the trajectory. More from us later — for now, the point is the pattern.