technical-interviewing（技术面试）

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

1. 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.
2. 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.
3. 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.
4. 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.
5. 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:

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:

1. Competency - What you are testing (e.g. "API design")
2. Levels - Typically 4: Strong Hire, Hire, No Hire, Strong No Hire
3. Behavioral anchors - Concrete examples of what each level looks like
4. 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:

1. Identify 1-2 core competencies the role needs daily
2. Design a problem that requires those competencies to solve
3. Create 3 difficulty tiers: base case, standard, extension
4. Write the rubric before finalizing the problem
5. 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:

1. Pick a system the candidate likely understands as a user
2. Define initial constraints (users, QPS, data volume)
3. Prepare 4-6 follow-up dimensions to probe depth
4. 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:

ROLE: <Title, Level>
TOTAL STAGES: <N>

Stage 1 - Phone Screen (45 min)
  Interviewer type: Any engineer
  Format: Practical coding
  Tests: Baseline coding ability, communication
  Question: <Specific question or question bank ID>

Stage 2 - Technical Deep-Dive (60 min)
  Interviewer type: Domain expert
  Format: Domain-specific coding
  Tests: <Role-specific competency>
  Question: <Specific question>

Stage 3 - System Design (60 min)  [Senior+ only]
  Interviewer type: Senior+ engineer
  Format: Whiteboard / virtual whiteboard
  Tests: Architecture thinking, trade-off reasoning
  Question: <Specific question>

Stage 4 - Culture & Collaboration (45 min)
  Interviewer type: Cross-functional partner
  Format: Behavioral + scenario-based
  Tests: Communication, conflict resolution, ownership

Run a calibration session

Calibration aligns interviewers on what each rubric level means:

1. Select 3-4 real or mock candidate responses (anonymized)
2. Have each interviewer score independently using the rubric
3. Reveal scores simultaneously (avoid anchoring)
4. Discuss disagreements - focus on which rubric criteria were interpreted differently
5. Update rubric language where ambiguity caused divergence
6. 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

Gotchas

1. 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.
2. 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.
3. 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.
4. 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.
5. "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: `` npx skills add AbsolutelySkilled/AbsolutelySkilled --skill <name> ` Skip entirely if recommended_skills` is empty or all companions are already installed.