Why I Fail at Vibe Coding and Spec Driven Development

Introduction: The Reality of AI Development in 2025

After nearly two years of development using GenAI and Agentic AI, I've faced an uncomfortable truth. Vibe Coding and Spec Driven Development limit AI's true capabilities.

In February 2025, when Andrej Karpathy first used the term "vibe coding" on X (formerly Twitter), the tech industry was thrilled. Describe what you want to AI, don't look at the code directly, just check the results. It sounded like magic.

But less than a year later, the same Karpathy now emphasizes "Context Engineering". What happened?

In this article, from the perspective of an Application Architect and Agentic AI practitioner, I'll deeply explore why development approaches that remove context are bound to fail, and how true collaboration with AI is possible.

---

Part 1: The Allure and Trap of Vibe Coding

What is Vibe Coding?

According to Karpathy's original definition, Vibe Coding has these characteristics:

• Describe what you want to AI in natural language
• Don't review or edit the generated code
• Evaluate and request improvements based only on execution results
• Focus on iterative experimentation rather than code correctness or structure

Collins Dictionary selected this as the 2025 Word of the Year. That's how much impact it had on the industry.

Why is it Attractive?

The appeal of Vibe Coding is clear:

1. Removes entry barriers: Create apps without programming experience
2. Speed: Complete prototypes in hours
3. Focus on creativity: Concentrate on ideas instead of implementation details

Many startups actually launched MVPs quickly using this approach. Initially, it seemed successful.

The Real Cost

But by late 2025, reality began to emerge. According to TechStartups.com:

"Thousands of startups are now paying the price for AI-generated technical debt."

Specific problems:

1. Context Collapse

LLMs have limited context windows. As projects grow with Vibe Coding, AI forgets previous decisions. The result:

• Inconsistent code styles
• Duplicated logic
• Conflicting implementations

2. Security Vulnerabilities

If you don't review code, you can't discover security issues. According to Snyk's analysis, common problems found in Vibe Coding generated code:

• SQL Injection vulnerabilities
• Hardcoded credentials
• Improper input validation
• Insecure dependencies

3. Unmaintainable Code

"Working" code and "maintainable" code are different. Vibe Coding results in:

• No documentation
• No tests
• Incomprehensible structure
• Impossible to debug

Thoughtworks' Ken Mugrage described this as "complacency with AI generated code". Complacency about AI-generated code is the core of the problem.

---

Part 2: The Fundamental Limitations of Spec Driven Development

What is Spec Driven Development?

After recognizing Vibe Coding's problems, many teams switched to Spec Driven Development. This approach:

1. Write detailed specifications first
2. Request AI to implement according to specs
3. Verify that results match specifications

It looks more systematic. But there are two fatal problems here too.

Problem 1: Removal of Context

Specs only convey "what to build." But what AI really needs is much richer context:

What Specs Convey:

• Functional requirements
• I/O formats
• Constraints

What AI Really Needs:

• Why are we building this?
• How does the existing system work?
• What attempts have failed?
• What are the team's coding conventions?
• What's the background of performance requirements?

Let's examine why this difference matters from an Agentic AI perspective.

The Relationship Between ReAct Pattern and Context

One of the core patterns of Agentic AI, ReAct (Reasoning + Acting), works as follows:

1. Reason: Analyze current state and goal to determine next action
2. Act: Execute determined action (tool use, API calls, etc.)
3. Observe: Observe results
4. Iterate: Repeat until goal achievement

The key here is "current state". For AI to reason effectively, it needs rich context about the current state.

Specs provide only the goal and remove the current state. As a result:

• AI performs simple generation instead of reasoning
• Without context, it tries to find "the answer" by applying only general patterns
• Cannot reflect the project's specific requirements

Spec Driven Development degrades Agentic AI to a mere code generator.

Problem 2: Absence of Iteration

Here's an even more fundamental problem. A single development cycle is useless.

Let's face the reality of software development:

Actual Development Process:
Requirements → Implementation → Feedback → Modification → Feedback → Modification → ... → Complete

Spec Driven Assumption:
Specification → Implementation → Complete

This gap is the problem.

Why Iteration is Essential:

1. Requirements change: Customers only know what they really want after seeing the result
2. Unpredictable problems: Unexpected technical constraints discovered during implementation
3. Learning and improvement: First versions always have room for improvement
4. Feedback loop: Real user reactions determine direction

In Spec Driven Development, iteration becomes:

