Subtotal 0,00 د.إ Subtotal: 0,00 د.إ
GAP
The Gap Nobody Wants to Admit
Here’s a question I want you to sit with for a second.
When was the last time you wrote a non-trivial algorithm completely from scratch — no Copilot, no Claude, no Cursor? Not because you had to. Because you could.
For a lot of developers in 2027, that answer is uncomfortable. And that discomfort is exactly what this blog is about.
We’ve gotten very good at feeling productive. The question is whether we’re actually becoming better engineers — or just better at looking like we are.
IS IT TRAP?
Why It's a TrapWhat Is "Vibe Coding"
The term “vibe coding” was coined by Andrej Karpathy in early 2025:
“There’s a new kind of coding I call ‘vibe coding’, where you fully give in to the vibes, embrace exponentials, and forget that the code even exists… I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works.”
Andrej Karpathy, X (formerly Twitter), February 2025
Karpathy was describing a legitimate personal workflow for throwaway prototypes. The trap isn’t vibe coding itself. The trap is when production engineers start applying it to production systems.
Simon Willison, creator of Datasette, drew the critical line:
“Vibe coding does not mean ‘using AI tools to help write code’. It means ‘generating code with AI without caring about the code that is produced.'”
Simon Willison, simonwillison.net, March 2025
That distinction — not caring about the code — is where cognitive decay begins.
STOP
The Data That Should Stop You Cold
The METR Productivity Study (2025)
In mid-2025, METR conducted one of the most rigorous randomized controlled trials on AI coding productivity to date. 16 experienced developers from major open-source projects completed 246 real-world coding tasks. Before starting, developers forecast that AI would reduce completion time by 24%. After completing the study, they estimated AI had reduced time by 20%. The actual result: AI <big>increased</big> completion time by 19%.
Read that again. Developers <b>believed</b> they were 20% faster. They were actually 19% <b>slower</b>. That’s a <b>39-point gap between perception and reality</b>.
“Developers estimated that AI had increased their productivity by 20%, while the actual data showed the opposite.”
METR Research, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, July 2025.
This is “illusory productivity” in the wild — documented, measured, and undeniable.
The GitClear Code Quality Report (2024–2025)
GitClear analyzed 153 million changed lines of code, comparing patterns from 2023 to previous years before AI tools became prominent. Their finding: “AI code assistants excel at adding code quickly, but they can cause ‘AI-induced tech debt.'”
GitClear’s Bill Harding put it precisely:
“Hastily added code is caustic to the teams expected to maintain it afterward.”
Bill Harding, GitClear Founder, DevOps.com, December 2025.
Fast to write. Expensive to maintain. That’s the debugging tax — paid in full, later.
COST
A Real Cost ModelThe Debugging Tax
The “debugging tax” isn’t a metaphor. It’s an engineering economics reality.
The classic rule from research on defect costs holds:
“Defects found in production cost 100x more to fix than those caught in design.”
Barry Boehm, Software Engineering Economics, Prentice Hall, 1981
AI-generated code that’s accepted without understanding doesn’t eliminate defects. It <em>delays their discovery</em> — pushing them further right in the SDLC, where costs compound.
# The Vibe Coder Path — Fast NOW, Expensive LATER
# Day 1: AI generates authentication middleware in seconds
# Developer accepts it without reading. Looks right. Tests pass.
def authenticate_user(token: str) -> dict:
payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
return payload
# What the vibe coder missed:
# - No expiry validation
# - No algorithm whitelist enforcement
# - No token revocation check
# - SECRET_KEY hardcoded assumption
# - No exception handling for expired/invalid tokens
# Day 47: Production breach. Token replay attack.
# Developer has to debug code they never understood.
# Estimated time to fix: 3 days + incident report + customer comms
# Actual cost: 100x the time it would have taken to review once.
```
```python
# The Deliberate Engineer Path — Slightly Slower NOW, Much Cheaper LATER
def authenticate_user(token: str) -> dict:
"""
Validates JWT token with explicit security controls.
Developer understood every line before shipping.
"""
try:
payload = jwt.decode(
token,
SECRET_KEY,
algorithms=["HS256"], # Explicit whitelist — prevents alg confusion attacks
options={"verify_exp": True} # Explicit expiry validation
)
# Additional business logic — developer knows this domain
if payload.get("jti") in REVOKED_TOKENS:
raise ValueError("Token has been revoked")
return payload
except jwt.ExpiredSignatureError:
raise AuthenticationError("Token expired")
except jwt.InvalidTokenError as e:
raise AuthenticationError(f"Invalid token: {str(e)}")
# AI may have drafted this. Developer internalized every decision.
# This is the difference between vibe coding and deliberate engineering.PSYCHOLOGY
The Psychology Behind the Illusion
Why Your Brain Lies to You
The METR study’s 39-point perception gap isn’t just about productivity metrics. It’s a textbook example of what psychologists call metacognitive miscalibration — a gap between what you think you know and what you actually know.
David Dunning and Justin Kruger documented this phenomenon in their landmark 1999 paper:
"People who lack the knowledge or wisdom to perform well are often unaware of this fact. We call this the Dunning-Kruger effect."Kruger J, Dunning D. (1999).Unskilled and Unaware of It. AI tools can amplify this effect. The code runs. The tests pass. The CI pipeline is green. You feel like a 10x developer. Meanwhile, you’ve accrued cognitive debt you don’t know exists — until the 2AM production incident reveals it.
The "Pseudo-Developer" Formation
The vibe coder trap produces what experts call “pseudo-developers” — people who can generate code but can’t understand, debug, or maintain it. When AI-generated code breaks, these developers are helpless.
This tracks with what the 2025 developer studies show about professional vs. novice AI usage. Research observing 13 experienced developers and surveying 99 more found that professional developers do not vibe code. Instead, they carefully control AI agents through planning and supervision, plan before implementing, and validate all agentic outputs. They found agents suitable for well-described, straightforward tasks — but not complex ones.
The gap between professionals and pseudo-developers isn’t tool access. It’s intellectual ownership of what gets shipped.
RISK
The Business Risk CEOs and Engineering Managers Must Understand
If you’re running an engineering org, here’s the conversation you need to have with your team.
By late 2025, roughly 90% of developers across the industry were using AI tools at least once a month, with more than 40% relying on them every day. Researchers collectively warned: do not mistake output for impact.
The Stack Overflow 2025 survey highlighted that the number-one frustration for 45% of respondents is dealing with “AI solutions that are almost right, but not quite” — creating what researchers call the “Uncanny Valley of Code,” where code looks syntactically perfect but contains subtle functional defects requiring deep expertise to uncover.
Your engineers are likely measuring productivity by lines of code, PRs merged, or tickets closed. These are vanity metrics when AI is in the loop. The real questions to audit:
- What percentage of your engineers can explain their shipped code at the architecture level?
- How long does it take your team to debug a production issue that originated in AI-generated code?
- How many of your “junior” engineers are actually operating as vibe coders — shipping code they don’t understand?
The answers may be uncomfortable. But the alternative — discovering them during a critical outage or security breach — is worse.
ENGINEERING
The Escape RouteFrom Vibe Coder to Deliberate Engineer
The antidote isn’t abandoning AI. It’s developing what I call deliberate ownership of what you ship.
CARE
FrameworkThe CARE Protocol for AI-Assisted Engineering
-
C — Comprehend Before Accepting
Before accepting any AI-generated code block, answer: "Can I explain why this works to a colleague right now?" If no — read it until you can. -
A — Audit the Assumptions
AI optimizes for the common case. Your production system is rarely the common case. What edge cases did the AI not consider? What domain-specific constraints does it not know? -
R — Rewrite at Least One Module
For any significant feature, rewrite at least one component from scratch — even if the AI version was better. The act of rewriting is the learning. You're building cognitive ownership, not just shipping code. -
E — Evaluate Under Removal
Once a month: close the AI tools for one full morning. Attempt a non-trivial task solo. This is your cognitive fitness check. If it feels impossible, that's your signal.
Explore project snapshots or discuss custom web solutions.
The most dangerous kind of waste is the waste we do not recognize.
Shigeo Shingo
A Study of the Toyota Production System, 1981
Thank You for Spending Your Valuable Time
I truly appreciate you taking the time to read blog. Your valuable time means a lot to me, and I hope you found the content insightful and engaging!
FAQ's
Frequently Asked Questions
Karpathy himself clarified that vibe coding was designed for throwaway prototypes. The danger is when the prototype becomes the product — which happens constantly under delivery pressure. When production engineers vibe code, the debugging tax gets paid in incidents, security vulnerabilities, and technical debt rather than in upfront understanding. The METR 2025 study showed even experienced developers using AI tools on their own well-understood codebases ended up 19% slower — not for prototyping, but for real maintenance tasks.
No. The METR study measured specific tasks in mature open-source repositories — a context where deep domain knowledge matters more than boilerplate generation. AI tools genuinely accelerate boilerplate, scaffolding, test generation, and documentation. The lesson is precision: use AI where it adds speed without removing understanding, and be deliberate where it obscures understanding.
Start with qualitative signals: ask engineers to whiteboard-explain a recently shipped module without their laptop. Run blameless post-mortems that specifically track how many incidents originated in AI-generated code that wasn't fully reviewed. Quantitatively, track defect rate and time-to-debug for AI-assisted vs. manually written PRs. GitClear's analysis of 153M lines of code showed measurable quality degradation in AI-assisted code — your team's data will tell the same story if you look for it.
Seniority helps — but doesn't immunize. The 2025 "Professional Software Developers Don't Vibe, They Control" research (ResearchGate, 2025) found experienced developers maintain quality by staying in control of the AI. But the METR study's participants were all experienced open-source developers with an average of 5 years on their specific repositories — and they still fell prey to illusory productivity, overestimating their AI-assisted speed by 39 points. Seniority gives you better metacognition, but it requires active exercise to protect against the confidence-competence gap.
The phenomenon is grounded in established cognitive science. Metacognitive miscalibration — the gap between perceived and actual ability — has been studied since Dunning & Kruger's 1999 work (JPSP, 77(6):1121–1134). "Illusory productivity" as applied to AI-assisted work is an emerging application of this principle, now supported by empirical data from the METR 2025 RCT. It's not a buzzword — it's a measured 39-point perception-reality gap in a controlled study with real engineers doing real work.
Blogs
Related Blogs
Comments are closed