From Vibe Coding to Agentic Engineering: One Year That Changed How We Build Software
Exactly one year ago, Andrej Karpathy fired off a "shower thoughts" tweet that accidentally named a revolution: vibe coding. This week, he posted a retrospective nominating a new term for what the practice has evolved into— agentic engineering.
The shift isn't just semantic. It marks a fundamental change in how professionals build software with AI. What started as "fun throwaway projects that almost worked" has matured into a workflow where engineers orchestrate AI agents with professional-grade oversight, claiming leverage without compromising quality.
The Accidental Naming of a Movement
Karpathy reflects on the moment with characteristic humility: "I've had a Twitter account for 17 years now and I still can't predict my tweet engagement basically at all."
The throwaway tweet captured something a lot of people were feeling at the same time. By February 2025, LLMs had crossed a threshold—capable enough to generate working code, but not quite reliable enough for production. The result was a liminal workflow: you'd describe what you wanted, the AI would scaffold something close, and you'd vibe-check it into existence.
The term stuck. Now "vibe coding" appears on Karpathy's Wikipedia page as a major memetic contribution—its article longer than some of his technical work.
A lot of people quote tweeted this as 1 year anniversary of vibe coding. Some retrospective -
— Andrej Karpathy (@karpathy) February 4, 2026
I've had a Twitter account for 17 years now (omg) and I still can't predict my tweet engagement basically at all. This was a shower of thoughts throwaway tweet that I just fired off without thinking but somehow it minted a fitting name at the right moment for something that a lot of people were feeling at the same time, so here we are: vibe coding is now mentioned on my Wikipedia as a major memetic "contribution" and even its article is longer. lol
The one thing I'd add is that at the time, LLM capability was low enough that you'd mostly use vibe coding for fun throwaway projects, demos and explorations. It was good fun and it almost worked. Today (1 year later), programming via LLM agents is increasingly becoming a default workflow for professionals, except with more oversight and scrutiny. The goal is to claim the leverage from the use of agents but without any compromise on the quality of the software. Many people have tried to come up with a better name for this to differentiate it from vibe coding, personally my current favorite "agentic engineering"...
"It was good fun and it almost worked."
— Andrej Karpathy on vibe coding
That phrase—"it almost worked"—perfectly captured both the promise and the problem of early AI-assisted coding.
The Vibe Coding Era: Fast, Fun, and Fragile
Vibe coding worked best for throwaway projects, demos, and explorations. You'd spin up a prototype in an afternoon, marvel at the speed, and then hit the limitations:
- Security vulnerabilities you didn't spot in the generated code
- Architectural decisions that made sense locally but broke at scale
- Edge cases the model didn't consider
- Technical debt that compounded with each iteration
Research from METR showed a 40% higher security vulnerability rate in pure vibe-coded applications compared to traditional development. The speed came with hidden costs.
For professionals building production systems, "it almost worked" wasn't good enough. The workflow needed to evolve.
Enter Agentic Engineering
One year later, both the models and the methodology have matured. Karpathy's new term reflects this evolution:
Agentic
You're not writing code directly 99% of the time. You're orchestrating agents who write it, acting as oversight.
Engineering
There's an art and science to it. It's something you learn and get better at, with its own depth of a different kind.
The key difference: agentic engineering aims for professional quality without compromise, not throwaway demos. You claim the leverage of AI agents while maintaining the rigor of traditional software engineering.
What Changed in One Year
- Model capability: GPT-5.2 now achieves 6.6-hour autonomous task horizons
- Tool integration: VS Code shipped "Agent Sessions" as the native home for coding agents
- Agent orchestration: GitHub Copilot now supports Claude and Codex agents
- Professional adoption: Codex crossed 1M+ users; enterprises running agentic workflows
What Agentic Engineering Looks Like in Practice
At TeamDay, our founder Jozo embodies this workflow. Here's how he builds:
1. Architect the Solution
Jozo engineers the solution architecture with Claude. Not vague prompts— precise technical specifications: data models, API contracts, component hierarchies, error handling patterns.
2. Orchestrate Implementation
Claude executes the implementation. Not "write me a component"— multi-file refactors, type-safe migrations, test coverage. The agent handles the mechanical work while maintaining consistency.
3. Test and Provide Feedback
Jozo tests the implementation with real scenarios. Edge cases, performance under load, user experience flows. He acts as QA, providing specific feedback on what needs adjustment.
4. Maintain Oversight
Every change gets reviewed. Code patterns checked against project standards. Security implications considered. Architectural consistency maintained. The engineer is the final approval gate.
Notice what's different from vibe coding:
- Architecture-first instead of prompt-and-pray
- Systematic testing instead of "looks good"
- Active oversight instead of blind trust
- Production quality instead of "it almost worked"
Jozo's role isn't typist—it's orchestrator. He focuses on the problems AI can't solve: understanding user needs, making architectural tradeoffs, catching subtle bugs, maintaining long-term code health.
The Skills of an Agentic Engineer
Karpathy emphasizes that agentic engineering has "its own depth of a different kind." What does that mean in practice?
Prompt Engineering → Solution Architecture
You learn to communicate system requirements, not just task descriptions. The precision matters: vague architecture means fragile implementations.
Code Writing → Code Review at Scale
You develop pattern recognition for agent-generated code. What are the common failure modes? Which security vulnerabilities does the model miss? How do you spot architectural drift?
Debugging → Feedback Loop Design
You learn to provide feedback that improves the agent's next iteration. Not "this is wrong"—"here's why this approach won't scale, try this pattern instead."
Testing → Continuous Validation
You build systems that catch agent mistakes early. Automated tests that verify the agent understood the requirements. Type systems that enforce contracts. CI/CD that gates quality.
These aren't trivial skills. They require deep technical knowledge—you need to understand what good code looks like to recognize when the agent produces it. But the leverage is real: one engineer can maintain systems that previously required entire teams.
Vibe Coding vs. Agentic Engineering: A Side-by-Side
| Aspect | Vibe Coding (2025) | Agentic Engineering (2026) |
|---|---|---|
| Goal | Get it working quickly | Professional quality without compromise |
| Use Case | Demos, prototypes, experiments | Production systems, enterprise software |
| Workflow | Describe → Generate → Vibe-check | Architect → Orchestrate → Test → Review |
| Quality Bar | "It almost worked" | "It meets production standards" |
| Engineer Role | Prompt writer + patcher | Architect + orchestrator + reviewer |
| Model Capability | ~30min autonomous horizon | 6.6-hour autonomous horizon (GPT-5.2) |
| Security | 40% higher vulnerability rate | Systematic review + automated scanning |
| Learning Curve | Low (anyone can vibe) | Depth of a different kind (requires expertise) |
2026 and Beyond: Compounding Progress
Karpathy closes his retrospective with a prediction: "In 2026, we're likely to see continued improvements on both the model layer and the new agent layer. I feel excited about the product of the two and another year of progress."
That phrase—"the product of the two"—is key. The gains compound:
- 🧠Better models mean longer autonomous task horizons, fewer mistakes, deeper context understanding
- 🤝Better agent orchestration means multi-agent collaboration, specialized tool use, improved oversight systems
- 🔄Together they create a feedback loop: better models enable more sophisticated agent workflows, which reveal new capabilities to target
We're already seeing this play out. VS Code's "Agent Sessions" treat agents as first-class citizens. GitHub Copilot supports multiple agent backends. OpenRouter routes between 100+ models, letting developers choose the right agent for each task.
The infrastructure is maturing around the workflow. Agentic engineering isn't a fringe experiment—it's becoming the default way professionals build software.
Built BY Agentic Engineering, FOR Agentic Workflows
TeamDay embodies this philosophy at every level. The platform itself was built using agentic engineering—Jozo architecting with Claude, orchestrating implementation, maintaining oversight.
But more importantly, TeamDay is designed to support agentic workflows:
🎯 Mission-Based Architecture
Define the solution architecture as a mission. Let agents execute the implementation. Review the results. Iterate based on feedback.
🔧 Multi-Agent Orchestration
Route tasks to specialized agents. Claude for architecture, GPT-5 for rapid iteration, Codex for debugging. Use the right tool for each job.
👁️ Built-in Oversight
Review agent work within the same interface. Catch mistakes early. Provide contextual feedback. Maintain quality without micromanaging.
📊 Continuous Validation
Automated testing integrated into the workflow. Security scanning on every change. Type checking enforced. Quality gates that catch agent mistakes.
The result: you get the leverage of AI agents without compromising on quality. Exactly what Karpathy describes as the goal of agentic engineering.
From "It Almost Worked" to "It Works"
One year ago, vibe coding was the cutting edge—fast, fun, and fragile. Today, agentic engineering is the professional standard—systematic, rigorous, and reliable.
The transition matters. As Karpathy notes, the goal is to "claim the leverage from the use of agents but without any compromise on the quality of the software." That's not just a workflow change—it's a mindset shift.
Vibe coding was about speed. Agentic engineering is about leverage without sacrifice.
The engineers who master agentic workflows won't just be more productive— they'll build systems that were previously out of reach.
Not because the AI writes perfect code. Because the engineer knows how to architect solutions, orchestrate agents, test rigorously, and maintain oversight.
Karpathy is right: 2026 brings compounding progress on both the model layer and the agent layer. The product of those two improvements changes what's possible.
The question isn't whether to adopt agentic workflows. It's whether you'll develop the skills to do it well.
Experience Agentic Engineering
TeamDay is built for agentic workflows. Define missions, orchestrate agents, maintain oversight, ship production-quality software.
Try TeamDay FreeStart with agents. Scale with engineering.
References
- Andrej Karpathy's retrospective on vibe coding (February 4, 2026)
- METR security research on AI-generated code vulnerability rates
- GPT-5.2 autonomous task horizon benchmarks
- VS Code Agent Sessions documentation
- GitHub Copilot multi-agent support announcement