Vibe Coding

You paste a prompt into the chat and watch a file tree appear. It looks like work. Sometimes it even runs. Then you spend Thursday untangling a helper the model invented, and a test you never wrote.

The 80/20 rule in vibe coding is a review rule. About 20% of the session - the spec, the tests, the look at the risky lines - creates about 80% of whether the feature ships. More prompting is the other 80%. It feels like velocity.

This is for people who already live in Copilot, Cursor, or a chat sidebar. Five bottlenecks. One drill each. Not a model bake-off.

The quick map

• Spec first - if you cannot say the outcome, the model will invent one.
• A failing check before the generate loop.
• Review the risky slice: auth, money, data, deletes.
• One chat for one job.
• Revert when the vibe is mush.

GitHub has said that in files where Copilot is on, the tool builds about 46% of the code on average, and about 61% in Java. That counts accepted suggestions in those files, not every repo on earth (GitHub on Copilot-enabled files). If half the characters can come from a model, the bottleneck is not typing. It is what you refuse to rubber-stamp.

Stack Overflow's 2025 survey found most developers already using AI tools, or planning to - and more people distrusting accuracy than trusting it (Stack Overflow Developer Survey 2025). High adoption, low trust. That is the job. The cousin page on chatting with a model without a repo is 80/20 in ChatGPT.

Spec first: the outcome the model cannot guess

Vibe coding dies when the prompt is "make it work." The model will. It will also invent a folder, a name, and a side feature you now own.

Ignored practice: pasting the prompt and hoping the agent felt what done looks like. Watch drill: the one-paragraph spec. Before you generate, write what "done" looks like in five sentences. Inputs, outputs, what must not happen. If you cannot, you are not ready to vibe. You are ready to think. The same "name the outcome" spine shows up in 80/20 in software development.

A failing check: tests before the pretty demo

A green UI is not a test. The ignored majority is generating twelve files, then asking the model to "add tests" after the design has hardened around a guess.

Watch drill: red first. Write or generate one check that fails for the real bug or the real path. Only then open the loop. If the model cannot make that check fail-then-pass, you do not have a feature. You have a demo.

Review the risky 20%: auth, money, data, deletes

Software people have said for decades that a minority of defects create most of the pain. Hedge that as a shop pattern, not a paper about your repo. AI does not cancel it. It hides it in fluent code.

Watch drill: the four-door pass. For every generated diff, search auth, payments, personal data, and delete or drop paths. Read those lines like a human wrote them to rob you. Leave the CSS for later. If you are still learning to read diffs, 80/20 in learning programming is the slower, better room.

One chat, one job

Three agents on one job is a group project with no owner. The ignored majority is pasting the same error into a second tool because the first one "felt stuck."

Watch drill: one thread. Name the tool. Paste the spec. Stay there until you revert. If you switch, start a new spec, not a pile of contradictory files.

Revert when the vibe is mush

The sunk-cost of a bad generate is one commit. The sunk-cost of "just one more prompt" is a Friday. You cannot prompt your way out of a wrong shape.

Watch drill: the 20-minute rule. If the model has not moved the failing check in twenty minutes, revert the pile. Rewrite the spec. Smaller slice. Pride is not a compiler.

Swap the low-leverage generate for the bottleneck

Illustrative: ten pull requests tagged after review. Seven fails were a missing check or an unreviewed auth path. Two were a spec the prompt never stated. One was a model that invented a second database. Prompt count never won a tag.

80/20 example: If a tool can write about 46% of a file, about 20% of your time on spec, tests, and the risky lines will still create about 80% of ship quality. The other 80% is watching tokens land.

Traps that look like flow

"If it compiles, ship it."
Compiling is the model's favorite trick. Users do not live in the compiler.

"More agents means more quality."
More agents means more owners. Quality is the check that failed first.

Fewer forced rewrites in the minutes that count

You are not trying to ban the model. You are trying to stop donating Thursday to a file tree nobody specified. Do the 20%. Let the model type the rest.

8020 move: Next session, write the five-sentence spec and one failing check before you open the chat. If you skip either, you are not vibe coding. You are gambling.

Sources & scope

• GitHub Blog, Copilot for Business - ~46% / ~61% Java in Copilot-enabled files; not all code everywhere.
• Stack Overflow Developer Survey 2025 - high AI use, trust lower than distrust.
• Defect concentration as a software-shop pattern, not a vibe-coding trial.
• Ten-PR tag log marked Illustrative:. Not a claim that AI code is safe or unsafe as a class.