← Back to blog

Vibe Coding Mandate at Work: Should You Quit?

Is vibe coding mandate worth quitting over? Learn when AI-first development crosses the line and how to decide if it's time to leave your job.

Vibe Coding Mandate at Work: Should You Quit?

"Delete the entire unit test file and have Claude generate a new one." That is the workflow one senior engineer described in an Ask HN thread, asking whether it was worth leaving a company over a top-down push to adopt vibe coding. The post landed because the tension is now everywhere: leadership treats prompt engineering as the one correct way to build software, while experienced engineers worry about both their own skills and the codebase they will be babysitting in three years. So what is vibe coding — a concept now searched worldwide, including as "vibe coding 是什么" — and when does a company mandate to adopt it cross the line from useful to reckless?

This is a business decision as much as a personal one, so we will treat it like one: what the term means, where leadership is right, where the specific "regenerate the tests" habit becomes expensive, what the data actually shows, and how to decide whether to stay or go.

What vibe coding actually means

The term was coined by Andrej Karpathy in February 2025. His original description was deliberately loose: you "fully give in to the vibes, embrace exponentials, and forget that the code even exists." You describe what you want in plain language, accept whatever the AI produces, and keep prompting until it appears to work — without reading the code line by line. The Wikipedia entry on vibe coding captures the key distinction: vibe coding specifically means not reviewing the generated code, which separates it from ordinary AI-assisted programming where a human still reads, tests, and owns every change.

That distinction is the whole ballgame, and it is where most workplace arguments quietly go wrong. "Use AI to move faster" and "stop reading the code" are two completely different policies that happen to share a buzzword.

The concept spread far beyond engineering. Music producer Rick Rubin released The Way of Code, a reinterpretation of the Tao Te Ching built around vibe coding — which tells you the phrase has jumped from developer Twitter into general culture. Searches for "rick rubin vibe coding," "vibe coding tutorial," and "vibe coding course" all climbed alongside it. Popularity, though, is not a maintainability strategy. A term being culturally hot says nothing about whether it belongs in your production billing system.

Put simply: vibe coding is prompting your way to a result without reading the output. That is fantastic for a weekend prototype and dangerous as a default for software people depend on.

Where the CEO and CTO have a point

Honest take: dismissing AI-assisted development entirely would be a mistake, and any engineer weighing an exit should concede this clearly. The productivity gains on certain tasks are real. Scaffolding a new service, writing boilerplate CRUD, translating a snippet between languages, exploring an unfamiliar API, or standing up a throwaway vibe coding app to validate an idea before lunch — these are exactly the jobs where modern tools shine. The best vibe coding tools, from Cursor to Claude Code to GitHub Copilot, genuinely compress hours of typing into minutes.

For a business, that speed maps to money: faster prototypes mean cheaper validation of ideas that might otherwise consume a full sprint. A founder who has watched a demo get built in an afternoon is not being irrational to want more of that. In our experience building and maintaining production codebases for clients, AI tooling has meaningfully cut the time spent on the boring 80% — the glue code, the config, the first draft of a component.

So the CEO and CTO are not wrong that AI belongs in the workflow. They are wrong — if the Ask HN description is accurate — about how far to push it and which safeguards to remove. Those are separable problems, and the difference decides whether this is a coaching conversation or a resignation letter.

The real risk: regenerating tests instead of fixing them

The specific example in the post is the tell: "delete the entire unit test file and have Claude generate a new one" rather than manually addressing test failures. This is not an efficiency; it is disabling your smoke alarm because it keeps going off.

A test failure is information. It says the code and its expected behavior have diverged. There are only two honest responses: fix the code, or consciously update the test because the requirement genuinely changed. Deleting the failing tests and asking an AI to write fresh ones does something subtler and worse — the model tends to write tests that assert whatever the current code does, not what the business needs it to do. The suite goes green. The contract is gone. You have converted a warning light into decorative trim.

The business cost shows up later and larger. Tests are the cheapest place to catch a bug; production is the most expensive. Regenerated-to-pass tests give a team false confidence, so regressions sail through review, reach customers, and turn into incidents, refunds, and emergency hotfixes. Deleting a red test doesn't remove the bug — it removes your ability to find it. For a product owner, that trades a five-minute fix now for an unknown, unbounded liability later. This same pattern — AI confidently producing plausible output that quietly breaks things — is why vibe coding tools quietly play favorites with dependencies and inject choices no one on the team actually vetted.

Real numbers: what the data says about AI code quality

This is where the argument stops being about vibes and starts being about evidence.

GitClear analyzed over 150 million lines of changed code and found the trend lines moving the wrong way as AI assistants became mainstream. "Code churn" — code that gets reverted or substantially reworked within two weeks of being written — has been climbing, and the volume of duplicated, copy-pasted blocks is rising relative to refactored, reused code. Both are classic markers of falling maintainability. Their analysis of AI's downward pressure on code quality projected churn to roughly double over that window.

Google's 2024 DORA report adds the delivery angle. It found that higher AI adoption was associated with an estimated 7.2% decrease in software delivery stability for a 25% increase in AI usage. AI made teams feel faster while, on average, making their releases slightly less reliable. That is not an argument against AI — it is an argument for keeping the humans, the review, and the tests firmly in the loop.

