# Interview Question Bank — Twelve Prompts for Claude
A pack of structured prompts for generating a tiered interview question library from a role rubric. Paste a rubric, paste a prompt, get a question library tagged with rubric dimensions, anchors, and follow-ups.
## How to use this pack
1. Create a Claude project named `interview-questions-<role-slug>` per role.
2. Drop the role rubric in as project knowledge. Every prompt below assumes the rubric is loaded and reads from it.
3. Save each prompt below as a saved prompt within the project, tagged by tier.
4. Run them in order. Most produce 30-90 second outputs at Sonnet 4.6 speed.
5. Review the outputs. Edit for the firm's voice. The pack delivers a competent starter; the hiring manager owns the final library.
## Rubric input shape
The pack assumes a rubric with this shape (the same shape used by the screening, take-home, and reference workflows):
```json
{
"role": "Senior Backend Engineer",
"level": "Senior IC (L5)",
"dimensions": [
{
"id": "skill_match",
"label": "Production Go or Rust experience and distributed-systems depth",
"anchors": {
"1": "...",
"2": "...",
"3": "...",
"4": "...",
"5": "..."
}
},
...
]
}
```
If the rubric doesn't load, the prompts halt and ask for the rubric file.
---
# Tier 1 — Behavioral
## B1. Three behavioral questions per rubric dimension
```
Role: You are a structured-interviewing question author. Write behavioral
questions in STAR shape (Situation, Task, Action, Result) calibrated to
a specific rubric dimension and anchor.
Context: The rubric is loaded as project knowledge. Every dimension has
five anchors (1-5) describing observable behaviors at increasing depth.
Task: For each dimension in the rubric, write THREE behavioral questions.
Each question must:
- Probe past behavior (NOT hypothetical — that's tier 2)
- Be calibrated to discriminate between two named anchors (e.g. "this
question discriminates anchor 3 from anchor 4")
- Be answerable in 3-5 minutes by a candidate at the role's level
- Avoid leading language ("tell me about a successful project" is leading;
"tell me about a project that didn't go as planned" is neutral)
For each question, output:
- The question text
- The dimension it probes
- The anchors it discriminates between
- The signal you're listening for in a strong answer
- The signal you're listening for in a weak answer
Things to avoid:
- Questions that probe traits ("are you a team player?") — probe behavior.
- Questions that have a single right answer — questions that probe the
candidate's framing of the problem.
- "Culture fit" questions without behavioral anchors.
- Questions about protected-class topics or proxies (school name, employment
gaps, family status, etc.).
Output format: Markdown, grouped by dimension, with a level-2 heading per
dimension and a level-3 heading per question.
```
## B2. Drill-down questions for rehearsed answers
```
Role: You are a structured-interviewing question author. The candidate has
clearly prepped the behavioral question — they answered too fluidly, with
named outcomes and a clean STAR structure. The drill-down asks for a
different example, a counter-factual, or a step they skipped.
Context: The rubric is loaded as project knowledge. Tier-1 behavioral
questions (B1 output) are loaded too.
Task: For each B1 question, produce ONE drill-down. Each drill-down must:
- Ask for a different example, the same dimension ("walk me through a
different time you had to do that")
- Or ask for a counter-factual ("what would you have done differently?")
- Or probe a step the candidate skipped ("what happened between steps 2
and 3? You moved fast there")
- Land in 30-60 seconds — drill-downs are quick probes, not new questions
For each drill-down, output:
- The drill-down question
- The B1 question it pairs with
- What the rehearsed-answer pattern looks like (so the panelist knows
when to use the drill-down)
Things to avoid:
- Aggressive or interrogator-style framings — the drill-down is curiosity,
not confrontation
- Drill-downs that probe a different dimension than the B1 question
- Drill-downs that ask the candidate to defend their original answer
Output format: Markdown, paired with the B1 question.
```
## B3. Behavioral questions probing failure / negative cases
```
Role: You are a structured-interviewing question author. Standard behavioral
questions probe success. Strong candidates have practiced "tell me about a
weakness" answers ("I'm a perfectionist"). The negative-case questions probe
failure without the rehearsal-friendly framing.
Context: Rubric loaded as project knowledge.
Task: For each rubric dimension, write THREE behavioral questions that probe
the candidate's behavior when they FAILED at the dimension. Each question
must:
- Probe a real failure ("tell me about a time you misjudged X")
- NOT be the "weakness" question
- Calibrate to the rubric — failure on a dimension at level 3 looks
different from failure at level 5 (a junior engineer's worst day is
a senior engineer's normal day)
- Be answerable without the candidate having to disclose a confidential
incident — the question should work even if the example is sanitized
For each question, output:
- The question text
- The dimension it probes
- The signal of a healthy failure narrative (named cause, named
correction, named lesson)
- The signal of an unhealthy narrative (blame on others, no specific
cause, no lesson, "I'm a perfectionist" pattern)
Things to avoid:
- Asking the candidate to disclose a regulated or proprietary incident
- Probing for failures that are protected-class adjacent (gaps, etc.)
- Stress-test framings ("describe your biggest professional regret")
Output format: Markdown, grouped by dimension.
```
---
# Tier 2 — Situational
## S1. Two situational scenarios per rubric dimension
```
Role: You are a structured-interviewing question author. Situational
questions probe how the candidate would handle a hypothetical, calibrated
to the role's level.
Context: Rubric loaded as project knowledge. Pay attention to the role's
level — Senior IC scope problems are different from Manager scope problems.
Task: For each rubric dimension, write TWO situational scenarios. Each
scenario must:
- Be calibrated to the role's level (a Senior IC scenario probes
cross-team-system tradeoffs; a Staff IC scenario probes org-wide
architectural tradeoffs)
- Be answerable in 5-8 minutes
- Have multiple defensible answers — the scenario probes the candidate's
framing, not a "right answer"
- Stay grounded in real situations the candidate would plausibly hit —
not contrived puzzles
For each scenario, output:
- The scenario as a paragraph (set the stage in 50-100 words)
- The opening question
- Two follow-up probes (drill-downs based on the candidate's first
response — "if they answer X, ask Y; if they answer Z, ask W")
Things to avoid:
- Trick questions or gotchas
- Scenarios that depend on the candidate having seen this exact stack
- Scenarios with a single "smart" answer — those probe pattern-matching,
not judgment
Output format: Markdown, grouped by dimension.
```
## S2. Listening dimensions per scenario
```
Role: You are a structured-interviewing notetaker primer. Panelists listen
for specific things in each scenario answer. Without the listening
dimensions, panelists collect anecdotes; with them, they collect signal.
Context: Rubric loaded as project knowledge. S1 scenarios loaded too.
Task: For each S1 scenario, list the FIVE answer dimensions the panelist
should listen for. Each dimension must:
- Be observable in the candidate's spoken answer (NOT something only
visible in their resume or in code)
- Map to a specific rubric anchor
For each scenario, output:
- "What strong answers do" (3 bullets — name the moves, the questions
asked back, the criteria stated)
- "What weak answers do" (3 bullets — name the failure patterns: jumping
to solution without clarifying, ignoring constraints, generic framing)
- "What to write down" (the concrete notes the panelist takes that anchor
the debrief later)
Output format: Markdown, paired with each S1 scenario.
```
---
# Tier 3 — Technical / craft deep-dive
## T1. Five deep-dive questions per must-have skill
```
Role: You are a craft-deep-dive question author. The role's rubric names
must-have skills. The deep-dive probes whether the candidate has the skill
at depth — not just whether they can name it.
Context: Rubric loaded as project knowledge. Focus on the must_have skills.
Task: For each must-have skill in the rubric, write FIVE deep-dive
questions. Label each as:
- SHALLOW: sanity check the candidate has the skill at all (e.g. "explain
how Go's goroutines differ from threads")
- DEEP: probe the edges of the skill (e.g. "walk me through the time you
debugged a goroutine leak — what symptoms led you to suspect it, what
tools did you use, what was the fix")
The mix should be 1 shallow + 4 deep per skill. The deep questions are
the differentiators; shallow questions are gates.
For each question, output:
- The question text
- SHALLOW or DEEP label
- The skill it probes
- The signal of a 4-anchor answer (depth, but not edge-case awareness)
- The signal of a 5-anchor answer (depth + named edge cases + cited
failure modes the candidate has personally hit)
Things to avoid:
- Trivia questions ("what's the keyword in Rust for X?") — probe usage,
not memorization
- Questions whose answer changes between language versions (probe
fundamentals, not the latest framework's API)
- Whiteboard-coding questions framed as discussion — those are a
different format
Output format: Markdown, grouped by skill.
```
## T2. Three follow-ups per deep-dive question
```
Role: You are a deep-dive follow-up author. The candidate's first answer
to a deep question is correct but surface-level. The follow-ups drill
into the edges of the skill where deeper signal lives.
Context: Rubric loaded. T1 questions loaded.
Task: For each T1 deep question, produce THREE follow-ups. Follow-ups
must:
- Drill into a specific edge of the skill (the failure mode, the limit
of the technique, the case where the standard answer breaks)
- Be open-ended — the candidate constructs the answer
- Be answerable in 2-4 minutes each
- Surface the candidate's ability to ENGAGE with not-knowing — partial
answers are signal too
For each follow-up, output:
- The follow-up question
- What edge of the skill it probes
- What an "I don't know but here's how I'd find out" answer looks like
Things to avoid:
- Follow-ups that assume the candidate already gave a wrong answer
- Stacked follow-ups that pile pressure rather than probe depth
Output format: Markdown, paired with each T1 question.
```
## T3. Gap-finding questions per skill
```
Role: You are a gap-finding question author. Most technical questions
probe whether the candidate HAS a skill. Gap-finding probes whether the
candidate notices the LIMIT of the skill — when to use a different tool.
Context: Rubric loaded.
Task: For each must-have skill, write TWO questions that probe whether
the candidate notices when the skill is the wrong fit. Each question must:
- Describe a situation where the candidate's claimed skill would be
over-applied or mis-applied
- Ask the candidate to identify the alternative tool
- Probe judgment, not memorization
For each question, output:
- The question text
- The skill it probes
- The strong-answer pattern (named alternative tool, named criteria for
when each fits)
- The weak-answer pattern (defends the original tool, doesn't notice
the limit, claims the original tool covers the case)
Output format: Markdown, grouped by skill.
```
---
# Tier 4 — Reverse questions
## R1. Substantive questions a strong candidate might ask
```
Role: You are a reverse-question reader. Strong candidates ask substantive
questions about the role, the team, the firm. The questions they ask
signal what they prioritize.
Task: Produce a list of 10 substantive questions a strong candidate at
this role's level might ask, grouped by what each question signals.
For each question, output:
- The question
- What it signals (the candidate is thinking about ramp time, about
technical decision authority, about the trajectory of the team, etc.)
- How the panelist should respond — honestly, with specifics, not with
the recruiter pitch
Things to avoid:
- Generic questions ("what's the culture like?") — those are tier R2
- Questions that fish for the panelist's commitment ("would you
recommend joining?") rather than probe substance
Output format: Markdown, grouped by signal.
```
## R2. Generic / weak questions and what they signal
```
Role: You are a reverse-question reader. Weak candidates ask generic
questions. Generic questions are not necessarily disqualifying — they
might be early-career, or anxious — but they are signal.
Task: Produce a list of 10 generic / weak questions and what each
signals.
For each question, output:
- The question
- The signal it sends (didn't research, anxious about basics, fishing
for a specific answer the candidate already has, etc.)
- How the panelist should react — usually, redirect to a more specific
question to give the candidate another chance
Output format: Markdown, grouped by signal.
```
## R0. Synthesizing the reverse-question read
```
Role: You are an interview debrief facilitator. The candidate asked
N questions across the loop. The synthesis pulls the signal from the
pattern, not the individual questions.
Context: Rubric loaded. R1 + R2 outputs loaded.
Task: Produce a one-page synthesis template the panel uses in the debrief
to read the candidate's reverse questions as a pattern. The template
captures:
- Which substantive areas the candidate probed (matching to R1 signals)
- Which generic patterns showed up (matching to R2 signals)
- The cross-panelist read — different panelists got different questions;
the pattern is the read
Output format: A markdown template the panel fills in during the debrief.
```
