Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • Part 0 · What Debugging Is6
  • Part 1 · Reproduce8
  • Part 2 · Observe9
  • Part 3 · Localise10
  • Part 4 · Hypothesise and Test6
  • Part 5 · Bug Classes16
  • Part 6 · Debug by Stage9
  • Part 7 · Hangs and Deadlocks7
  • Part 8 · Intermittent Failures7
  • Part 9 · Fix, Prove, Prevent7
  • Part 10 · Case Studies12
  • Part 11 · Debug as a Team5
    • Triage Meetings That Converge
    • Ownership and Hand-Offs
    • Bug Tracking and Severity
    • Debug Metrics That Help, and Ones That Hurt
    • Designing for Debuggability
  • Part 12 · Interview Prep5
Loading lesson

‹The Art of Hardware Debug
  1. Topics
  2. The Art of Hardware Debug
  3. Part 11 · Debug as a Team

Part 11 · Debug as a Team · All levels

Part 11 · Debug as a Team

How do I lead a hunt and make the team faster?

  • 5topics
  • 5lessons

Topics in this section

  1. 1Triage Meetings That Converge1 lesson
  2. 2Ownership and Hand-Offs1 lesson
  3. 3Bug Tracking and Severity1 lesson
  4. 4Debug Metrics That Help, and Ones That Hurt1 lesson
  5. 5Designing for Debuggability1 lesson
On this page

    Part 11 answers: How do I lead a hunt and make the team faster?

    Where Part 11 sits on the debug loop: Report, Prevent.

    On a real project, bugs cross owners: RTL, verification, physical design and the lab. This part covers triage that converges, hand-offs that do not lose information, metrics that help, and designing for debuggability before tape-out.

    After this part you can

    • Run a triage meeting that ends with owners and next experiments.

    • Choose bug-tracking fields and metrics that help rather than hurt.

    • Review a design for debuggability before tape-out.

    Lessons in this part

    5 lessons, about 58 min

    1. 1Triage Meetings That ConvergeYou can prepare a triage from a red regression with scripts, group failures by signature, attach a repro and a first bad commit to each, and chair a meeting that leaves no signature without an owner and a next experiment.12 min
    2. 2Ownership and Hand-OffsYou can decide who owns a bug at each step, build a hand-off package with replay, signature, first wrong cycle, waveform window and open questions, and end the hand-off only when the receiver reproduces the first wrong cycle.12 min
    3. 3Bug Tracking and SeverityYou can fill a bug record with the fields a hardware team needs, set severity from impact in silicon rather than from frequency in simulation, and move a bug through its states with the evidence each state requires.12 min
    4. 4Debug Metrics That Help, and Ones That HurtYou can choose debug metrics that measure flow and quality (time to reproduce, time to root cause, reopen rate, escape gap), read them as medians and tails, and explain how a count or a pass-rate target is gamed.10 min
    5. 5Designing for DebuggabilityYou can turn a block's failure modes into a debug spec with decision rules, choose witnesses a bug cannot corrupt together, prove each diagnosis with a test and a mutation, and run a debuggability sign-off review.12 min

    Revision sheet

    The part on one page, taken from each lesson's Remember box.

    Triage Meetings That Converge

    • Prepare before the meeting, with scripts: signatures, one repro each, the first bad commit and the files it touched. The meeting is for decisions.

    • One row per signature, not per failing run. 66 red lines here are five bugs; too coarse or too fine a grouping both mislead.

    • Every row leaves with one named owner, one experiment, its prediction and a due time. A signature without them is the meeting's failure.

    Rule of thumb: nobody debugs in the triage meeting; the meeting assigns the next experiment and moves on.

    Ownership and Hand-Offs

    • A bug has one owner at a time: the person who acts next. Ownership moves when the receiver accepts, not when the ticket is reassigned.

    • Hand over the hunt, not just the failure: replay, signature in every simulator, first wrong cycle with the probe that shows it, what is ruled out, the question.

    • The hand-off ends when the receiver reproduces the first wrong cycle on their own machine. Until then the giver still owns it.

    Rule of thumb: never reassign a bug the receiver has not yet reproduced.

    Bug Tracking and Severity

    • Severity is the harm if it ships; frequency is how often a test sees it; priority is the order of work. Three fields, set by different questions.

    • Judge severity by silicon, not by the simulator: an unreset register that one simulator hides is still random data on a real chip.

    • Fixed is not closed. Verified means the repro and a wider sweep pass at the fix, run by someone or something other than the author's local tree.

    Rule of thumb: set severity by asking what the bug does in silicon in the worst reachable case, never by how many seeds fail.

    Debug Metrics That Help, and Ones That Hurt

    • Measure intervals in a bug's life, not counts of bugs. Report the median and the 90th percentile; the tail is where the expensive bugs live.

    • Pair every speed metric with a quality one: closed and stayed closed, verified at the fix, found at the earliest stage that could find it.

    • A metric used to rank people stops measuring the work. Use debug metrics to find slow steps in the process, never as individual targets.

    Rule of thumb: never set a target on a number that the people being measured can move without finding a bug.

    Designing for Debuggability

    • Write the debug spec from the failure modes: for each, the register the lab reads and the rule that turns the value into a decision.

    • A diagnosis needs independent witnesses. A counter that the bug corrupts cannot tell you the bug is there; two counts kept apart can.

    • Debug logic is verified like function: inject each failure, check the decoded registers name it, and mutate the debug logic to find untested promises.

    Rule of thumb: every failure mode in the review gets a register, a decision rule and a test that shows the rule picks the right culprit.

    Practise it

    • Practice question: Debugging rare seed failures in regression

    • Practice question: Report catcher triage: noise down, real failures up

    • Practice question: Seed reproducibility: failing to log random seeds breaks debug

    • Code lab: Watchdog FSM

    • Code lab: Outstanding tracker

    • Interview: run a mock interview on this topic

    Related topics

    • Course hub

    • Previous: Part 10 · Case Studies

    • Next: Part 12 · Interview Prep

    PreviousNext: Triage Meetings That Converge

    Up next

    Up nextTriage Meetings That Converge

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Part 0 · What Debugging Is
    • Part 1 · Reproduce
    • Part 2 · Observe