Now layer in a long-standing engineering truth: developers spend far more time reading code than writing it — the ratio is often cited at roughly ten to one. Vibe coding optimizes the cheap 10% (typing) and taxes the expensive 90% (understanding). A codebase nobody on the team has actually read is a codebase nobody can safely change. That is precisely the "AI-generated spaghetti two to three years from now" the original poster is afraid of inheriting.

Real numbers: rising churn, rising duplication, and a measurable dip in delivery stability. None of that says "stop using AI." All of it says "stop skipping the review step."

Best vibe coding tools won't fix a broken policy

It is tempting to frame this as a tooling debate, but the tool is not the villain. Cursor, Claude Code, and Copilot are all capable of producing clean, reviewed, well-tested code — when a competent engineer drives them that way. The same tool that ships a maintainable module on Monday can bury a team in unreviewed spaghetti on Tuesday. The variable is the workflow, not the vendor.

That is also why the fix is not another vibe coding course or a weekend vibe coding tutorial for the team. Training helps people prompt better, but it does not repair a culture that has decided reading code is optional. The organizations getting real leverage from AI treat it as a fast, tireless junior developer whose every pull request still gets reviewed — not as an oracle whose output is merged on faith. As we have written before, even the strongest models still stumble on judgment-heavy work; the best AI for vibe coding still fails at design, and the same gap applies to architecture, security boundaries, and test intent.

What this means for your project: the question to ask leadership is not "which tool" but "what is our review and testing standard, and does AI get an exemption from it?" If the honest answer is "AI is exempt," the tooling is irrelevant — the policy is the risk.

Will vibe coding stall a senior engineer's growth?

The career worry in the post is legitimate and worth separating into two halves.

Half one: skill atrophy is real. Lean entirely on AI to reason about systems and your own ability to reason about systems dulls — the same way constant GPS use erodes your sense of direction in a city you have lived in for years. A senior engineer who stops reading code, debugging from first principles, and holding the mental model of the system will, over a few years, become someone who can only supervise a machine they no longer understand. That is a genuine threat to long-term value and employability.

Half two: not all AI skill is fake skill. Learning to decompose problems for a model, to specify constraints precisely, to review AI output critically, and to catch the subtle bugs it introduces — these are becoming real, marketable senior competencies. The engineers who will thrive are not the ones who refuse AI, and not the ones who surrender to it, but the ones who direct it while keeping their own hands on the wheel.

The danger in the described company is that it is optimizing for half two while actively destroying half one. "Delete the tests and regenerate" trains people to stop understanding. That is the specific pattern that degrades a senior engineer into a spaghetti supervisor.

Should you quit? Here is what we recommend

Leaving a job is a big, costly move, so run the diagnosis before the decision.

First, separate the mandate from the method. "We are an AI-forward shop" is reasonable and increasingly common. "We delete failing tests and merge unread code" is a quality-control failure wearing an innovation costume. Confirm which one you are actually dealing with, because engineers sometimes hear the slogan and assume the worst practice, while some leaders say the slogan without meaning "abandon review."

Second, make the business case upward, once, in their language — timelines and cost, not craftsmanship. Regenerated tests raise incident rates; unreviewed code raises rework and churn; both raise the cost of every future change. Point to the GitClear and DORA findings above; they are external, credible, and hard to wave away. A CEO obsessed with speed may still respond to "this specific habit will slow us down in six months and here is the data."

Third, watch the response, because it is the real signal. If leadership engages — "show me a safer workflow that keeps the speed" — you have a company worth staying at, and you may even end up owning the standard. If they treat any review or testing as heresy and double down, they have told you the ceiling of your technical growth there, and the exit math gets simple.

Here is what we recommend: do not quit over the buzzword; do quit over the refusal to keep a quality bar. If the company will let you use AI and keep tests, review, and comprehension, stay and lead. If it insists that reading your own codebase is a waste of time, the original poster's instinct to leave is sound — that environment degrades both the product and the engineer.

Key takeaway for business

For leaders: AI belongs in your workflow, but the value is in the review-and-test discipline you keep, not the discipline you drop. The measurable risk of skipping it — rising churn, duplicated code, lower delivery stability — is documented, not hypothetical. Mandating "vibe coding" without a review standard optimizes for a fast demo today and an unmaintainable liability in two years.

For senior engineers: the threat is not AI; it is a policy that trains you to stop understanding your own systems. Use the tools aggressively, keep your hands on the design and the tests, and treat "delete the failing test and regenerate it" as the red flag it is.

And for anyone weighing the exit in that Ask HN thread: the question is not whether your company uses vibe coding tools — nearly everyone will. It is whether they let you keep the one habit that separates an engineer from a spaghetti supervisor: reading the code you are responsible for. If the answer is no and it will not change, that is a reason to move on that any hiring manager will understand.

This article is based on publicly available sources and may contain inaccuracies.

Related articles

✦SqueezeAI
  1. Vibe coding is defined by the absence of code review — the programmer accepts AI output without reading it, which distinguishes it from ordinary AI-assisted development where a human still owns every change. These two practices share a buzzword but represent fundamentally different risk profiles for production systems.
  2. Deleting failing tests and regenerating them with an AI is the concrete anti-pattern that converts a productivity tool into a liability: it removes the signal that the code is wrong rather than fixing the underlying defect.
  3. AI assistance yields genuine productivity gains on bounded, low-stakes tasks — scaffolding, boilerplate, language translation, and throwaway prototypes — so blanket rejection of the tooling is as unwarranted as mandating it for all code.

Powered by B1KEY