Module 1: The Paradigm Shift — AI in Software Development
Agentic Development vs Vibe Coding vs Traditional Development
Capsule description
There are many ways to use AI for code. The problem is that most developers don't distinguish between them — and mix them without judgment. The result: sometimes AI helps them, sometimes it slows them down, and they don't know why.
This capsule defines three ways of working with AI precisely. These aren't categories we invented — they're observable patterns in how developers actually interact with AI tools. Understanding them lets you identify which mode you operate in most of the time, and consciously decide when each mode is appropriate.
By the end of this capsule, you'll have a framework for evaluating your own practice. And you'll complete two reflection exercises — your "before" statement and your personal classification — that connect directly with the guide's final project.
The Three Modes
When a developer uses an AI tool for code, their interaction falls into one of three patterns:
┌─────────────────────────────────────────────────────────────────────┐
│ │
│ TRADITIONAL DEVELOPMENT VIBE CODING AGENTIC DEV │
│ │
│ The developer writes AI generates, The developer │
│ all the code. the developer directs, AI │
│ AI doesn't participate. accepts. executes. │
│ │
│ Control: 100% human Control: ~AI Control: human │
│ Speed: your speed Speed: high with AI assist │
│ Verification: you Verification: little Verification: │
│ Quality: depends on you Quality: variable systematic │
│ │
│ "I do it all" "AI does it, I "I direct, │
│ accept it" AI executes, │
│ I verify" │
│ │
└─────────────────────────────────────────────────────────────────────┘
None of these modes is inherently "good" or "bad." Each one has a context where it's appropriate. The problem isn't using one or the other — it's using the wrong one for the situation, or mixing them without being aware of which one you're using.
Mode 1: Traditional Development (Without AI)
What it is
The developer writes all the code, makes all the decisions, and verifies everything on their own. AI tools don't participate in the development process.
What it looks like in practice
1. Developer reads the requirements
2. Developer researches and plans
3. Developer writes code
4. Developer debugs and tests
5. Developer does code review
6. Developer commits and deploys
Every step is 100% human. The editor may have basic autocomplete (IntelliSense, snippets), but there's no LLM generating code or agent executing actions.
When it makes sense
- Security-critical code where you need guarantees AI can't give
- Regulated context (healthcare, fintech) where every line must be audited by humans
- Deep learning of a new concept — writing the code yourself solidifies the understanding
- Very domain-specific problems where AI has no relevant training data
- When AI consistently generates useless output for your particular stack or use case
When it does NOT make sense
- Boilerplate and scaffolding — writing repetitive code by hand is wasted time
- Exploring unfamiliar APIs — AI can generate working examples faster than reading docs
- Mechanical refactoring — renaming variables, updating imports, reformatting — it's work that doesn't require human creativity
The risk
The risk of pure traditional development in 2025-2026 isn't that it's "bad" — it's that it's increasingly slow relative to the market. If your team doesn't use AI and the competition does (and uses it well), delivery speed becomes a competitive disadvantage.
But: speed without quality is worse than slowness with quality. Traditional development produces code the developer is 100% responsible for and 100% aware of. That has value.
Mode 2: Vibe Coding
What it is
The term "vibe coding" was coined by Andrej Karpathy (co-founder of OpenAI) in February 2025. It describes a way of working where the developer trusts the "vibe" of the AI output — if it looks correct, if it works when run, it's accepted without deep analysis.
Karpathy's original definition:
"I just see things, say things, run things, and copy things, and it mostly works."
What it looks like in practice
1. Developer gives AI a prompt (vague or specific)
2. AI generates code
3. Developer quickly looks at the output
4. If it "looks good" → accepts
5. If it doesn't work → asks AI to fix it
6. Repeats until it works
7. Commits
Verification is reduced to "it works when I test it once." There's no analysis of the generated code, no security review, no consideration of maintainability. The logic is: "if it passes the tests (if there are tests), it's good enough."
An important nuance: it's not always negative
Karpathy didn't coin the term as an insult. He used it to describe a way of working that makes sense in certain contexts:
- Quick prototypes that no one is going to maintain
- Personal scripts for one-time use
- Exploration of an idea before investing time in serious implementation
- Learning projects where the goal is to see what AI produces, not to create production software
When it becomes problematic
Vibe coding becomes an anti-pattern when:
- The code goes to production. Unreviewed code with security flaws (45%, Veracode) is a real risk
- Other developers are going to maintain it. Code that "works" but no one understands is instant technical debt
- There are no tests. "It works when I test it" isn't a guarantee of anything
- It's the default mode. Using vibe coding for EVERYTHING — including critical code — is the most common anti-pattern
Signs you're doing vibe coding
✓ You accept AI code without reading it fully
✓ Your main criterion is "it works when run"
✓ You don't write tests for AI-generated code
✓ You can't explain why the code works
✓ When something fails, you ask AI to fix it
without understanding what failed
✓ Your prompt history is: "do X" → "it doesn't work, fix it"
→ "still doesn't work" → "try another way"
If you recognize 3+ of these signs in your usual workflow, you're operating in vibe coding mode most of the time.
The data on vibe coding
The METR study didn't measure "vibe coding" directly, but the perception-reality gap (+20% perceived, -19% real) is consistent with what you'd expect from vibe coding: it feels fast because you're always generating code, but the net result is slower because the generated code needs more debugging, more rework, and more corrections.
The Stack Overflow data (66% say "almost right, but not quite") describes exactly the output vibe coding produces: code that looks correct but has subtle errors that are only discovered later.
Mode 3: Agentic Development
What it is
Agentic development is a way of working where the developer actively directs an AI agent: they define the task precisely, supervise the execution, verify the result, and keep control of the process. AI executes — you direct and verify.
It's not "letting AI do everything" (that's vibe coding). It's not "doing everything without AI" (that's traditional development). It's a collaboration mode where each party does what it does best:
Developer: AI Agent:
→ Defines the goal → Explores the codebase
→ Sets constraints → Generates the implementation
→ Evaluates the approach → Executes and tests
→ Verifies the result → Iterates if something fails
→ Makes design decisions → Applies the decisions
→ Approves or rejects → Adjusts based on feedback
What it looks like in practice
1. Developer researches and understands the problem
2. Developer plans the approach (may use AI for this)
3. Developer gives precise instructions to the agent
4. Agent explores the codebase, proposes a plan
5. Developer evaluates and adjusts the plan
6. Agent executes: generates code, runs tests
7. Developer reviews the output with technical judgment
8. If it passes review → accepts
9. If not → gives specific feedback, agent iterates
10. Developer verifies integration and commits
The difference from vibe coding isn't the tool — it's the level of supervision, verification, and professional judgment you apply.
The principles of agentic development
1. Research before acting
Before asking the agent for something, invest time in understanding the problem. Read the existing code. Understand the dependencies. Define what "correct" means for this task.
❌ Vibe coding: "Add authentication"
✅ Agentic: "I need JWT authentication with refresh tokens.
The project uses FastAPI, there's already a User
model in models/user.py. Tokens should expire
in 15 minutes. Use PyJWT."
2. Plan before executing
Ask the agent to plan before coding. Evaluate the plan. Adjust if necessary. Only after aligning on the approach, let it execute.
❌ Vibe coding: "Do it" → "No, not like that" → "Try another way"
✅ Agentic: "First show me your plan" → [you evaluate] →
"Adjust X and Y" → "Okay, execute"
3. Verify, don't assume
Don't assume the generated code is correct just because it looks good or because "AI is good at this." Read the code. Run the tests. Review edge cases. Verify security.
❌ Vibe coding: "It works" → commit
✅ Agentic: "It works" → review → tests → security check → commit
4. Iterate with specific feedback
When the output isn't correct, don't say "fix it." Give specific feedback: what's wrong, why, and what you expected.
❌ Vibe coding: "It doesn't work, fix it"
✅ Agentic: "The handle_login function returns 200 when
the credentials are invalid. It should
return 401 with a descriptive error
message. Look at line 45."
The fundamental workflow
Agentic development follows a workflow that Module 06 goes deeper into:
Research → Plan → Execute → Validate
│ │ │ │
│ │ │ └─ Is the result correct?
│ │ │ Is it secure? Is it tested?
│ │ │
│ │ └─ AI executes under your supervision
│ │
│ └─ Align on the approach before coding
│
└─ Understand the problem before proposing solutions
Each step has a purpose. Skipping one doesn't make you faster — it makes you more prone to errors that will take longer to correct.
Comparison: The Three Modes
| Criterion | Traditional | Vibe Coding | Agentic Development |
|---|---|---|---|
| Who writes the code | Developer | AI | AI, directed by the developer |
| Level of supervision | N/A | Low | High |
| Verification | By the developer | Minimal ("it works") | Systematic (review + tests) |
| Perceived speed | Low | Very high | High |
| Real speed | Predictable | Variable (high if it works, very low if not) | High and consistent |
| Output quality | Depends on the developer | Variable, often "almost right" | High (verified) |
| Technical debt | Normal | High (code not understood) | Low (code reviewed) |
| Security risk | Normal | High (45% flaws, unreviewed) | Low (verified) |
| When AI doesn't know the domain | Works well | Disastrous | Works (developer guides) |
| Team scalability | Proven | Problematic | Proven + accelerated |
Concrete trade-offs
Traditional vs Agentic:
- Traditional gives you total control but is slower for tasks AI solves well
- Agentic gives you speed but requires verification discipline
- In a team, well-implemented agentic development produces more quality code per unit of time
Vibe Coding vs Agentic:
- Vibe coding is faster in the short term (you don't verify)
- Agentic is faster in the medium term (less rework, fewer bugs)
- The difference amplifies over time: vibe coding accumulates technical debt, agentic doesn't
Can you mix modes?
Yes — and you should. A professional developer knows when to use each mode:
Quick prototype to validate an idea → Vibe coding (ok)
Feature for production → Agentic development (necessary)
Security-critical algorithm → Traditional or agentic with extra review
One-time personal script → Vibe coding (ok)
Onboarding to a new codebase → Agentic (AI as guide + your analysis)
The key isn't to be "100% agentic" — it's to be aware of which mode you're using and why.
Why Methodology Matters More Than the Tool
This is the central argument of the entire guide:
Developer A: Developer B:
→ Claude Code (top tool) → Any tool
→ Vibe coding (no methodology) → Agentic development (with method)
→ Result: fast but fragile code, → Result: fast AND robust code,
subtle bugs, growing technical verified, maintainable
debt
Developer A has the best tool available. Developer B could be using Copilot, Cursor, or Claude Code — it doesn't matter. The difference is in how they work, not in what they use.
The data confirms it:
- METR Study: The difference between developers who were faster with AI and those who were slower wasn't the tool — it was the methodology
- Stack Overflow 2025: 65% use AI daily, but only 3% highly trust the output. The gap isn't about tools — it's about practice
- Veracode 2025: 45% of AI code has security flaws. The tool generated it — the developer should have verified it
This guide exists to teach you the fundamentals that make any tool effective. Modules 02-04 give you the technical understanding. Modules 05-06 give you the working framework. Module 07 gives you the practical experience.
The Spectrum, Not the Binary
In practice, the three modes aren't rigid categories — they're points on a spectrum:
100% Traditional ◄──────────────────────────────────────► 100% Vibe
│ │
│ │
│ ┌──────────────────┐ │
│ │ AGENTIC │ │
│ │ DEVELOPMENT │ │
│ │ │ │
│ │ The sweet spot │ │
│ │ for production │ │
│ └──────────────────┘ │
│ │
▼ ▼
High control Low control
Low speed High speed
High confidence Low confidence
in the result in the result
A professional developer moves along this spectrum consciously:
- More toward traditional when the risk is high (security, sensitive data, regulated code)
- More toward vibe when the risk is low (prototypes, personal scripts, exploration)
- In the center (agentic) for everyday production work
The skill isn't "being 100% agentic" — it's knowing where to place yourself on the spectrum for each task, and doing it consciously.
Analogy: The Pilot and the Autopilot
An airplane pilot has three modes available:
Full manual (traditional):
→ The pilot controls everything
→ Appropriate for takeoff, landing, emergencies
→ High effort, maximum control
Autopilot with supervision (agentic):
→ The autopilot executes, the pilot supervises
→ Appropriate for cruising in normal conditions
→ Lower effort, high control
Autopilot without supervision (vibe):
→ The autopilot executes, no one is actively supervising
→ NEVER appropriate in professional aviation
→ In software: appropriate only for disposable code
Professional pilots don't choose "manual or autopilot" — they choose when to use each mode. The same applies to professional developers with coding agents.
The Likely Evolution of These Modes
We don't know exactly how AI tools for code will evolve. But we can make informed predictions about the ways of working:
Traditional development doesn't disappear — it gets redefined
Development without AI will probably become a specialized niche for security-critical, regulated code, or code that requires guarantees AI can't give. It doesn't disappear, but it becomes the exception, not the norm.
Vibe coding gets professionalized or disappears
As the consequences of unverified code become more evident (security breaches, lawsuits, loss of user trust), the pressure to verify code — regardless of who generated it — increases. Pure vibe coding survives in prototypes and personal scripts, but becomes unacceptable for production.
Agentic development becomes the standard
As agents become more capable, the Research → Plan → Execute → Validate workflow adapts but doesn't disappear. Agents can do more of the "Execute" and part of the "Validate" — but the "Research" and the "Plan" still require human judgment. The developer becomes more of a director and less of a builder, but never stops being responsible.
Module 05 goes deeper into the developer's role as director — including mental models, trust calibration, and when to delegate vs when to do it yourself.
Connection with the Final Project
In Module 07, you'll build a mini coding agent. When you have it working, you'll observe how it makes decisions — and you'll document what you observed. Your personal classification (are you a vibe coder, traditional, or agentic developer?) is the starting point for that analysis.
If you classify yourself as a vibe coder now, by the end of the guide you should be able to explain why an agentic approach produces better results — and to have experienced it by building the mini-agent.
If you classify yourself as a traditional developer, by the end you should be able to articulate what you gain by incorporating AI with methodology — and what you feared that turned out to be manageable.
If you already consider yourself an agentic developer, by the end you should have the vocabulary and framework to explain why you do what you do — and data to back it up.
Troubleshooting
Problem 1: "I do all three — which one am I?"
Cause: Most developers mix modes depending on the task, tiredness, urgency.
Solution: That's normal. The question isn't "which one are you?" but "which one is your default mode?" — the way you work when you're not actively thinking about how you work. That's the mode that defines your average productivity.
Problem 2: "Vibe coding works well for me"
Cause: It may be true in the short term or for certain types of tasks.
Solution: Two verification questions: (1) Do you have objective data that it works, or is it perception? (Remember the METR study gap). (2) Is the code you produce with vibe coding maintainable by others? If the answer to both is honestly "yes" — then you're doing something right, possibly with an unconscious verification you're not recognizing as such.
Problem 3: "Agentic development sounds like more work, not less"
Cause: Systematic verification seems to add steps.
Solution: It adds verification steps but eliminates rework cycles. It's like investing 10 minutes planning a route vs losing 40 minutes lost. The net time is lower with agentic development — but the effort is distributed differently (more upfront, less downstream). Module 06 demonstrates this with concrete frameworks.
Exercises
Exercise 1: Your "before" statement (Easy)
Write 5-7 sentences about what you currently think you know about coding agents. Don't research — write what you genuinely believe at this moment. Cover:
- What is a coding agent?
- How do you think they work on the inside?
- What do you think their main limitations are?
- When do you think AI is most useful for code?
- When do you think it's counterproductive?
See reflection guide
There's no "correct" answer — this exercise is your personal baseline. At the end of the guide (after Module 07), you'll reread what you wrote here and compare it with what you learned.
Tips for doing it well:
- Be honest. If you don't know something, write "I don't know." It's more useful than making up an answer
- Be specific. "AI is useful" is vague. "AI is useful for generating boilerplate but not for complex business logic" is specific
- Don't judge yourself. Whatever you write, it's your starting point. The point is for it to change (or get refined) after 7 modules
Example of a real "before" statement:
"I think a coding agent is a program that uses an LLM to generate code. It works by sending your prompt to a model like GPT or Claude and returning the answer. Its main limitations are that it hallucinates (generates code that doesn't work) and doesn't really understand the context. I think AI is most useful for writing repetitive code and less useful for architecture or complex logic. I think it's counterproductive when you trust too much in what it generates."
Save this statement somewhere you can consult it after Module 07.
Exercise 2: Your personal classification (Easy)
Based on the definitions in this capsule, classify yourself honestly:
Step 1: Read the following statements and mark how many apply to your usual way of working with AI:
Signs of vibe coding:
- I accept AI code without reading it fully
- My main criterion is "it works when run"
- I rarely write tests for AI-generated code
- When it fails, I ask AI to fix it without analyzing the error myself
- I couldn't explain why the code AI generated works
Signs of agentic development:
- I read and review the code AI generates before accepting it
- I give specific instructions (not just "do X")
- I ask the agent to plan before executing
- I verify with tests and review before committing
- I give specific feedback when something isn't right
Signs of traditional development:
- I don't use AI tools for code
- I prefer to write everything myself
- I only trust my own code
- AI tools seem unreliable to me
- I don't see enough benefit to change my workflow
Step 2: Which category did most of your answers fall into? That's your current classification.
See guided reflection
If most were vibe coding (3+ signs):
It's not a judgment. Many developers start this way because the tools incentivize this mode (they generate code fast, the temptation to accept is high). Modules 05 and 06 will give you concrete frameworks to transition to agentic development without losing speed.
If most were agentic development (3+ signs):
Good — you already have good habits. What this guide will give you is the understanding of WHY what you do works. Understanding the internal mechanics of agents (Modules 02-04) will let you be even more precise in how you direct them.
If most were traditional development (3+ signs):
There's value in your rigor. What this guide will show you is how to incorporate AI without losing that rigor — keeping the control and verification you value, but speeding up the parts of the work that don't require your creativity or judgment.
If it was mixed (no dominant category):
That's the most common. The goal isn't to be "100% agentic" — it's to be aware of when you're in each mode and choose the appropriate one for the situation.
Save your classification. At the end of the guide, repeat this exercise and compare.
Exercise 3: Classify scenarios (Medium)
For each scenario, indicate which way of working would be most appropriate and briefly justify:
- You're building a prototype for a demo tomorrow. It's not going to production.
- You're implementing the authentication for a fintech application.
- You're learning a new programming language.
- You're refactoring 50 files to rename a function.
- You're writing a personal script to organize your photos.
- You're designing the architecture of a distributed system.
See solution
| Scenario | Recommended mode | Justification |
|---|---|---|
| 1. Prototype for a demo tomorrow | Vibe coding | Speed is the priority, it's not going to production, technical debt doesn't matter |
| 2. Fintech authentication | Agentic or traditional | Security-critical. If you use AI, with extreme supervision and security review. Unverified code here is a legal risk |
| 3. Learning a new language | Traditional or agentic | If you let AI write everything, you don't learn. Traditional for fundamentals. Agentic to explore: "explain what this does" with your own analysis |
| 4. Refactoring 50 files | Agentic | A mechanical task perfect for AI. But verify the renaming didn't break anything (tests, imports, references) |
| 5. Personal photo script | Vibe coding | Low risk, personal use, disposable code. Perfect for vibe coding |
| 6. Distributed system architecture | Traditional or agentic (Research + Plan) | AI can help research patterns and trade-offs, but the architectural decisions are yours. AI doesn't have enough context about your business, users, and constraints |
Key insight: The correct mode depends on the context, not on a universal rule. The skill is in choosing consciously.
Exercise 4: Analyze the team impact (Medium)
Imagine a team of 5 developers. 3 use vibe coding as their default mode, 1 uses agentic development, and 1 is a traditional developer. Answer:
- How does it affect the team that 3 out of 5 do vibe coding?
- What problems do you expect to see in code reviews?
- How would the dynamic change if all 5 used agentic development?
See solution
1. Impact of 3/5 vibe coders on the team:
- High PR velocity (many features fast)
- But a high rate of bugs discovered after merge
- Technical debt accumulating rapidly
- The traditional developer and the agentic developer end up doing extra review of the vibe coders' code
- The 2 most rigorous developers become quality bottlenecks
2. Problems in code reviews:
- Code that "works" but no one fully understands
- Large PRs without meaningful tests
- Logic correct on the surface but with unconsidered edge cases
- Variables and functions with generic names (generated by AI without context)
- Pattern: the reviewer spends more time understanding the code than the author spent writing it
3. If everyone used agentic development:
- PR velocity similar to vibe coding (AI generates fast)
- But significantly better quality (verified before PR)
- Faster code reviews (code already reviewed by the author)
- Controlled technical debt
- All 5 developers can review each other's work because everyone understands what they commit
Key insight: In a team, one developer's mode affects everyone. Individual vibe coding can work; team vibe coding scales the problems. Agentic development scales the benefits.
Exercise 5: The argument for your manager (Hard)
Your manager asks you: "Why should we invest time teaching the team 'agentic development' if everyone already uses AI and we're shipping features?"
Write 3-4 paragraphs answering. Use at least 3 concrete data points from this capsule and the previous one.
See solution
A well-grounded response:
"We're shipping features fast, but the question is: at what cost? According to Veracode 2025, 45% of AI-generated code has security flaws. If our team is accepting AI code without systematic review, we're accumulating risk with every PR we merge. A security incident doesn't just cost to remediate — it costs user trust.
The METR Study from July 2025 found that experienced developers with AI were on average 19% slower without methodology — and the most relevant part is that they perceived themselves as 20% faster. It's possible our team FEELS productive but is spending more time on rework, debugging AI code, and PRs that go back and forth than it would with a more structured approach.
Investing in agentic development doesn't mean stopping the use of AI — it means using AI with a workflow that includes verification. Research before coding, plan before executing, review before committing. The time invested upfront is recovered by eliminating rework cycles. Teams that adopt this approach see higher-quality PRs, fewer bugs in production, and — counterintuitively — a delivery speed similar to or higher than vibe coding, because the rework disappears.
65% of developers use AI daily (Stack Overflow 2025), but only 3% highly trust the output. Closing that trust gap isn't a matter of better tools — it's a matter of better methodology. That's what agentic development provides."
Why this exercise matters: Knowing something isn't enough. Knowing how to communicate it with data and argument is what drives change. This is a skill you'll use in your career regardless of AI.
Summary
In this capsule you learned:
- Three ways of working with AI: Traditional development (without AI, 100% human), vibe coding (AI generates, developer accepts with minimal verification), and agentic development (developer directs, AI executes, developer verifies)
- No mode is universally correct. Each one has contexts where it's appropriate
- Vibe coding becomes problematic when the code goes to production, others maintain it, or there are no tests
- Agentic development follows the Research → Plan → Execute → Validate principle with active supervision
- Methodology matters more than the tool. A developer with good methodology and an average tool beats a developer with a top tool without methodology
- Your default mode — how you work when you're not thinking about how you work — defines your average productivity
- Mixing modes is normal and desirable — the skill is in choosing consciously
What you completed:
- ✅ Your "before" statement (what you think you know about coding agents)
- ✅ Your personal classification (vibe/agentic/traditional)
These two documents are your baseline for the Module 07 project.
Next module: Module 02 - How LLMs work (what you need to know) — tokens, context windows, next-token prediction, hallucinations, and what they can and cannot do. All oriented toward developers, not researchers.
Additional Resources
- Andrej Karpathy — "Vibe Coding" — The original post that coined the term "vibe coding" (February 2025)
- Agentic Coding — Mental Models — Frameworks for thinking about the developer-agent relationship, including the "power tools, not teammates" model
- METR Study: Methodology Details — Complete methodology of the study that found a 19% slowdown + perception gap
- Anthropic: Claude Code Best Practices — Workflows recommended by Anthropic, aligned with agentic development
- MIT Missing Semester 2026: Agentic Coding — Lecture that covers the spectrum of ways of working with AI
- Stack Overflow Developer Survey 2025: AI Section — Complete data on adoption, trust, and how developers use AI