# HR Interview Designer
**Design structured interviews that predict performance and eliminate bias.**
Unstructured interviews are worse than random at predicting job performance. This skill builds evidence-based interview processes that work.

## Philosophy
The best interviews are **structured, consistent, and scored**. Every candidate gets the same questions, evaluated against the same rubric, by a calibrated panel.

The model:
1. **Define** — What does success in this role actually require?
2. **Design** — Build questions that test those specific requirements
3. **Calibrate** — Train interviewers to score consistently
4. **Execute** — Run the process with minimal candidate friction
5. **Decide** — Use data, not gut feelings

## Input Required
- Job description with requirements
- Key competencies for the role (from hiring manager)
- Interview panel composition
- Timeline constraints
- Level of the role (affects depth expectations)

## Workflow

### Phase 1: Competency Mapping
```
Map JD requirements to interviewable competencies:

For each JD requirement, define:
  Requirement: "5+ years building distributed systems"
  Competency: System design at scale
  How to test: System design round with real-world scenario
  Score rubric:
    1 = Cannot design a simple system
    2 = Can design basic systems, misses edge cases
    3 = Solid design, considers trade-offs
    4 = Strong design with depth in multiple areas
    5 = Exceptional depth, teaches the interviewer something

Competency categories to cover:
  Technical/Functional:
    - Core skills (can they do the job?)
    - Problem-solving (how do they approach ambiguity?)
    - Depth (do they understand WHY, not just HOW?)

  Collaboration:
    - Communication (can they explain complex ideas simply?)
    - Teamwork (evidence of cross-functional collaboration)
    - Conflict resolution (how do they handle disagreement?)

  Leadership (for senior roles):
    - Decision-making (how do they make trade-offs?)
    - Mentoring (do they lift others up?)
    - Ownership (do they take responsibility beyond their scope?)

  Values/Culture:
    - Growth mindset (do they learn from failures?)
    - Alignment (do their values match company values?)
    - Motivation (why this role, this company, now?)
```

### Phase 2: Interview Architecture
```
Design the full interview loop:

Example: Senior Software Engineer (4 rounds)

Round 1: Technical Screen (45 min, video)
  Format: Coding exercise + technical discussion
  Focus: Core technical competence, communication
  Interviewer: Senior engineer on the team
  Questions: 2 coding problems at appropriate level
  Score: Technical skill (1-5), Communication (1-5)

Round 2: System Design (60 min, video or onsite)
  Format: Collaborative design session
  Focus: Architecture thinking, trade-offs, depth
  Interviewer: Staff/Principal engineer
  Questions: Open-ended design problem relevant to company domain
  Score: Design skill (1-5), Problem-solving (1-5), Depth (1-5)

Round 3: Behavioral + Collaboration (45 min, video)
  Format: STAR-based behavioral interview
  Focus: Past behavior as predictor of future performance
  Interviewer: Engineering manager or cross-functional partner
  Questions: 4-5 behavioral questions covering key competencies
  Score: Collaboration (1-5), Ownership (1-5), Growth (1-5)

Round 4: Hiring Manager (30 min, video)
  Format: Two-way conversation
  Focus: Mutual fit, motivation, career alignment
  Interviewer: Direct hiring manager
  Questions: Motivation, career goals, role-specific challenges
  Score: Motivation (1-5), Fit (1-5), Level appropriateness (1-5)

Total interview time: 3 hours
Candidate experience goal: "Challenging but fair. I felt heard."
```

### Phase 3: Question Bank
```
Curated questions by competency:

System Design:
- "Design a URL shortener that handles 100M URLs/day"
- "Design a real-time notification system for a social app"
- "Design the data pipeline for a ride-sharing analytics dashboard"
- "Design an API rate limiter for a multi-tenant SaaS platform"

Coding:
- "Implement an LRU cache with O(1) get and put"
- "Design and implement a task scheduler with priority queues"
- "Build a simple key-value store with persistence"
- "Parse and evaluate a boolean expression string"

Behavioral (STAR format expected):
- "Tell me about a time you had to make a decision with incomplete information"
- "Describe a situation where you disagreed with your team's direction"
- "Walk me through your biggest professional failure and what you learned"
- "Tell me about a time you had to influence without authority"
- "Describe a project where you had to learn something completely new"

Leadership (for senior/staff):
- "How do you decide what to work on when everything is a priority?"
- "Tell me about a time you had to push back on a leadership decision"
- "How do you mentor engineers who are stuck?"
- "Describe how you've driven technical standards across a team"

Reverse interview (questions for the candidate to ask):
- "What does a typical week look like for someone in this role?"
- "What's the biggest challenge the team is facing right now?"
- "How does the team make technical decisions?"
- "What does onboarding look like for the first 30 days?"
- "How is performance measured for this role?"
```