Spec v1 → Implementation → "Oh, this isn't right"
→ Spec v2 → Implementation → "Almost there..."
→ Spec v3 → Implementation → Repeat...

Every time you write a new Spec:

• Previous context is lost
• AI doesn't know why changes were made
• Possibility of repeating the same mistakes
• Difficult to maintain consistency

Thoughtworks Technology Radar also points this out:

"There are questions about how we remain adaptable and flexible while also building robust contextual foundations for AI systems with spec-driven development."

---

Part 3: Context Engineering - The Right Direction

From Prompt Engineering to Context Engineering

In mid-2025, the industry discourse began to shift. Andrej Karpathy presented a new direction:

"Context engineering is the delicate art and science of filling the context window with just the right information for the next step."

Simon Willison (Django co-creator) also supported this:

"The term prompt engineering makes people think it's 'typing something into a chatbot.' The inferred definition of context engineering is much closer to the intended meaning."

Shopify CEO Tobi Lutke agreed:

"I really like the term context engineering over prompt engineering. It describes the core skill better: the art of providing all the context for the task to be plausibly solvable by the LLM."

What is Context Engineering?

Context Engineering is not simply writing longer prompts. It's about building dynamic systems:

Prompt Engineering: Writing static instructions
Context Engineering: Building systems that provide the right information at the right time

Core components:

1. Task Description: Clear explanation of the task
2. Few-shot Examples: Examples of desired output
3. RAG (Retrieval Augmented Generation): Retrieval of relevant documents/code
4. State and History: Record of previous conversations and decisions
5. Tools: Available tools and how to use them
6. Constraints: Constraints and guardrails

Practical Application: Context-First Development

Here's the approach that has worked for me.

Before (Spec Driven):

"Implement user authentication.
- Use JWT tokens
- 1 hour expiration
- Support refresh tokens"

After (Context Engineering):

"Let me explain our system:

[Current State]
- B2B SaaS platform, currently using session-based auth
- About 10,000 users, max 500 concurrent connections
- Existing codebase is Express.js + PostgreSQL

[Reason for Change]
- Mobile app launch planned, need stateless auth
- Microservices transition planned

[Constraints]
- Need to migrate existing user sessions
- Minimize downtime essential
- Must pass security audit

[Past Attempts]
- Tried OAuth2 6 months ago but rolled back due to complexity

[Question]
What's the best approach to transition to JWT-based auth in this context?
Please suggest a strategy first, and I'll review before we proceed with implementation."

See the difference?

In the second approach, AI can:

• Reason (understand why this change is needed)
• Consider context (existing system, constraints)
• Learn from past failures (OAuth2 rollback experience)
• Suggest strategy first (not immediate code generation)

---

Part 4: The Right Collaboration Model for Agentic AI

AI is a Collaborator, Not a Tool

The common error in Vibe Coding and Spec Driven Development is treating AI as a tool.

Tool Perspective: Input → Process → Output
Collaborator Perspective: Share Context → Discuss → Agree → Execute → Feedback → Improve

The core capability of Agentic AI is autonomous reasoning. To leverage this capability:

1. Pose problems, don't dictate solutions
2. Let AI ask questions
3. Review AI's reasoning process
4. Accumulate feedback as context

Practical Workflow

Here's the workflow I use:

Phase 1: Context Building

1. Explain project background
2. Share current architecture
3. Define the problem to solve
4. Specify constraints
5. Share past attempts and results

Phase 2: Exploratory Conversation

1. Ask AI to suggest approaches
2. Discuss pros and cons of each approach
3. Check if there are additional questions
4. Reach agreement on chosen approach

Phase 3: Incremental Implementation

1. Request implementation in small units
2. Review each step
3. Provide feedback (this becomes the next context)
4. Proceed to next step

Phase 4: Building Guardrails

1. Write tests for generated code
2. Documentation
3. Apply code review checklist
4. Security review

Maintaining Context Continuity

The most important thing in iteration is context continuity.

# Conceptual structure
class DevelopmentSession:
    def __init__(self):
        self.context = {
            "project_background": "",
            "architecture": "",
            "decisions_made": [],
            "feedback_history": [],
            "constraints": [],
            "lessons_learned": []
        }
    
    def add_decision(self, decision, reasoning):
        self.context["decisions_made"].append({
            "decision": decision,
            "reasoning": reasoning,
            "timestamp": now()
        })
    
    def add_feedback(self, feedback, outcome):
        self.context["feedback_history"].append({
            "feedback": feedback,
            "outcome": outcome
        })
        # This feedback becomes context for the next AI call

