AI coding assistants have split the software development world in two. On one side, you have developers maintaining professional standards. On the other, you have people who, as Andrej Karpathy describes it, “fully give in to the vibes” and essentially forget the code exists.
As explored in our comprehensive framework for AI-assisted development, this divide represents one of the most consequential choices facing engineering teams today. Augmented coding is what happens when you use AI assistance without abandoning your engineering brain. You still care about code quality, complexity, test coverage—not just whether the thing appears to work. Where vibe coding accepts whatever the AI spits out as long as it seems functional, augmented coding treats AI like a power tool that amplifies your expertise instead of replacing your judgment.
Kent Beck worked out the framework building a production B+ Tree. Simon Willison mapped out similar principles in what he calls “vibe engineering.” Chris Lattner grounds it all in decades of craftsmanship creating LLVM, Swift, and Mojo.
Let’s break down what makes augmented coding actually work.
What Is Augmented Coding?
Kent Beck defines augmented coding as keeping traditional software engineering values while using AI assistance. You care about readable code, manageable complexity, good test coverage, solid architecture, and systems that can be maintained years down the track. The AI does most of the typing, but you’re still responsible for the quality being equivalent to hand-written work.
Compare that to vibe coding. Here’s Karpathy’s description: “I ‘Accept All’ always, I don’t read the diffs anymore. When I get error messages I just copy paste them in with no comment.” Fast, loose, and frankly irresponsible.
The distinction matters because vibe code is legacy code. Nobody understands it, which makes it technical debt. Programming isn’t just about getting things to run—it’s about building understanding of what you’re creating and why. When you vibe code, you’re accumulating technical debt as fast as the LLM can generate it. If you don’t understand the code, your only option when things break is to ask the AI to fix it, which is like paying off one credit card with another.
Here’s what separates the two approaches:
What you care about: Augmented coding focuses on code quality, tests, coverage, and keeping complexity under control. Vibe coding only cares if the system appears to work.
What the AI does: In augmented coding, AI amplifies what you already know. In vibe coding, it replaces understanding.
Testing: Augmented coding uses test-driven development with proper coverage. Vibe coding does spot checks if it looks functional.
Code review: Augmented coding demands you verify everything the AI outputs. Vibe coding accepts whatever looks like it works.
Skills needed: Augmented coding amplifies expertise you’ve already built. Vibe coding tries to bypass learning entirely.
Architecture: With augmented coding, you maintain the architecture. With vibe coding, architecture just emerges from whatever the AI suggests.
Who’s responsible: Augmented coding means you’re accountable for quality. Vibe coding deflects with “the AI did it.”
Augmented coding amplifies your skills and helps you advance. Vibe coding risks your skills degrading. Augmented coding actively prevents technical debt. Vibe coding creates it at speed. Augmented coding builds systems meant to last decades. Vibe coding creates systems that work now but have uncertain futures.
Even Karpathy admits vibe coding is “not too bad for throwaway weekend projects, but still quite amusing.” The problem is habit formation. Even throwaway projects train patterns that leak into professional work.
Beck didn’t just theorise—he demonstrated augmented coding in production.
The B+ Tree Project: Augmented Coding in Practice
Kent Beck documented his augmented coding framework through the BPlusTree3 project, building a production-grade B+ Tree library in Python and Rust using AI assistance while keeping engineering standards high.
Beck tried two versions initially that became too complex, so he reset to BPlusTree3. The development used strict test-driven development and active intervention to stop the AI from overreaching.
What does “active intervention” look like? Beck watches for warning signs. Unnecessary loops showing up in code. Functionality appearing that wasn’t in the spec. Quality degrading in what the AI generates. Architectural decisions happening without oversight. Between iterations, code review keeps you in control.
Here’s where it gets interesting. When Rust’s memory model made things too complex, Beck switched to Python and got the algorithm working. Then he used Augment’s Remote Agent to convert the Python into Rust—an experimental move that worked surprisingly well.
This shows strategic AI use for well-defined, bounded tasks rather than letting it generate whatever it wants. The Rust version matches standard performance in most operations and excels at range scanning. The Python C extension runs near-native speed. The final library proved competitive with standard implementations, with high test coverage throughout.
Beck stresses that augmented coding keeps programming enjoyable while cutting out tedious work. You make more consequential decisions per hour. “Yak shaving mostly goes away”—routine tasks like coverage testing become manageable when you collaborate with AI.
Vibe Engineering: Simon Willison’s Production-Quality Framework
Vibe engineering is Simon Willison’s term for production-grade AI-assisted development where experienced engineers use large language models while staying fully accountable for code quality, testing, and architecture. Where vibe coding means “fast, loose and irresponsible” AI assistance, vibe engineering describes how experienced software engineers use LLMs responsibly.
Willison created the term to separate responsible from irresponsible AI use. The key difference: vibe engineering requires you to operate “at the top of your game” with existing expertise that AI amplifies instead of replaces.
Traditional vibe coding involves handing off simple, low-stakes tasks to AI and accepting whatever works. Vibe engineering means iterating with coding agents to produce maintainable, production-ready software.
Willison’s golden rule: “I won’t commit any code to my repository if I couldn’t explain exactly what it does to somebody else.”
His framework rests on eleven practices:
Automated testing lets agents verify functionality reliably through comprehensive test suites.
Advance planning means high-level architectural specs improve what agents produce.
Documentation helps agents navigate unfamiliar sections of code through detailed guides.
Version control discipline supports debugging and tracking changes through Git mastery.
Automation infrastructure improves consistency via CI/CD pipelines.
Code review culture speeds up iteration through productive review.
Management skills drive results through clear direction and contextual awareness.
Manual QA expertise catches edge cases automated checks miss.
Research capabilities evaluate multiple approaches to solutions.
Preview environments enable safe feature testing before production.
Strategic judgment recognises what agents handle best versus manual work.
The amplification effect is real. Advanced LLM collaboration demands operating at peak capability—you’re researcher, architect, spec writer, and quality manager combined in one role. If an LLM wrote code for you, and you reviewed it, tested it thoroughly, and made sure you could explain how it works—that’s not vibe coding, it’s software development.
Lou Franco emphasises a methodical, review-focused workflow—committing incrementally to ensure he actually understands the code being generated. How much technical debt AI introduces is up to him.
Both augmented coding and vibe engineering preserve something AI threatens: software craftsmanship, a theme central to understanding the broader strategic context of AI-assisted development.
Code Craftsmanship in the AI Era
Software craftsmanship is about code quality, solid architecture, and professional pride in creating systems that are easy to change, pleasant to use, and built to last decades. In the AI era, craftsmanship means maintaining deep understanding of your system’s architecture while strategically using AI for implementation—never handing architectural thinking over to algorithms.
As code generation becomes abundant, quality standards should rise, not fall. The focus should stay on “reliable, well-designed systems that are easy to change and a pleasure to use” rather than celebrating raw productivity.
Chris Lattner created LLVM in 2000. It’s compiler infrastructure that supports languages that didn’t exist when it was designed—now underlying Rust, Swift, and Clang. Swift is Apple’s programming language for their ecosystem. MLIR provides compiler infrastructure for modern hardware and AI. Mojo is a programming language designed to provide lasting foundations for AI development.
Lattner’s consistent approach: “understanding the fundamentals of what makes something work,” then rebuilding systems from first principles. “The reason those systems were fundamental, scalable, successful, and didn’t crumble under their own weight is” they had excellent design and engineering culture focused on technical excellence.
Software often outlives what you initially expect. LLVM succeeded because it was architected to support future languages nobody knew about yet. Building for longevity means thinking beyond immediate needs.
“Product evolution requires the team to understand the architecture of the code.” Technical excellence extends beyond individual productivity to genuinely caring about quality. Teams that understand their codebase deeply can maintain and improve it effectively.
Lattner warns that vibe coding could end careers. “When you’re vibe-coding things, you spend time waiting on agents, coaching them, and it doesn’t work.” The gambling-like loop of repeatedly prompting AI tools wastes time without building competency. Junior engineers adopting vibe coding might sacrifice their professional development.
Relying on AI without understanding creates a “career killer,” stopping the skill development necessary for meaningful work. “When things settle out, where do you stand? Have you lost years of development spending it the wrong way?”
Lattner gets “a 10 to 20% improvement” through code completion. AI is “amazing for learning a codebase you’re not familiar with.” Use it to eliminate drudgery like automating boilerplate and memorising APIs.
What concerns Lattner is delegating knowledge itself. Accepting AI-generated code without understanding compromises product quality. A senior engineer let the agentic loop rip to fix a bug, but the solution “made the symptom go away” while introducing worse problems elsewhere.
With Mojo, “we consider ourselves to be the first customer. We have hundreds of thousands of lines of Mojo code.” Dogfooding means the development team immediately encounters their own product’s shortcomings, driving genuine improvement.
Lattner prioritises “edit the code, compile, run it, get a test that fails, and iterate”—ideally within 30 seconds. He built VS Code support early for Mojo because “without tools creating quick iterations, all your work is slower, more annoying, and more wrong.”
“I don’t measure progress based on lines of code written. Verbose, redundant, not well-factored code is a huge liability.” Productivity means getting stuff done and making the product better.
AI can generate code “twice as much as a human in seconds or minutes,” but it falls short of true software craftsmanship. AI “directly answers prompts without seeking out missing context,” generating responses based on flawed assumptions. “Writing the code is usually the easy part. The hardest part is knowing what to write.”
Augmented Coding vs. Vibe Coding: A Detailed Comparison
The fundamental difference is developer responsibility and code comprehension. Augmented coding maintains traditional software engineering values while using AI assistance. Vibe coding abandons oversight entirely, accepting anything that appears to work.
Choose augmented coding when you’re building production systems needing maintenance, working on long-lived codebases expected to last more than two years, operating in team environments where code quality affects colleagues, developing professional skills, or creating any system where failure has consequences.
Vibe coding might apply for throwaway prototypes explicitly discarded after demonstration, personal learning experiments (with awareness of risks), or rapid concept validation before proper implementation. Low stakes projects where security and maintainability don’t matter might tolerate vibe coding.
But watch out. Even “valid” vibe coding use cases risk habit formation that bleeds into professional work. Watch out for secrets and data privacy when vibe coding. Be a good network citizen—anything making requests out to other platforms could increase load and cost.
Those using AI to accelerate learning will outpace those treating it as a substitute for understanding. The former gain exponential advantage; the latter face “learned helplessness.”
Skill Amplification: How AI Enhances Expert Developers
Skill amplification is the concept that AI coding tools enhance existing developer expertise rather than replace it, requiring you to operate “at the top of your game” to achieve maximum effectiveness. Unlike approaches attempting to bypass learning, amplification treats AI as a force multiplier for professionals who already understand architecture, testing, and code quality.
AI provides implementation suggestions, not architectural wisdom. Quality of AI output depends on quality of your prompts. Spotting AI errors requires deep understanding. Strategic decisions about when to use AI require experience.
Here’s the paradox. AI tools work best for experienced developers who theoretically need them least, while struggling beginners who most need help risk career damage. Experienced developers provide better prompts, spot errors quickly, and know when to intervene. Junior developers can’t evaluate AI suggestions, miss architectural problems, and develop bad habits.
Willison stresses peak performance for vibe engineering. Beck’s active intervention prevents AI overreach. Lattner emphasises understanding fundamentals enables effective AI leverage. Augmented coding isn’t democratising expertise—it’s amplifying existing capability.
The skill development pathway matters. Build foundational skills through traditional practice before adopting AI tools. Understand testing, architecture, and code quality manually before using AI. Develop judgment about good versus bad code through experience. Practice code review and quality assessment without AI assistance first.
After establishing expertise, leverage AI for implementation acceleration. Use AI for routine tasks to eliminate yak shaving. Maintain oversight and active intervention when using AI.
Beck argues that AI coding assistants fundamentally change the economics of hiring junior developers. Augmented coding means “accelerate learning while maintaining quality.” With intentional AI-assisted learning practices, Beck projects the junior developer ramp compresses from 24 months to 9 months.
Preserving Craftsmanship While Using AI Tools
Test-driven development becomes necessary when working with AI agents because tests act as guardrails against unintended consequences. Kent Beck describes AI agents as “unpredictable genies”—granting wishes in unexpected ways. AI agents can make symptoms disappear without fixing root causes.
“AI agents keep trying to delete tests to make them pass,” forcing you to maintain vigilant oversight. Writing tests before implementation ensures AI-generated code meets specs rather than creating plausible-looking solutions that fail edge cases.
Treat AI output like junior developer code. Never merge without reading and understanding. Verify alignment with architectural principles. Check for unnecessary complexity or over-engineering. Confirm test coverage is adequate. Review for maintainability, not just functionality.
Commit AI-generated changes in small, understandable increments. Maintain comprehension throughout development. Enable easy rollback if AI diverges from intent.
Keep control over system design and module boundaries, technology choices and dependency decisions, performance and scalability trade-offs, security and reliability requirements, and long-term evolution and migration paths.
Use AI for implementation of well-specified components. Boilerplate generation and routine tasks. Code transliteration between languages. Test case generation from specifications. Documentation writing from code.
Monitor for undeclared functionality beyond specifications. Watch for unnecessary loops or complexity. Verify AI doesn’t delete or modify tests. Check that architectural boundaries are respected. Ensure generated code matches team standards.
Lattner prioritises edit-compile-run-test cycles under 30 seconds. Immediate verification of AI changes enables quick course correction when AI diverges. Fast feedback loops maintain momentum and comprehension.
Addy Osmani focuses on spec-driven development, having a very clear plan of what he wants to build. “I think that tests are great. And if you’re open to tests, it can be a great way of de-risking your use of LLMs and coding.”
Wrapping It All Up
Augmented coding is Kent Beck’s disciplined approach maintaining engineering values. Vibe engineering is Simon Willison’s production-quality framework for experienced professionals. Craftsmanship is Chris Lattner’s focus on building systems that last.
Augmented coding and vibe engineering share a principle: AI amplifies existing expertise rather than replacing professional judgment. Both frameworks demand rigorous testing, active oversight, and architectural control—rejecting vibe coding’s uncritical acceptance of AI output.
Where does your team fall on the augmented coding versus vibe coding spectrum? Define quality expectations for AI-assisted development. Build foundational expertise before scaling AI tool adoption. Create culture that rewards craftsmanship and long-term thinking over short-term velocity.
For a complete overview of all considerations when navigating AI-assisted development, see our comprehensive guide to understanding vibe coding and software craftsmanship.
The choice between augmented coding and vibe coding isn’t just technical—it’s cultural, professional, and strategic. Teams maintaining engineering discipline while using AI will build systems that last and careers that thrive. Those that “fully give in to the vibes” risk both codebase sustainability and professional growth.
“What you want to get to is mastery. That’s how you escape doing what everybody can do and get more differentiation.” Deep understanding—asking hard questions, pushing toward knowledge others lack—creates career resilience regardless of AI’s pace.
