Vibe Coding Is Creating a Generation of Sorcerer’s Apprentices

Introducing “Mentor Mode” — a human-centered alternative

There’s a scene in Fantasia where Mickey Mouse, tired of carrying buckets of water, enchants a broom to do his chores. It works beautifully—until it doesn’t. The broom splits into more brooms, each carrying more water, flooding the room. Mickey has no idea how to stop it because he never understood the magic in the first place.

This is vibe coding in 2025.

The Sorcerer’s Apprentice Problem

“Vibe coding” — the practice of describing what you want and letting an AI generate the code — has exploded. Cursor, Copilot, Claude, GPT. The tooling is genuinely impressive. A junior developer can now scaffold an entire application in an afternoon.

But I’ve been watching what happens in week two.

The AI generates 500 lines of React. It works. The developer ships it. Then a bug appears. They stare at their own codebase like it’s hieroglyphics. They paste the error back into the AI. It “fixes” it by regenerating 200 lines. Something else breaks. They paste that error. The AI removes a feature that was working. They don’t notice until production.

The developer has become a passenger in their own codebase.

This isn’t a skill issue. It’s a paradigm issue. We’ve optimized for speed of generation at the cost of understanding.

What Understanding Actually Provides

When you understand your code, you get:

1. Debugging capability. You can read a stack trace and know where to look.

2. Modification confidence. You can add a feature without fear of breaking something unrelated.

3. Architectural intuition. You can feel when something is getting too complex.

4. Compound learning. Each project makes you better at the next one. Understanding accumulates. Prompting doesn’t.

---

Introducing Mentor Mode

What if we flipped the relationship?

Vibe Mode: Human describes goal → AI generates code → Human accepts or rejects

Mentor Mode: Human describes goal → AI generates code AND teaches every concept → Human understands before moving on

The name is intentional. In Vibe Mode, the AI is a wizard performing magic. In Mentor Mode, the AI is a teacher whose success is measured by whether the student can eventually work independently.

The Mentor Mode Prompt

Here’s the template I use:

I'm building [PROJECT].

I want to learn as I build. For this session, focus on [SPECIFIC CHUNK].

Please:
1. Explain the concept BEFORE showing code
2. Give me the mental model (how should I think about this?)
3. Show code in small pieces with comments explaining each piece
4. Explain any syntax I might not know
5. Include "check your understanding" questions
6. Give me a small practice exercise

Assume I'm an intelligent adult who wants to understand, 
not just copy-paste.

What Mentor Mode Output Looks Like

When I asked for help writing a parser function, instead of just getting code, I got:

The Concept:

“Parsing is taking text and giving it structure. Your brain does this with English: ‘The dog bit the man’ becomes Subject → Verb → Object. We’re doing the same thing with code.”

The Mental Model:

“Think of the = sign as a landmark. Everything left of it is the name, everything right is the value. Find the landmark, split there.”

Then the code, with every line explained:

javascript

function parseLine(line) {
  // Find the position of the = sign
  const equalsIndex = line.indexOf('=')
  
  // If no =, this isn't a valid assignment
  // indexOf returns -1 when not found
  if (equalsIndex === -1) {
    return null
  }
  
  // Everything before = is the name
  // slice(0, n) takes first n characters
  // trim() removes whitespace
  const name = line.slice(0, equalsIndex).trim()
  
  // Everything after = is the value
  const value = line.slice(equalsIndex + 1).trim()
  
  return { name, value }
}

Then came comprehension questions (”What does indexOf return if not found?”) and a practice exercise (”Extend this to handle labels”).

The difference: After vibe coding, I have working code. After Mentor Mode, I have working code and I understand indexOf, slice, trim, and string parsing patterns I’ll use forever.

(Full example with complete output in Appendix A)

---

The Role of Repetition

Learning requires repetition. This is neuroscience, not opinion. The first time you see slice(), you’ll forget it. The third time, it’ll stick.

Mentor Mode builds repetition in naturally:

1. Concept explanation — first exposure

2. Code with comments — see it applied

3. Syntax breakdown — see it isolated

4. Comprehension questions — active recall

5. Practice exercise — apply it yourself

6. Next chunk uses it again — spaced repetition

If you’re still forgetting things, slow down. The goal isn’t speed — it’s durable understanding.

---

When to Use Each

When to use Vibe Mode:

• Throwaway prototype — speed matters, durability doesn’t

• One-off script — you’ll never touch it again

• Hackathon — ship now, learn never

When to use Mentor Mode:

• Learning a new framework — investment compounds to future projects

• Your own product — you’ll maintain this for years

• Career development — skills transfer, code doesn’t

• Code interview prep — you need to explain your code

---

Common Objections

“This is too slow. I have deadlines.”

You have a deadline this week. But you also have a career spanning decades. Mentor Mode is slower on day 1 and faster on day 100.

Also: how much time do you spend debugging vibe-coded projects? That’s hidden slowness that doesn’t feel like slowness.

“I don’t need to understand everything. That’s why we have AI.”

You don’t need to understand everything. But you need enough to know when the AI is wrong, debug when things break, and make architectural decisions.

“This is just... learning.”

Yes. Vibe coding is the avoidance of learning dressed up as productivity. Mentor Mode is learning accelerated by AI. The insight isn’t that learning is good — it’s that we’ve built workflows that accidentally optimize against it.

---

Signs You’re Ready to Speed Up

Mentor Mode isn’t forever. You’re ready to accelerate when:

• You can predict what the AI will generate before it does

• You spot when the AI’s solution is suboptimal

• You can modify the code without looking anything up

• You could explain it to someone else

The goal isn’t perpetual slowness. It’s building the foundation that makes speed sustainable.

---

A Personal Note

I’m Russell, and I came to this the hard way.

Six months ago, I vibe-coded an entire project. The AI generated hundreds of lines of Svelte. It worked. I shipped it.

Three weeks later, I needed to add a feature. I opened the codebase and realized: I had no idea how any of it worked. I pasted the code back into Claude to add the feature. It regenerated half the app. Something broke. I pasted the error. It fixed one thing and broke another.

I spent more time fighting that codebase than it would have taken to build it properly in the first place.

That’s when I started developing what I now call Mentor Mode. It’s slower upfront. But I own what I build. And every project makes the next one easier.

---

Try It Today

1. Pick something small you want to build

2. Use the Mentor Mode prompt (full template in Appendix C)

3. Resist the urge to skip ahead

4. If you can’t answer the comprehension questions, don’t proceed

It’s slower. It’s harder. But you’ll own what you build.

Mickey’s mistake wasn’t using magic. It was using magic he didn’t understand.

Don’t be Mickey. Try Mentor Mode.

---

If this framework helped you, I’d love to hear about it. And if you improve on it, share it — that’s how good ideas spread.

---

Russell Miller is a product builder and recovering vibe-coder. He studied math at MIT, and built ML products serving thousands of users, and spends a lot of time thinking about how AI can enable go to market. He’s currently developing Cast, a calculator tool where comparison is the product, and exploring operating partner roles at PE firms rethinking how humans and AI work together. Find him at @russellm or russell@zavient.com

---

Appendices

Appendix A: Full Mentor Mode Example (Small Chunk)

Prompt:

I'm building a calculator app that parses a simple DSL.

For this session, focus on writing a function that takes 
"price = 100" and extracts the variable name and value.

[Mentor Mode instructions]

Full Response:

The Concept: Parsing a Single Line

Parsing is taking text and giving it structure. Your brain does this automatically with English:

"The dog bit the man"
     ↓
Subject: "dog"
Verb: "bit"  
Object: "man"

We’re doing the same thing:

"price = 100"
     ↓
name: "price"
value: "100"

Text in → Structured data out.

The Mental Model: Find the Landmark, Split There

Think of = as a landmark. Everything left is the name, everything right is the value.

1. Find the =