Ways to implement this in practice:

1. agents.md / CLAUDE.md: Maintain context documents for AI at project root
2. Context7 MCP: Integrate external documents as context
3. Mem0: Utilize long-term memory systems
4. Reference Application: Provide reference implementations as context

Thoughtworks calls this "anchoring coding agents to a reference application". Providing AI with contextual ground truth.

---

Part 5: Why This Matters

The Time Bomb of Technical Debt

Code quickly created with Vibe Coding is a time bomb.

Month 1: "Wow, we can build this fast!"
Month 3: "Where did this bug come from?"
Month 6: "Who can understand this code?"
Month 12: "It would be faster to rebuild from scratch"

By late 2025, this scenario is becoming reality at thousands of startups.

The True Value of Agentic AI

Agentic AI is not just a code generator. When properly utilized:

• Decompose complex problems and solve step by step
• Combine multiple tools to perform tasks
• Self-verify to ensure quality
• Continuously learn to improve

These capabilities are only realized when context exists.

The Changing Role of Developers

In the Context Engineering era, the developer's role is:

Past: Code writer
Present: Context designer + Quality verifier + Architect

Time spent directly writing code decreases, but more important roles emerge:

1. Context Design: Building environments where AI can work effectively
2. Quality Verification: Reviewing and improving AI outputs
3. Architecture Decisions: Maintaining system-wide consistency
4. Building Guardrails: Ensuring safe and maintainable systems

---

Part 6: Practical Guide

Starting Today

1. Create Context Documents

Create a CONTEXT.md or agents.md file at your project root:

# Project Context

## Overview
[What the project is, why it exists]

## Architecture
[Current system structure]

## Conventions
[Coding conventions, naming rules]

## Constraints
[Technical/business constraints]

## History
[Key decisions and their reasons]

## Lessons Learned
[Past failures and lessons]

2. Change Conversation Patterns

❌ "Build X feature"
✅ "We're trying to solve X problem in our system.
   The current situation is this, constraints are these.
   What approach would be good?"

3. Convert Reviews to Context

After reviewing AI's output:

"This part is good, but needs modification to Z because of Y.
Please consider this point in similar situations going forward."

As this feedback accumulates, AI generates increasingly project-appropriate outputs.

4. Incremental Implementation

Don't request everything at once:

Step 1: Strategy discussion
Step 2: Core logic implementation
Step 3: Review and feedback
Step 4: Edge case handling
Step 5: Test writing
Step 6: Documentation

Each step's result becomes context for the next step.

Anti-patterns to Avoid

1. "Just build it" syndrome: Requesting results without context
2. Spec bombing: Throwing massive specifications at once
3. Skipping review: Using AI output without review
4. Context reset: Starting from scratch every conversation
5. Tool treatment: Treating AI as a tool rather than collaborator

---

Conclusion: Context is Everything

Vibe Coding is the illusion that "AI will figure it out." Spec Driven Development is the misconception that "clear instructions are enough."

Both remove context and ignore iteration.

Real AI utilization is different:

1. Provide sufficient context
2. Let AI reason
3. Review results
4. Accumulate that review as context again

This is Context Engineering. This is how to properly leverage Agentic AI.

This is why Karpathy created Vibe Coding and then transitioned to Context Engineering. This is why Simon Willison, Tobi Lutke, and Thoughtworks all point in the same direction.

AI is not a tool but a collaborator. Collaborators need context.

Software development doesn't end with a single implementation. Iteration is the essence. And for effective iteration, context continuity is essential.

In 2025, the paradigm of AI development methodology is changing. It's time to wake up from the illusion of Vibe Coding and move toward the reality of Context Engineering.

---

References

1. Karpathy, A. (2025). "Vibe Coding" - X/Twitter post, February 2025
2. Karpathy, A. (2025). "Context Engineering" - X/Twitter post, June 2025
3. Willison, S. (2025). "Context Engineering" - simonwillison.net
4. Mugrage, K. (2025). "From vibe coding to context engineering: 2025 in software development" - Thoughtworks
5. Thoughtworks Technology Radar Vol. 33 (2025)
6. "The Vibe Coding Delusion" - TechStartups.com, December 2025
7. "Why Vibe Coding Fails at Scale" - juanfernandopacheco.com, July 2025
8. Snyk (2025). "Is Vibe Coding Secure?"

---

If this article was helpful, please share your AI utilization experiences too. How are you applying Context Engineering?