
Sign up to save your podcasts
Or


Send a text
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:
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.
Send a text
Why Users "Hate" Software Developers (And What We Can Actually Do About It)
That support ticket saying "I give up" isn't about bad code—it's about broken trust. In this episode, we uncover why users feel abandoned by the very people meant to help them, and share four proven strategies that transform frustrated users into genuine collaborators.
What you'll learn:
Whether you're a developer wondering why users seem hostile, a product manager dealing with mounting complaints, or a team lead trying to bridge the developer-user divide, this episode provides actionable strategies that change everything—starting with your next support ticket.
Send a text
Why Your Junior Developers Can't Focus (And 3 Ways to Fix It)
Junior developers aren't struggling because they're easily distracted—they're drowning in context switching. In this episode, we explore why constant interruptions hit new developers harder than experienced team members, and share three practical solutions that transform scattered, anxious developers into confident contributors.
What you'll learn:
Whether you're a team lead trying to help junior developers thrive, or a junior developer feeling overwhelmed by constant context switching, this episode provides actionable strategies you can implement immediately.
Send a text
I once spent three hours debugging a database query that a senior developer fixed in ten seconds. That embarrassing moment taught me the most valuable lesson of my junior developer career: it's not about avoiding getting stuck—it's about knowing how to ask for help effectively.
In this episode, I share the game-changing 15-minute rule that transformed me from a "question machine" constantly interrupting teammates to someone others actually started coming to for guidance. You'll discover why most junior developers fall into two traps: struggling alone for hours or asking for help in ways that frustrate their team.
What You'll Learn:
Whether you're a junior developer who feels stuck asking for help, a senior developer mentoring others, or anyone who wants to collaborate more effectively, this episode gives you practical techniques you can use immediately.
Key Takeaway: Your team hired you expecting questions—the secret is making them count.
Send a text
In this episode, I share the humbling story of my biggest early career mistake—and the three strategies it taught me for successfully joining new development teams:
🎯 Map the human terrain before diving into code 👀 Use the product like a complete stranger first
🤝 Make one small, meaningful contribution
Whether you're starting a new role or have team members joining, these insights will help you land well instead of crashing and burning.
🔗 Read the full article:
New Team, Unknown Codebase: How to Land Without Crashing
Send a text
Eight messages by noon about wireframe details that weren't even final. Sound familiar?
In this episode, we explore the hidden psychology behind micromanagement and why even well-intentioned managers fall into controlling behaviors that crush team morale and innovation.
What You'll Learn:
Key Takeaway: The best managers are barely noticed day-to-day, but their absence would be immediately felt. Learn how to build trust instead of undermining it.
Perfect for developers, designers, product managers, and tech leaders who want to create environments where teams actually thrive.
The Blog: NotTheCode
More episodes: NotTheCode Podcast
Send a text
Entropy in Teams: The Unseen Force of Decline
Ever wonder why your team feels more chaotic today than six months ago, even though nothing major changed? You're experiencing entropy—the natural drift toward disorder that affects every team, regardless of industry or department.
In this episode, we explore how high-performing teams gradually lose their edge through small compromises and overlooked maintenance. From daily meetings that mysteriously balloon from 15 to 45 minutes, to brilliant team members who slowly disengage, entropy's human cost is real and measurable.
What You'll Learn:
Key Takeaway: Entropy isn't a problem to solve—it's a condition to manage through consistent, small improvements. The best teams aren't those that avoid entropy; they're the ones that acknowledge it, plan for it, and tackle it together.
Perfect for developers, product managers, designers, team leads, and anyone who believes that maintaining team health requires the same intentional effort as tending a garden.
Send a text
A story from after-work drinks reveals why "We should've talked sooner" might be the most avoidable sentence in team life. Learn how to turn delayed feedback into real-time partnership with four practical techniques you can try this week.
Perfect for: Developers, team leads, product managers, and anyone who wants to build better team dynamics.
Send a text
It's 3 AM. You're debugging what was supposed to be a "simple" user authentication system that somehow grew into a 2,000-line monster with six layers of abstraction. Sound familiar?
In this episode, we explore why developers consistently fall into the complexity trap—mistaking sophistication for good engineering, getting hypnotized by technical challenges, and building systems that anticipate needs that never materialize.
You'll discover:
This isn't about dumbing down your code—it's about building systems that serve humans, not the other way around. Because the most complex system in any tech project isn't your architecture—it's your team.
Perfect for developers, product managers, and tech leaders who want to build better software by focusing on what actually matters.
Key takeaway: The next time you're about to add another layer of abstraction, ask yourself: "What would the simplest solution look like?" Your future self will thank you.
Send a text
Most tech project failures aren't caused by broken code—they're caused by broken communication. In this episode, we explore how something as simple as a genuine smile can transform team conflict into collaboration.
Drawing from real project war stories, we dive into why human dynamics are the most complex system developers actually work with, and how small gestures can defuse tension faster than any technical fix.
You'll discover:
Whether you're a developer tired of team friction, a PM caught between conflicting priorities, or a designer navigating difficult feedback loops, this episode offers practical wisdom for building better relationships—and better software.
Key takeaway: Building exceptional software isn't just about technical excellence—it's about remembering the humans behind the code.
From the publisher's feed
NotTheCode is a narration-style podcast that explores the human side of software development—one story at a time.
Each episode is a deep, voice-narrated dive into a key idea from the…
Perfect for developers, PMs, designers, and tech leads who know that building great products starts with understanding the humans behind them.