2. Grab what’s left (trim whitespace)

3. Grab what’s right (trim whitespace)

4. Return both

The Code

javascript

function parseLine(line) {
  // Find the position of the = sign
  // "price = 100" → position 6
  const equalsIndex = line.indexOf('=')
  
  // If no =, this isn't valid
  // indexOf returns -1 when not found
  if (equalsIndex === -1) {
    return null
  }
  
  // Everything before = is the name
  // slice(0, 6) on "price = 100" gives "price "
  // trim() removes the space → "price"
  const name = line.slice(0, equalsIndex).trim()
  
  // Everything after = is the value
  // slice(7) gives " 100", trim → "100"
  const value = line.slice(equalsIndex + 1).trim()
  
  return { name, value }
}

Syntax You Should Know

indexOf() — Returns position of match, or -1 if not found.

javascript

"hello".indexOf('e')  // 1
"hello".indexOf('x')  // -1

slice(start, end) — Extracts portion of string. Omit end to go to end.

javascript

"hello".slice(0, 2)  // "he"
"hello".slice(2)     // "llo"

trim() — Removes whitespace from both ends.

javascript

"  hello  ".trim()  // "hello"

{ name, value } — Shorthand for { name: name, value: value }.

Check Your Understanding

1. What does indexOf return if the character isn’t found?

2. What’s the difference between slice(0, 5) and slice(5)?

3. Why do we need trim()?

Practice Exercise

Modify the function to handle price = 100 | "Product Price" — extracting name, value, AND label.

Test It

javascript

console.log(parseLine("price = 100"))
// { name: "price", value: "100" }

console.log(parseLine("no equals here"))
// null

console.log(parseLine("  spacy  =  values  "))
// { name: "spacy", value: "values" }

---

Appendix B: Full Mentor Mode Example (Project Kickoff)

Prompt:

I want to build a web app that lets users create shareable 
calculators. Users write formulas like "profit = revenue - cost", 
share a link, others plug in numbers and see results.

Before coding, help me:
1. Break this into learnable chunks (max 1 hour each)
2. Sequence them so each builds on the last
3. Identify what concepts I'll learn in each chunk
4. Flag which chunks I should do myself vs use AI help

Response:

Phase 1: Core Engine (You Build, AI Teaches)

ChunkWhat You BuildConcepts1Basic layoutHTML/CSS fundamentals2Parse single lineString manipulation3Parse multiple linesLoops, state4Evaluate mathExpression evaluation, scope5Handle %, $Data transformation6Connect to UIReactivity

Phase 2: Features (AI Helps More)

ChunkWhat You BuildConcepts7Input formForms, events8Save scenariosState management9Comparison tableComponent design10LocalStoragePersistence

Phase 3: Polish (AI Generates, You Review)

ChunkWhat You BuildConcepts11StylingCSS frameworks12Share URLsRouting, databases13User accountsAuthentication

Why This Sequence

Each chunk builds on the previous:

• Chunk 2 teaches string parsing

• Chunk 3 extends to multiple strings

• Chunk 4 uses parsed structure to compute

• Chunk 5 extends parsing for edge cases

Skip to Chunk 4 without Chunk 2, and you’ll be lost when parsing breaks.

---

Appendix C: The Mentor Mode Prompt Template (Russell’s Version)

I'm building [PROJECT].

I want to learn as I build, not just get working code. 

For this session, focus on [SPECIFIC CHUNK].

Please structure your response as:

## The Concept
Explain what we're doing and why, before any code.

## The Mental Model
An analogy or framework for thinking about this.

## The Code
Show code in pieces with comments explaining 
each non-obvious line. No walls of code.

## Syntax You Should Know
Explain any language features I might not recognize.

## Check Your Understanding
2-3 questions I should be able to answer if I understood.

## Practice Exercise
A small modification I can try myself.

## Test It
How to verify this works before moving on.

---

Assume I'm an intelligent adult who wants to understand. 
If I can't explain this code after your response, 
you haven't succeeded.