# Stop Vibe Coding: How Elite Developers Actually Use AI > Most developers believe AI makes them faster. The research shows the feeling and the measurement can point in opposite directions. Here is what experienced engineers do instead. - Author: Yadunandan Singh (https://yadunandan-singh.pages.dev/) - Published: 2026-04-07 · updated 2026-10-19 - URL: https://yadunandan-singh.pages.dev/blog/stop-vibe-coding/ - Topics: AI-Assisted Coding, Software Engineering, Research - First published on Medium: https://medium.com/@yadunandan-ai-dev/stop-vibe-coding-how-elite-developers-actually-use-ai-backed-by-real-research-da32f95c0039 ## Summary Yadunandan Singh reviews what research says about AI-assisted programming: a December 2025 study found that experienced developers keep tight control of AI agents rather than "vibe coding", and METR's randomised trial found developers who felt 20% faster were measured 19% slower. He sets out a seven-step workflow drawn from that research and Addy Osmani's process: spec first, small steps, full context, immediate tests, line-by-line review, a second model's opinion, and regular practice without AI. ## Key takeaways - Experienced developers plan, review every diff and work in small steps; they don't vibe code. - Feeling faster isn't being faster: in METR's trial, developers who believed AI made them 20% faster were 19% slower. - Write a spec first, give the model full context, and break work into small, testable chunks. - Test immediately and review every line; don't ship code you can't explain. - Practise without AI regularly to avoid skill decay. --- There's a line from a senior engineer with more than fifteen years of experience that I keep coming back to: > "I don't vibe code. I work with AI." That one sentence sums up what a growing body of research keeps finding, and it has real consequences for how you should be using AI coding tools right now. ## What the research actually found In December 2025, a team of researchers published a study with a title that gives the game away: [*Professional Software Developers Don't Vibe, They Control*](https://arxiv.org/abs/2512.14012). They watched 13 experienced developers work with AI agents (tools like Claude Code, Cursor and GitHub Copilot) in live sessions, then surveyed 99 more about how they use them. The developers valued agents as a productivity boost, but none of them handed over control. They planned before implementing. They read the diffs and tested the output. They broke big plans into small, deliberate steps, and they insisted on software quality over raw speed. The paper's own advice to developers is blunt: *do not expect to "vibe."* The same picture shows up at scale. In [Stack Overflow's 2025 Developer Survey](https://survey.stackoverflow.co/2025/ai) (more than 49,000 respondents), most developers said vibe coding is not part of their professional work, and the single most common frustration with AI tools, chosen by 66%, was code that is *"almost right, but not quite."* The best engineers aren't simply moving faster. They're moving more deliberately. ## The illusion of speed This is where it gets uncomfortable. In a randomised controlled trial, [METR](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/) asked 16 experienced open-source developers to complete 246 real tasks, with AI tools either allowed or not. Before starting, the developers predicted AI would make them **24% faster**. Afterwards, they still believed it had made them **20% faster**. The measurement said they were **19% slower**. The study has caveats worth knowing: it looked at large, mature codebases the developers already knew well, using early-2025 tools. But the gap between perception and reality is the lesson. **The feeling of productivity is not productivity.** AI produces a lot of output quickly, and much of the time it "saves" goes straight back into debugging, rethinking and unpicking what it confidently got wrong. Those mistakes also compound quietly. [CodeRabbit analysed 470 open-source pull requests](https://www.coderabbit.ai/blog/state-of-ai-vs-human-code-generation-report) (320 co-authored by AI, 150 written by people) and found that the AI-assisted ones had: - about **1.7× more issues** overall - **75% more logic and correctness errors** - **1.5–2× more security issues** - **more than 3× the readability problems** CodeRabbit sells AI code review, so read it with that in mind, but it matches what most developers experience: *the code works, until it really doesn't.* ## What experienced developers do differently Experienced engineers don't use AI as a replacement for thinking. They treat it like a fast, overconfident junior developer: genuinely useful, and never unsupervised. They hand it the work where it shines: - boilerplate and scaffolding - test generation - refactoring - exploring unfamiliar APIs And they stay hands-on for the work where mistakes are expensive: - architecture decisions - core business logic - complex debugging - security-sensitive code The difference isn't talent or tooling. It's discipline. ## The seven-step workflow What follows is synthesised from Addy Osmani's [LLM coding workflow](https://addyosmani.com/blog/ai-coding-workflow/), the study above, and the patterns that keep showing up in surveys of professional developers. ### 1. Spec first, code later Before a single line of code, force clarity. Work *with* the AI to pin down requirements, edge cases, data models and architecture. Osmani, borrowing Les Orchard's phrase, calls it a "waterfall in 15 minutes": a short, structured planning phase that makes everything after it smoother. **How to do it:** describe your idea, then ask the AI to question you until every requirement, edge case and constraint is covered. Collect the answers in a `spec.md` file and treat it as the source of truth. ### 2. Break everything into tiny steps One developer in the study told their agent, in so many words, to *"do just step 1."* That's the level of control to aim for. Some participants built plans of more than seventy steps, and still executed them one small chunk at a time. Small scope means fewer hallucinations, more coherent output and an easy rollback when something breaks. - **Instead of:** "Build a full authentication system." - **Try:** "Write a function that hashes passwords with bcrypt. Don't touch anything else." ### 3. Give it all the context AI isn't smart; it's literal. It does exactly what you describe, including every ambiguity you left in. Before a session, give it: - the relevant source files - API documentation - constraints and invariants - anti-patterns to avoid - the libraries and naming conventions already in use Tools such as `gitingest` or `repo2txt` can bundle a codebase into a form a model can read efficiently. The rule is simple: poor context in, poor code out. ### 4. Generate, then test immediately This is where most people slip: they generate, assume it works, and move on. Professionals run a tight loop instead: **generate → test → fix → repeat** Without tests, AI assumes its code works, and confidence is dangerous when it's wrong. Use test-driven development where you can: write the tests first (or have the AI write them), implement against them, run them after every chunk, and don't move on until they pass. ### 5. Review every line A good rule: *if you can't explain it to a junior developer, you don't understand it well enough to keep it.* One survey respondent in the study said they would "read every line of code before accepting." If something looks right but you don't know *why* it works, that's a red flag, not a green light. A classic example is an inverted permission check that lets deactivated users into admin tools: it reads fine at a glance, passes a happy-path test, and can sit unnoticed for weeks. Don't ship what you can't explain. ### 6. Get a second opinion Don't rely on a single model. Generate with one and review with another; if Claude wrote it, ask Gemini to critique it. Different models have different blind spots. Then add the automated layer: linters, static analysers and dependency scanners such as SonarQube or Snyk. They take minutes to set up and catch what both people and models miss. It's cheap insurance against expensive bugs. ### 7. Code without AI, regularly This is the step most people skip, and the one with the longest-term consequences: skill decay. Lean on AI for everything and the things you used to know start to feel unfamiliar. So practise deliberately without it: no autocomplete, no chat, no suggestions. Rust exercises are particularly good for this, because ownership, borrowing and lifetimes demand an understanding that AI can't shortcut for you. Osmani puts the risk well: without a solid base, AI can lead to *"Dunning-Kruger on steroids."* AI amplifies skill. It can't replace skill that was never built. ## The four most common mistakes **1. Prompting without thinking.** "Build me X" produces something that looks like ten developers worked on it without talking to each other. *Fix:* write the spec first. Fifteen minutes of planning saves hours. **2. Asking for too much at once.** Big, monolithic prompts lose coherence. The model contradicts its earlier decisions and drops requirements you set ten paragraphs ago. *Fix:* one function, one bug or one feature at a time. **3. Giving no context.** Vague prompts produce vague code. *Fix:* show the relevant files, state the constraints and name the libraries and patterns. **4. Skipping tests.** Without a test suite, "almost right" goes to production, and you find out what "not quite" means at the worst possible moment. *Fix:* write the tests first and let them be the safety net that makes AI-assisted coding viable. ## How I use this in my own work I follow this split in my own projects. When I built my [neuro-symbolic math solver](https://yadunandan-singh.pages.dev/blog/neuro-symbolic-math-solver/), an agent scaffolded the React interface from a detailed prompt, but I wrote the image-processing pipeline, trained the model and designed the evaluation step myself, because that's where a confident mistake would have broken everything. My [open-source pull requests](https://yadunandan-singh.pages.dev/about) follow the same rule: AI can help me explore an unfamiliar codebase, but nothing goes up for review that I can't explain line by line. ## The one-line formula > **Spec first. Small steps. Maximum context. Test everything. Review every line. Cross-check with a second model. Code without AI every week.** The gap between an average developer and an excellent one isn't talent, years of experience or access to better tools. It's discipline, control, and the willingness to review everything before it ships. ## A final thought Most professional developers have already rejected vibe coding, not because AI isn't powerful, but because they understand what it is. AI is a force multiplier, and like every force multiplier it scales whatever you bring to it. Bring sloppy thinking and you get sloppy code, fast. Bring disciplined engineering habits and you get something genuinely remarkable. The developers who will win with AI aren't the ones who trust it most. They're the ones who understand it most clearly, and use it accordingly. ## Sources - Huang, Reyna, Lerner, Xia and Hempel, [*Professional Software Developers Don't Vibe, They Control: AI Agent Use for Coding in 2025*](https://arxiv.org/abs/2512.14012), arXiv, December 2025. - METR, [*Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity*](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/), July 2025. - CodeRabbit, [*State of AI vs. Human Code Generation*](https://www.coderabbit.ai/blog/state-of-ai-vs-human-code-generation-report), December 2025. - Stack Overflow, [*2025 Developer Survey: AI*](https://survey.stackoverflow.co/2025/ai). - Addy Osmani, [*My LLM coding workflow going into 2026*](https://addyosmani.com/blog/ai-coding-workflow/).