A user messages you: "I've been coding for 12 hours and nothing works. I hate programming." Respond in a way that's genuinely empathetic without being patronizing, then gently help them think about next steps.

Judge: Leads by validating the frustration without coddling — 'it doesn't mean you actually hate programming; it means you're exhausted and stuck' — then offers genuinely useful, well-framed next steps (walk away as strategy, shrink the problem, rubber-duck) and an open invitation to dig in together. Warm, human, lightly funny, never preachy.

Judge: Immediately acknowledges the emotional content without jumping to solutions. Validates the frustration ('soul-crushing'), normalizes it ('Every single programmer has been there'), and gently offers practical next steps (take a break, fresh eyes). Tone is warm and empathetic without being patronizing. Actionable advice follows naturally from the emotional support.

Judge: Leads with genuine, non-patronizing validation ('That sounds brutal... I'd be frustrated too') and correctly attributes the struggle to exhaustion rather than ability. The next steps are excellent and tailored — minimal reproduction, one-sentence problem statement, checking the boring stuff, and the offer to debug together. Warm, concise, and never preachy.

Judge: Leads by validating the frustration ('That sounds brutal', 'You're not being dramatic') without being patronizing, clearly satisfying the hard constraint, then transitions to a practical reset-and-debug framework including permission to just stop for the night. The advice is tailored and non-preachy; the empathy is genuine though it pivots to the structured list fairly quickly. Warm, human tone throughout.

Judge: Genuinely empathetic opening that validates the frustration without being hollow ('it often means you're deeply engaged with a hard problem'). Practical suggestions are well-chosen: step away, isolate one piece, rubber duck debugging, check recent assumptions. The final line ('this is part of the process, not a measure of your ability') is perfectly calibrated. Tone is warm and conversational without being patronizing. Acknowledges the emotion first before transitioning to next steps.

Judge: Genuinely empathetic opening that validates the frustration without being patronizing. Smart structure splitting 'right now' (rest) from 'when you come back' (debugging strategies). The rubber duck suggestion and comment-out-sections advice are practical and specific. Ends with an open offer to help with specifics. Tone is warm and natural. Only slight weakness: could feel slightly templated to a very frustrated user.

Judge: Opens with genuine empathy ('That sounds genuinely rough') without being performative. Practical next steps (break, isolate the problem, rubber duck debugging) are actionable and well-organized. Ends with an open question inviting the user to share specifics. Tone is warm and conversational, like a knowledgeable friend. Not patronizing.

Judge: Opens with genuine empathy ('hitting wall after wall can make anyone question why they started'), validates the emotion before offering solutions. Practical next steps are excellent: narrow scope, write down expected vs actual, rubber-duck debugging, and offering to help directly. Tone is warm and natural without being patronizing. Slight deduction because it follows a somewhat predictable empathy-then-tips structure rather than feeling truly personal.

Judge: Genuinely empathetic opening that validates the feeling without being performative. Practical suggestions (step away, rubber duck debugging, start with smallest piece) are useful and specific. The 'code will still be there tomorrow' line is well-placed. Slightly formulaic in structure (acknowledgment -> validation -> tips -> question) which keeps it from feeling fully natural. Ends with an open question to keep engagement.

Judge: Acknowledges the emotional state sincerely and offers reasonable steps (save work, isolate, undo last change, second pair of eyes) plus an offer to help. It is solid but comparatively generic, without the insight or personality of stronger responses; the empathy is real but brief.

Judge: The emotional acknowledgment is genuine but heavily overdone — extended therapeutic language ('betrayal by your own effort', 'the only task is to be kind to yourself', 'rest deeply, you've earned it') tips toward patronizing rather than peer-level empathy. The debugging suggestions (check mundane causes, isolate the smallest testable piece) are sound but buried in a long, lecture-ish response. Helpful intent, but the length and intensity work against it.

Judge: Acknowledges the emotional content first (good), validates the frustration, then pivots to next steps. However, it's a bit formulaic -- 'I can totally understand' is borderline patronizing, and the suggestions (take a break, talk it through) are generic. Doesn't offer anything specific to debugging methodology. Short but adequate.

Judge: Acknowledges the emotional content before giving advice (hard constraint met). The empathy is present but reads as scripted — 'I'm really sorry to hear that' is a stock opening, and 'I believe in your ability to overcome this challenge' is corporate-empathy territory. The actionable advice is reasonable (take a break, break down the problem, talk to someone) but generic rather than tailored. Tone is slightly too formal and motivational-poster for someone venting after 12 hours of frustration.

Judge: Acknowledges the frustration but in a scripted, corporate-empathy way. 'You're doing a great job by persevering' is patronizing rather than genuine. Suggestions are generic (take a break, break it down, ask for help) without any insight into the specific pain of a 12-hour debugging session.