Use this skill when designing coding challenges, structuring system design interviews, building interview rubrics, calibrating evaluation criteria, or creating hiring loops. Triggers on interview question design, coding assessment creation, system design prompt writing, rubric building, interviewer training, candidate evaluation, and any task requiring structured technical assessment.
Use this skill when designing coding challenges, structuring system design interviews, building interview rubrics, calibrating evaluation criteria, or creating hiring loops. Triggers on interview question design, coding assessment creation, system design prompt writing, rubric building, interviewer training, candidate evaluation, and any task requiring structured technical assessment.
When this skill is activated, always start your first response with the 🧢 emoji.
Technical Interviewing
Technical interviewing is both a skill and a system. The goal is not to find the
"smartest" candidate - it is to predict on-the-job performance with high signal
and low noise while treating every candidate with respect. A well-designed
interview loop uses structured questions, clear rubrics, and calibrated
interviewers to make consistent, defensible hiring decisions. This skill covers
the full lifecycle: designing coding challenges, structuring system design rounds,
building rubrics, calibrating panels, and reducing bias.
When to use this skill
Trigger this skill when the user:
Wants to design a coding challenge or take-home assignment for a specific role
Needs to create a system design interview question with follow-ups
Asks to build a scoring rubric or evaluation criteria for interviews
Wants to structure a full interview loop (phone screen through onsite)
Needs to calibrate interviewers or run a calibration session
Asks about reducing bias in technical assessments
Wants to evaluate a candidate's performance against a rubric
Needs interviewer training materials or shadow guides
Do NOT trigger this skill for:
Preparing as a candidate for interviews (use system-design or algorithm skills)
General HR hiring workflows not specific to technical assessment
Key principles
Structure over gut feel - Every question must have a rubric before it is
used. "I'll know a good answer when I see it" is not a rubric. Define what
strong, acceptable, and weak look like in advance. Structured interviews are
2x more predictive than unstructured ones.
Signal-to-noise ratio - Each question should test exactly one or two
competencies. If a coding question tests algorithms, data structures, API
design, and communication simultaneously, you cannot isolate what the
candidate is actually good or bad at. Separate the signals.
Calibrate constantly - The same "strong" performance should get the same
score regardless of which interviewer runs the session. Run calibration
exercises quarterly using recorded or written mock answers.
Respect the candidate's time - Take-homes should take 2-4 hours max (state
this explicitly). Onsite loops should not exceed 4-5 hours. Every minute of
the candidate's time should produce meaningful signal.
Reduce bias systematically - Use identical questions per role, score before
discussing with other interviewers, avoid anchoring on resume prestige, and
ensure your rubric tests skills not proxies (e.g. "uses our preferred
framework" is a proxy, not a skill).
Core concepts
The interview funnel
Every technical hiring loop follows a narrowing funnel. Each stage should have a
clear purpose and avoid re-testing what was already assessed:
Stage
Purpose
Duration
Signal
Resume screen
Baseline qualifications
2-5 min
Experience match
Phone screen
Communication + baseline coding
30-45 min
Can they code at all?
Technical deep-dive
Core competency for the role
45-60 min
Domain strength
System design
Architecture thinking (senior+)
45-60 min
Scope, trade-offs
Culture/values
Team fit, collaboration style
30-45 min
Working style
Question types
Algorithmic - Data structures, complexity analysis. Best for junior/mid roles.
Risk: over-indexes on contest skills vs real work.
Practical coding - Build a small feature, debug existing code, extend an API.
Better signal for day-to-day work.
System design - Design a URL shortener, notification system, rate limiter.
Best for senior+ roles. Tests breadth and trade-off reasoning.
Code review - Review a PR with intentional issues. Tests reading skill and
communication.
Take-home - Larger project done asynchronously. Best signal but highest
candidate time cost.
Rubric anatomy
Every rubric has four components:
Competency - What you are testing (e.g. "API design")
Levels - Typically 4: Strong Hire, Hire, No Hire, Strong No Hire
Behavioral anchors - Concrete examples of what each level looks like
Must-haves vs nice-to-haves - Which criteria are required vs bonus
Common tasks
Design a coding challenge
Start with the role requirements, not a clever problem. Work backward:
Identify 1-2 core competencies the role needs daily
Design a problem that requires those competencies to solve
Create 3 difficulty tiers: base case, standard, extension
Write the rubric before finalizing the problem
Test-solve it yourself and time it (multiply by 1.5-2x for candidates)
Template:
PROBLEM: <Title>
LEVEL: Junior / Mid / Senior
TIME: <X> minutes
COMPETENCIES TESTED: <1-2 specific skills>
PROMPT:
<Clear problem statement with examples>
BASE CASE (must complete):
<Minimum viable solution criteria>
STANDARD (expected for hire):
<Additional requirements showing solid understanding>
EXTENSION (differentiates strong hire):
<Follow-up that tests depth or edge case thinking>
RUBRIC:
Strong Hire: Completes standard + extension, clean code, discusses trade-offs
Hire: Completes standard, reasonable code quality, handles prompts on edge cases
No Hire: Completes base only, significant code quality issues
Strong No Hire: Cannot complete base case, fundamental misunderstandings
Create a system design question
Good system design questions are open-ended with clear scaling dimensions:
Pick a system the candidate likely understands as a user
Define initial constraints (users, QPS, data volume)
Prepare 4-6 follow-up dimensions to probe depth
Write what "good" looks like at each stage
Follow-up dimensions to prepare:
Scale: "Now handle 10x the traffic"
Reliability: "A database node goes down - what happens?"
Consistency: "Two users edit the same document simultaneously"
Cost: "The CEO says infrastructure costs are too high"
Latency: "P99 latency must be under 200ms"
Security: "How do you handle authentication and authorization?"
Build a scoring rubric
For each competency being assessed:
COMPETENCY: <Name>
WEIGHT: <High / Medium / Low>
STRONG HIRE (4):
- <Specific observable behavior>
- <Specific observable behavior>
HIRE (3):
- <Specific observable behavior>
- <Specific observable behavior>
NO HIRE (2):
- <Specific observable behavior>
STRONG NO HIRE (1):
- <Specific observable behavior>
Always use behavioral anchors (what you observed), not trait labels ("smart",
"passionate"). "Identified the race condition without prompting and proposed a
lock-based solution" is a behavioral anchor. "Seemed smart" is not.
Structure a full interview loop
Map each stage to a unique competency. Never duplicate signals:
Calibration aligns interviewers on what each rubric level means:
Select 3-4 real or mock candidate responses (anonymized)
Have each interviewer score independently using the rubric
Reveal scores simultaneously (avoid anchoring)
Discuss disagreements - focus on which rubric criteria were interpreted
differently
Update rubric language where ambiguity caused divergence
Document decisions as "calibration notes" appended to the rubric
Target: interviewers should agree within 1 point on a 4-point scale at least
80% of the time.
Design a take-home assignment
Take-homes must balance signal quality with respect for candidate time:
State the expected time explicitly (2-4 hours)
Provide a starter repo with boilerplate already set up
Define submission format and evaluation criteria upfront
Include a README template for candidates to explain their approach
Grade with a rubric, not vibes
Offer a live follow-up to discuss the submission (15-30 min)
Anti-patterns / common mistakes
Mistake
Why it's wrong
What to do instead
No rubric before interviews
Every interviewer uses different criteria; inconsistent decisions
Write and distribute rubric before any candidate is interviewed
Asking trivia questions
Tests memorization, not ability; alienates strong candidates
Ask problems that require reasoning, not recall
"Culture fit" as veto
Becomes a proxy for demographic similarity
Define specific values and behaviors you are testing for
Same question for all levels
Junior and senior roles need different signal
Adjust complexity and expected depth per level
Discussing candidates before scoring
First opinion anchors everyone else
Score independently, then debrief
Marathon interviews (6+ hours)
Candidate fatigue degrades signal; disrespects their time
Cap at 4-5 hours including breaks
Only testing algorithms
Most roles never use graph traversal; poor signal for day-to-day work
Match question type to actual job tasks
No interviewer training
Untrained interviewers ask leading questions, give inconsistent hints
Run shadow sessions and calibration quarterly
Gotchas
Rubrics written after interviewing are not rubrics - If interviewers define what "good" looks like after seeing a candidate's answer, they are post-hoc rationalizing, not evaluating. Write rubric anchors before the first candidate session, not after.
Hints are part of the rubric, not a kindness - Unscripted hints produce wildly different interviews across candidates. Standardize hints: define at what point in the problem you offer a hint, what the hint is, and score separately whether the candidate needed it.
Take-home time estimates are always underestimated by designers - When you build the take-home, you already know the answer. Multiply your time estimate by 2-3x for candidates approaching it cold. A 4-hour take-home that actually takes 8-10 hours destroys candidate experience and trust.
Debrief sequencing affects outcomes more than debrief content - If the hiring manager or a senior engineer speaks first in the debrief, everyone else's scores shift toward theirs. Use independent written submissions before any discussion to prevent anchoring.
"Culture fit" rejections require the same documentation as technical rejections - Vague "not a culture fit" is legally and ethically risky. If a candidate is rejected for collaboration or communication, document the specific observable behaviors from the rubric, not the general feeling.
References
For detailed guidance on specific topics, read the relevant file from
the references/ folder:
references/system-design-questions.md - Library of system design questions
organized by level with expected discussion points and rubric anchors
references/coding-challenge-patterns.md - Coding challenge templates organized
by competency signal (API design, data modeling, debugging, concurrency)
references/rubric-calibration.md - Step-by-step calibration session guide with
sample scoring exercises and facilitator script
Companion check
On first activation of this skill in a conversation: check which companion skills are installed by running ls ~/.claude/skills/ ~/.agent/skills/ ~/.agents/skills/ .claude/skills/ .agent/skills/ .agents/skills/ 2>/dev/null. Compare the results against the recommended_skills field in this file's frontmatter. For any that are missing, mention them once and offer to install:
