Debugging

Comparing Level 1 and Level 2

Level 1

Level 2

Description

At Level 1, you're learning the basic detective work of software engineering: how to spot when something's wrong and start figuring out why. You're likely working on relatively straightforward bugs or encountering problems during your own development work. You may not yet have a structured approach to debugging, but you’re gaining awareness of tools like logs, breakpoints, and stack traces. Often, your best tool is asking for help—and that’s a good place to start.

Description

At Level 2, you start to debug with intention. You no longer just try things and hope—they’re informed guesses, guided by logs, observations, and experience. You take initiative to investigate bugs, not just wait for others to confirm or explain them. Your toolkit now includes tools like debuggers, error tracking dashboards, test coverage reports, and stack traces. You approach bugs with a method: gather clues, form a theory, test it, and adjust.

Key Behaviors

  • •
    Notices when something is broken and asks for help
  • •
    Uses print statements or console logs to inspect values
  • •
    Reproduces simple bugs in development or staging environments
  • •
    Follows debugging steps suggested by teammates
  • •
    Begins to observe patterns in common issues

Key Behaviors

  • •
    Reproduces and isolates issues with minimal guidance
  • •
    Reads and traces stack traces through unfamiliar code
  • •
    Uses logs and error messages to form hypotheses
  • •
    Fixes moderately scoped bugs end to end
  • •
    Leaves helpful notes or comments for others encountering the same issue

Common Struggles

  • Unsure how to isolate or reproduce issues
  • May jump to conclusions or try random fixes
  • Doesn't yet use systematic strategies or tooling
  • May depend on others to investigate or validate fixes

Common Struggles

  • Can get stuck in rabbit holes without stepping back
  • May miss broader root causes by focusing on symptoms
  • Sometimes hesitates to touch unfamiliar code when debugging

Success Indicators

  • Recognize when something’s wrong and try to learn why
  • Use basic inspection techniques (logs, console, etc.)
  • Communicate clearly about bugs you encounter
  • Ask good questions and follow guidance to learn how others debug

Success Indicators

  • Investigate bugs with a structured process
  • Fix issues in code you didn’t write by reading and testing
  • Communicate clearly about what’s broken, why, and what you’re trying
  • Leave the codebase better than you found it when fixing bugs

Mindset Shift

From:

"Something's broken, what do I try?"

To:

"What steps can I take to isolate the cause of this issue?"

Mindset Shift

From:

"I can fix the thing that’s broken."

To:

"I understand the system well enough to explain what went wrong."

Questions to Ask Yourself

  • Can I reproduce this reliably?
  • What changed recently that might have caused this?
  • What logs or traces could help me understand what happened?

Questions to Ask Yourself

  • What assumptions is this code making—and are they valid?
  • Is this a one-off issue or part of a recurring pattern?
  • What could prevent this class of bug in the future?

Build These Habits

  • 1
    Practice isolating issues by changing one thing at a time
  • 2
    Learn to read stack traces and trace logs through the code
  • 3
    Try to reproduce issues in your local or staging environment
  • 4
    Take notes on what you tried and what you observed

Build These Habits

  • 1
    Write tests that reproduce bugs before fixing them
  • 2
    Use tools like git bisect, debugger breakpoints, or tracing utilities
  • 3
    Annotate logs or code to leave breadcrumbs for others
  • 4
    Document what caused the issue and how you resolved it

Seek Feedback

  • "How would you approach debugging this?"
  • "What clues do you look for when you’re stuck?"
  • "Am I using the right tools or techniques for this kind of issue?"

Seek Feedback

  • “Does my root cause analysis make sense to you?”
  • “Would my notes help the next person understand what happened?”
  • “Is there a better way to prevent this kind of issue?”

Signals You're Ready to Level Up

  • You isolate simple issues without much help
  • You try multiple debugging strategies before asking
  • You learn from each bug and apply that insight later

Signals You're Ready to Level Up

  • You debug without needing someone to point you in the right direction
  • You explain causes as well as fixes in your PRs or commits
  • You help others debug more effectively through questions or tools

Focus Summary

  • Be curious
  • Be systematic
  • Every bug is a chance to learn

Debugging is how we turn confusion into clarity. At Level 1, you’re just starting to build your toolkit and instincts—and that’s where everyone begins.

Focus Summary

  • Don’t just squash the bug—understand where it came from.

At Level 2, debugging becomes a practiced skill. You’re not guessing anymore—you’re reasoning. You’re learning to see through the chaos.