### Phase 4: Rubric Design
```
Create a scoring rubric for each question:

Example: System Design Interview

Score 5 (Strong Hire):
- Clarifies requirements before designing
- Proposes multiple approaches with trade-off analysis
- Considers scale, reliability, and cost
- Adapts based on constraints introduced mid-session
- Communicates clearly throughout
- Demonstrates depth in areas relevant to our systems

Score 4 (Hire):
- Covers most requirements
- Shows solid architectural thinking
- Considers key trade-offs
- Good communication
- Some depth in relevant areas

Score 3 (Lean Hire):
- Basic design covers functional requirements
- Some consideration of scale
- Communication adequate
- Limited depth

Score 2 (Lean No Hire):
- Incomplete design
- Misses key requirements
- Struggles with ambiguity
- Surface-level understanding

Score 1 (Strong No Hire):
- Cannot structure a design
- No consideration of constraints
- Poor communication
- Significant knowledge gaps

Calibration rule:
After each round, interviewer writes:
1. Score (1-5)
2. Evidence (specific things said/done)
3. Confidence (high/medium/low)
4. Recommendation (strong hire / hire / no hire)
```

### Phase 5: Debrief Framework
```
Structured debrief after all rounds:

1. Each interviewer shares (2 min each):
   - Overall score
   - Top evidence for hire
   - Top concern
   - Recommendation

2. Discussion (10 min):
   - Where do scores diverge?
   - What additional information is needed?
   - Any process concerns (bad day, technical issues)?

3. Decision framework:
   All 4s and 5s → Strong hire
   Mostly 3s and 4s, no 1s or 2s → Hire
   Mixed 2s and 3s → Discuss further, may need additional round
   Any 1s → Strong signal to pass
   2+ interviewers say no hire → Default to no hire

4. Decision:
   □ Strong Hire — make offer immediately
   □ Hire — proceed with offer
   □ Additional round needed — schedule within 48 hours
   □ No Hire — send rejection within 24 hours

Anti-bias rules:
- No "culture fit" discussions (use "values alignment" with evidence)
- No "gut feeling" without supporting evidence
- No anchoring on first interviewer's score (share scores simultaneously)
- No discussing candidates from other roles in the same debrief
```

## Candidate Experience Checklist
```
Before the interview:
□ Send calendar invite with video link/location, parking info
□ Share interview format: who they'll meet, what to expect, duration
□ Offer accommodation options (timezone, accessibility)
□ Confirm 24 hours before

During the interview:
□ Start on time (being late signals disrespect)
□ Introduce yourself and the format
□ Ask if they have any questions before starting
□ Leave 5-10 min at the end for their questions
□ Be genuinely enthusiastic — they're evaluating you too

After the interview:
□ Thank them within 24 hours
□ Share next steps and timeline
□ Deliver the decision within the promised timeframe
□ If rejected, give a brief genuine reason if possible
□ If offer, follow up with excitement and momentum

Candidate experience scorecard:
"Would I recommend interviewing here to a friend?"
Target: 8+/10 even for rejected candidates
```

## Integration with Other Skills
- **hr-job-description-forge**: JD requirements map to interview competencies
- **hr-candidate-hunter**: Screening feeds into interview pipeline
- **hr-offer-architect**: Interview scores inform level and compensation
- **hr-onboarding-commander**: Pre-hire data feeds into onboarding plan

## Files
- `memory/hr/interview-plan-[role].md` — Full interview plan per role
- `memory/hr/question-bank-[department].md` — Department-specific questions
- `memory/hr/rubrics/[role].md` — Scoring rubrics per role
- `memory/hr/debrief-[candidate]-[date].md` — Debrief notes per candidate