Your First AI Mentor: Not a code vending machine

Ever felt that familiar pang of self-doubt staring at a complex codebase or a cryptic error message? That moment you wish a senior developer was right there to guide you? This episode of NotTheCode is for you.

We challenge the common notion of AI for coding as just a "code vending machine." While it's tempting to simply ask for code and paste, that approach often leads to more confusion than learning. Instead, we explore a powerful alternative: treating tools like GitHub Copilot, Claude Code, and ChatGPT as your personal AI mentor—a patient, always-available partner dedicated to accelerating your growth.

Join us as we break down "The Mentor Loop," a simple, repeatable habit that transforms passive code generation into active, deliberate practice. You’ll learn how to shift your mindset from merely getting answers to truly understanding the "why" behind the code.

Discover practical, junior-friendly use cases, complete with specific prompts you can adapt:

• Deciphering Complex Code: Turn tangled modules into clear mental maps and break down dense functions without feeling overwhelmed.
• Mastering Test-Driven Development (TDD): Learn to confidently ship small, safe changes by using AI to guide your Red-Green-Refactor cycle, from writing failing tests to crafting minimal, passing diffs and safe refactors.
• Effective Debugging: Transform frustrating error messages into learning opportunities, using AI to pinpoint root causes and propose targeted fixes.
• Crafting Professional Pull Requests: Prepare for code reviews like a pro, using AI to summarize changes, highlight risks, and suggest follow-up tasks.
• Building Lasting Habits: Understand the crucial guardrails for staying in control, demanding explanations, and always verifying AI-generated code with your own judgment and tests.

This isn't about letting AI replace you; it's about empowering you. We'll explore how to establish a workflow that leverages AI to build confidence, improve code quality, and develop the sharp thinking skills that define senior developers. Stop merely copying. Start learning faster, building better, and mastering the craft.

Transcript

 AI Mentor

Welcome to Not the code where we explore the human side of software development.

You're staring at a failing test. The senior developer who usually helps is deep in a meeting. The code. Feels like a labyrinth and that little flicker of self-doubt starts to grow. We've all been there as a last resort. You paste the error into an AI assistant and it doesn't just spit out an answer. It explains the why.

Proposes a tiny safe change and even suggests a test to prove the fix. That's the moment. AI stops feeling like a magic shortcut and starts feeling like a mentor. Today, we're not talking about 10 x productivity or letting a robot write your code. We're talking about a playbook for using tools like GitHub Copilot, Claude Code and Chat GPT as a patient partner, one that helps you learn faster, ship with more confidence, and build the habits that truly matter in the long run.

The biggest mistake I see people make with AI is treating it like a vending machine for code. The real power. The sustainable power comes when you treat it like a thinking partner. And you can do that with a simple habit I call the mentor loop. It goes like this. First you set a tiny specific goal.

Second, you prompt the AI for a plan and a small reviewable change, what we call a diff. third. You verify it yourself. You run the tests, you read the code. Finally the most important part, you reflect. You ask why? Why was this a better approach? What did I miss? This loop turns passive code generation into active deliberate practice.

So let's walk through how to use it. Before you can write good code, you have to read it when you're dropped into a new code base building a mental map is everything. Your AI partner can be an incredible guide here, instead of getting lost clicking through dozens of files, open a key module and ask your in IDE assistant, like copilot chat or Claude, explain this

module's responsibilities and it's main interactions with other parts of the app. It's like asking for a guided tour. Or maybe you're facing a complex function. It happens instead of just pushing through. Take a snippet, redact anything sensitive and ask chat GPT. Explain this function like I'm new to the code base.

Give me a few questions I should be able to answer after I understand it. This frames you're learning. The same idea works for debugging. An error message isn't a dead end. It's a clue. Paste the stack trace into your IDE and ask, given this error, propose the most likely root cause. Then provide a minimal diff to fix it and a new regression test.

You're not just getting a fix, you're learning a diagnostic process. Once you understand the landscape, it's time to build. This is where the mentor loop really starts to shine. Test-driven development is a perfect workflow for this. It builds a safety net that lets you move with confidence. First, you write a small failing test.

This is your goalpost. Then you ask your AI. I have a failing test. Propose the smallest code change to pass it return. A unified diff. Notice the constraints. Smallest change. Unified diff your guiding the tool. Once the test is passing, the loop isn't over. Now you refactor. You ask, suggest one safe refactor to improve readability, keep the tests green and return a diff. You are learning what clean code looks like, one small, safe step at a time. Your job isn't done when the tests pass. Shipping professional code means making it easy for others to review and understand. A good pull request tells a story, and your AI can help you draft it with your code changes as context, ask, summarize these changes for a PR.

Explain the what and the why. List potential risks and suggest one follow-up task. You'll still need to edit it into your own voice, but it gives you an incredible headstart. Now this all comes with a critical warning. These tools are powerful, but they don't have your context. Your judgment is what makes this entire process work.

So a few ground rules. First, instead of accepting huge changes, always ask for small, incremental diffs. Run your tests after each tiny step. Second, instead of using AI to avoid thinking, use it to deepen your thinking. Always ask why. Explain the trade-offs here. Is there a more performant way to do this?

And third, instead of vague prompts be specific. Your clarity dictates the quality of the response. This isn't a rigid, one size fits all process. The real goal is to experiment and build a workflow that makes you a more confident, effective developer. A great way to start is by focusing only on reading and refactoring.

Find a function in your code base that feels a bit confusing. Use your AI assistant to understand it and then to propose a single safe refactor. Don't apply the change. Just study the diff. See how a small change can simplify logic or prevent a bug. It's a low pressure way to train your eye for improvement.

Once you're comfortable there, move on to shipping a small change like a bug fix. Drive the TDD workflow from start to finish. You own the tests, you own the code, and you own the story of the change. Each small win will build the confidence you need to take on more complex problems. The real goal here isn't just to code faster, it's to learn faster.

The senior developers we admire didn't get there by knowing everything they got there by building a process for learning effectively. This is your chance to build your own. So think about your own workflow. Where are the friction points? Is there a task you've been avoiding? This week try using the mentor loop on it.

Set a tiny goal. Ask for a plan and a small diff and see what you learn. Small, safe steps compound. That's how we grow one thoughtful change at a time.

Thanks for listening to Not the code. If this resonated with you, try asking your AI for one small safe dip this week instead of a block of code, and see what you learn. Until next time, keep building better things together.