# 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-` 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. ```