From Vibe Coding to Agentic Engineering: Karpathy on the Future of Programming

February 2026 — Andrej Karpathy, who coined the term "Vibe Coding," has declared it outdated. The new term is Agentic Engineering. In just one year, AI programming has gone from "coding by vibes" to autonomous agents that write code on their own. Here's what changed.

What Karpathy Said

His Post on X (February 2026)

Karpathy wrote:

"Programming is unrecognizable. There is no more 'business as usual' in software. AI agents are extremely disruptive to the default programming workflow."

And added:

"Vibe coding was fun while it lasted. We're now in the era of Agentic Engineering — where AI agents don't just suggest code, they write, test, and deploy it themselves."

Context

In February 2025, Karpathy coined the term Vibe Coding:

"Fully giving in to the vibes, embracing exponentials, and forgetting that the code even exists."

It described a way of working where the developer writes a prompt and the AI writes the code. The developer doesn't read the code closely — they trust the "vibe."

A year later, Karpathy says that's no longer enough.

The Evolution of AI Programming

2024: Code Completion

Tools: GitHub Copilot, Tabnine Model: AI completes lines of code Developer's role: Writes the code while the AI offers suggestions

# The developer types:
def calculate_total(

# The AI completes it:
def calculate_total(items):
    return sum(item.price for item in items)

Limitations:

• Understands only the current line
• No project context
• Lots of errors

2025: Vibe Coding

Tools: Claude, GPT-4, Cursor Model: AI generates entire functions/files from a description Developer's role: Describes what's needed and reviews the result

Prompt: "Write an API endpoint for creating a user with email validation"

The AI generates:
- The endpoint
- Validation
- Error handling
- Tests

Progress:

• Understands file/project context
• Generates related files
• Fewer obvious errors

Limitations:

• The developer is still at the center
• Every task has to be spelled out
• The AI doesn't take the initiative

2026: Agentic Engineering

Tools: OpenAI Codex, Claude Code, Cursor Agent, Devin Model: An AI agent completes tasks autonomously Developer's role: Sets goals and reviews the result

Task: "Add Google OAuth sign-in"

The AI agent, on its own:
1. Analyzes the current architecture
2. Studies the Google OAuth documentation
3. Creates the files it needs
4. Configures environment variables
5. Writes tests
6. Runs the tests and fixes bugs
7. Opens a PR with a description

Progress:

• Autonomous execution
• Finds information on its own
• Iterative improvement

Agentic Engineering in Detail

Definition

Agentic Engineering is an approach to software development in which AI agents:

• Autonomously complete tasks
• Iterate until they reach the goal
• Use tools (browser, terminal, IDE)
• Coordinate with each other (multiple agents for complex tasks)

Key Components

1. Autonomy The agent doesn't wait for step-by-step instructions. It gets a goal and acts.

2. Tools The agent can:

• Read and write files
• Run commands
• Search the web
• Work with APIs

3. Memory The agent remembers:

• Project context
• Previous decisions
• Errors and how they were fixed

4. Self-improvement The agent:

• Runs tests
• Analyzes errors
• Fixes them and tries again

Example Workflow

Task: "Fix the bug where users can't upload images larger than 5MB"

The agent:
1. Searches for upload-related code
2. Finds the limit in the config
3. Checks the frontend and backend
4. Changes the limit
5. Adds error handling
6. Writes a test for a large file
7. Runs the tests
8. Commits with a clear message

Agentic Engineering Tools

OpenAI Codex (2026)

Released in February 2026:

• Model: GPT-5.2-Codex
• Highlight: Full agentic mode
• Integrations: VS Code, JetBrains, terminal

Claude Code

From Anthropic:

• Model: Claude Sonnet 4.6
• Highlight: Computer Use + code
• Focus: Enterprise security

Cursor Agent

Cursor IDE:

• Model: Multi-model (Claude, GPT, DeepSeek)
• Highlight: Deep IDE integration
• Focus: Developer experience

Devin (Cognition)

The first "AI software engineer":

• Status: Beta for enterprise
• Highlight: Works like a human developer
• Limitations: Expensive and slow

What Changes for Developers

New Skills

More important:

• Defining tasks (what to do, not how)
• Architectural thinking
• Code review (of other people's code and AI code)
• Understanding systems rather than details

Less important:

• The syntax of a specific language
• Boilerplate code
• Memorizing APIs
• Routine operations

New Roles

Productivity

According to GitHub data (February 2026):

• +55% coding speed with agents
• +40% test coverage
• -30% time spent debugging

Criticism and Risks

Code Quality

Problem: Agents generate "working but messy" code. Solution: Code review remains critical.

Security

Problem: An agent with access to the file system and the internet is a risk. Solution: Sandboxing, restrictions, audit logs.

Dependence

Problem: Developers lose deep understanding. Solution: Regular "hands-on" programming and continued learning.

The Job Market

Problem: Fewer junior developers are needed. Reality: More AI supervisors are needed — the same people, but with different skills.

Practical Recommendations

How to Get Started with Agentic Engineering

1. Pick a tool

• Cursor Agent — to get started
• Claude Code — for the terminal
• Codex — for VS Code

2. Start with isolated tasks

• Refactoring legacy code
• Writing tests
• Documentation

3. Set up guardrails

• Review the git diff before every commit
• Automated tests as a gate
• A sandbox for experiments

4. Iterate

• Analyze the quality of AI-written code
• Improve your prompts
• Document patterns

Example with Cursor

# cursor-rules.md in the project root

## Rules for the AI agent:
- Always use TypeScript strict mode
- Format code with Prettier
- Write tests for every function
- Don't use any
- Log errors through our logger

Example with Claude Code

# Run a task
claude-code "Add pagination to /api/users endpoint with limit/offset"

# The agent, on its own:
# 1. Analyzes the current code
# 2. Modifies the endpoint
# 3. Updates the types
# 4. Adds tests
# 5. Shows the diff for review

The Future

Karpathy's Forecast

"In 2-3 years, most code will be written by AI agents, reviewed by humans. The programmer's job shifts from writing to directing."

What to Expect

2026-2027:

• Agents become the standard
• Integration into every IDE
• Enterprise adoption

2027-2028:

• Multi-agent systems
• AI architects
• Minimal human-written code

Conclusion

Vibe Coding was a transitional stage. Agentic Engineering is a new paradigm in which AI agents write code autonomously while humans direct and review the work.

Key takeaways:

1. Vibe Coding is outdated — it's Agentic Engineering now
2. Agents are autonomous — they search, write, and test on their own
3. The developer's role is changing — from coder to architect
4. The tools are already here — Codex, Claude Code, Cursor
5. Start now — the learning curve will only get steeper

Programming will never be the same.