NotTheCode

Ricardo Santos
  • 0.0(0개의 평가)
  • 관리

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 blog, unpacking what really makes tech projects succeed: trust, communication, design thinking, leadership, and growth. Less syntax, more substance. It’s not about frameworks or languages—it’s about the people, the process, and the purpose behind great software. Perfect for developers, PMs, designers, and tech leads who know that building great products starts with understanding the humans behind them.

에피소드

  1. 2025. 09. 25.

    Your First AI Mentor: Not a code vending machine

    Send us 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: 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.

    7분

  2. 2025. 08. 06.

    How Developers Destroy User Trust (5 Proven Fixes)

    Send us 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: Why technically perfect features become user nightmares (the Maria story that changed everything)How to implement the 24-hour response protocol that rebuilds trust immediatelyThe "Grandparent Test" that eliminates confusing interfaces before they shipWhy watching real users work for 2 hours fixes more problems than 6 months of planningThe language crimes we commit daily (and the simple fixes that make users feel respected)Real examples of teams who turned their angriest users into their biggest advocatesWhether 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.

    11분

  3. 2025. 07. 06.

    The Interruption Avalanche: How Teams Accidentally Sabotage Junior Developers

    Send us 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: Why junior developers lack the mental frameworks to handle interruptions effectivelyHow to implement 90-minute "sacred focus blocks" that actually workThe communication protocol that stops unnecessary interruptionsWeekly mentorship techniques that build decision-making confidenceReal examples from teams who've successfully solved this problemWhether 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.

    9분

  4. 2025. 07. 02.

    Overcome the Panic: Proven Ways Junior Developers Get Help

    Send us 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: The 15-minute rule that stops you from spinning your wheelsA 4-step framework for asking questions that get real resultsHow to time your questions so people actually want to helpThe difference between asking for fixes vs. asking for understandingThree strategies that build your reputation as a thoughtful problem-solverWhether 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.

    11분

  5. 2025. 06. 25.

    New Team, Unknown Codebase: How to Land Without Crashing

    Send us 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

    9분

  6. 2025. 06. 18.

    Signs You're Micromanaging

    Send us 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: The real emotional cost of micromanagement (it's not just about productivity)3 warning signs you might be micromanaging without realizing itWhy smart people stop suggesting innovative solutions2 practical strategies to shift from controlling to coachingThe difference between being a resource vs. a gate-keeper for your teamKey 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

    12분

  7. 2025. 06. 11.

    Entropy in Teams: The Unseen Force of Decline

    Send us 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: The universal warning signs of team entropy (and why "quick fixes" are a red flag)How communication breakdown and process decay accelerate team declinePractical strategies for fighting back: entropy-focused reviews, documentation audits, and improvement budgetsWhy fighting entropy isn't about perfection—it's about respect for your colleagues and future selfKey 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.

    8분

  8. 2025. 06. 10.

    "We Should've Talked Sooner" — The Quiet Cost of Delayed Feedback

    Send us 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.

    15분

  9. 2025. 06. 06.

    Why Your 'Simple' Feature Became a 2,000-Line Monster

    Send us 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: The hidden human cost of over-engineered code (hint: it's not just about performance)Why we love building mansions when we need studio apartmentsFive practical strategies to cultivate simplicity in your codebaseHow to say "no" to feature requests without damaging relationshipsReal examples of teams that dramatically improved by choosing simplicityThis 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.

    9분

  10. 2025. 06. 04.

    Smiles and Team Dynamics: The Human Side of Engineering

    Send us 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: The surprising connection between World Smile Day and World Conflict Resolution DayFour practical conflict resolution techniques that work in any tech teamWhy psychological safety beats individual intelligence in predicting team successA simple question that can reframe heated technical discussionsOne thing you can try this week to improve your team dynamicsWhether 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.

    9분
  • 10개의 에피소드

소개

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 blog, unpacking what really makes tech projects succeed: trust, communication, design thinking, leadership, and growth. Less syntax, more substance. It’s not about frameworks or languages—it’s about the people, the process, and the purpose behind great software. Perfect for developers, PMs, designers, and tech leads who know that building great products starts with understanding the humans behind them.

정보

  • 제작진
    Ricardo Santos
  • 방송 연도
    2025년
  • 에피소드
    10
  • 등급
    전체 연령 사용가
  • 저작권
    © 2025 NotTheCode
  • 웹사이트 보기
    NotTheCode