Interview Debrief

Interview Debrief

The recording-powered debrief. When the user has a transcript of the interview, this reads what actually happened rather than their fuzzy memory of it, grades the performance against a concrete rubric, and turns it into two things: a plan to interview better next time, and the follow-up emails that keep this opportunity alive. Recording interviews is standard now. This is the skill that makes the recording pay off.

Boundary with interview-followup: use this skill when there's a transcript or recording. It does the deep, evidence-based analysis and drafts the follow-ups from what was really said. Use interview-followup when there's no recording. It runs a fast, memory-based thank-you plus debrief. Same learning loop, different input.

When to use

• "Here's my interview transcript", "analyze the recording", "debrief my Granola notes from the [company] round"
• "How did I do, and help me write the follow-up"
• Right after an interview, while the follow-up window is open (the recruiter/interviewer notes should go out inside ~24h)
• Any round that was recorded: recruiter screen, hiring manager, panel, technical, final

Inputs

• The transcript (required). Tool-agnostic. Accept any of:
  • Pasted transcript text in the conversation, or
  • A file the user saved to workspace/interviews/<id>-<round>-transcript.txt (or .md/.vtt/.srt)
  • Source doesn't matter: Granola, Otter, Fathom, Zoom, Google Meet, or hand-typed notes. If it's a raw ASR dump with speaker labels and filler, that's fine. Clean it up on read.
• Reads for context: pipeline/applications/<id>-...md (the role, interviewer names, the role thesis), workspace/output/<id>-interview-prep.md (what was expected vs. what happened), workspace/stories/story-bank.md, workspace/profile/profile.md, templates/outreach-templates.md (#5 post-interview note).
• Needs from user: the id/company and the round/stage if not obvious from the transcript, and who was in the room (names/titles) if the transcript doesn't make it clear.

Workflow

Part 1: Read and reconstruct the interview

1. Ingest the transcript. If it's a file, read it. If pasted, use it directly. Normalize speaker labels, strip ASR filler and timestamps, and map turns to people (candidate vs. each interviewer). If you can't tell who's speaking, ask once rather than guessing.
2. Rebuild the question set. List every question the user was actually asked, in order, tagged by interviewer. Flag which ones they anticipated (cross-reference <id>-interview-prep.md) and which were curveballs. The curveballs are the most valuable output.

Part 2: Grade the performance (the analysis)

3. Score each substantive answer on the same four axes interview-prep's mock uses, so prep and debrief speak one language. 1–5 each, with the evidence quoted from the transcript:
   • Structure. Clear STAR/framework, a point you can follow, no meandering
   • Specificity. Real names, numbers, detail, not "I collaborated cross-functionally"
   • Outcome. Lands on a concrete/quantified result
   • Concision. Leads with the answer, not a five-minute wind-up Quote the actual line so the critique is grounded, not generic. Note filler, hedging, buried leads, and every "we" that should have been "I".
4. Write the debrief in Start / Stop / Continue + Well / Improve form. This is the headline output:
   • What you did well. 2–4 specific moments that landed, quoted. (Reinforce these. They're repeatable strengths.)
   • What to improve. 2–4 specific weak moments, each with the better answer written out.
   • Start. Behaviors to add next time (e.g. "start quantifying the churn story, you told it with no number").
   • Stop. Behaviors to drop (e.g. "stop opening answers with 'so, basically', you did it 6 times").
   • Continue. What's working, keep doing it.
5. Name the patterns across rounds. Read prior debriefs in output/ for this search. If the same weakness shows up more than once (rambling on "why are you leaving?", no number on the flagship story, talking over the panel), call it out as a recurring pattern. Those are worth more than any single-interview note, and they set the next prep focus.
6. Read the room, honestly. From the transcript's actual signals (interviewer engagement, follow-up depth, what they volunteered about next steps, any hesitation), give a grounded read on how it went and likelihood of advancing. Cite the lines that inform it. Don't inflate. A realistic read beats an optimistic one.

Part 3: Draft the follow-up emails (gated)

7. Draft the follow-ups from what was actually said. This is the high-value moment, so use the transcript's specifics, not boilerplate. Produce the variants the user needs:
   • Recruiter note. Warm, brief, next-steps oriented: thanks, confirmed interest, one crisp line on fit, a light nudge on timeline/process. ~90 words.
   • Interviewer / hiring-manager note(s). One per person the user met, each referencing something specific to that conversation, reinforcing the fit on the thing they probed, and, where a question was fumbled, one clean sentence that answers it better (recovered straight from the improved answer in Part 2). ~120 words. Never copy-paste across people.
8. Slop gate. Run the writing-quality skill on every draft. Strip AI tells, hollow verbs, "I hope this finds you well", "I wanted to reach out", "it's not X it's Y". Do not show a draft until it passes.
9. Eval gate. Submit each email to artifact-eval (outreach spec). Fix any REVISE/FAIL and re-submit until PASS. This is the standard the rest of the system's outbound writing meets, and the follow-up is no exception.
10. Save and present, never send. Write each to output/<id>-followup-<recipient>.md and present for approval. The user sends every note themselves.

Part 4: Feed the system (close the loop)

11. Story bank. Append every new/unexpected question to stories/story-bank.md. For any answer that landed well, capture it as a reusable STAR story (via templates/story-template.md). A strong live answer is an asset for the next interview. For any fumble, store the stronger answer next to the question so it's ready next time. Flag any competency the round exposed that the bank doesn't cover.
12. Interview-prep. Write the recurring patterns and unfilled gaps forward so the next interview-prep session drills exactly what needs work. Note it in the application record's prep section and, if the pattern spans the search, at the top of the debrief so it's unmissable.
13. Application record. Append to pipeline/applications/<id>-...md a dated Debrief section: round, questions asked, per-axis scores summary, well/improve/start/stop/continue, room read, next steps the interviewer named, and that follow-ups were drafted (paths).
14. Tracker. Update pipeline/tracker.csv and advance status (e.g. interviewing → final, or hold if more rounds), set next_action = send follow-up + next_action_date = today, and the expected decision or next-round date. Update notes with the one-line read.
15. Report the loop: the grade summary (scores + the top 1–2 patterns), the follow-up drafts awaiting send, what landed in the story bank, and the tracker change.

Output

• Writes to:
  • workspace/output/<id>-debrief.md – the full analysis: question set, per-answer scores with quoted evidence, well/improve/start/stop/continue, recurring patterns, room read
  • workspace/output/<id>-followup-<recipient>.md – each follow-up email, writing-quality + artifact-eval passed, not sent
  • workspace/stories/story-bank.md – new questions, strong answers captured as stories, better answers for fumbles, gap flags (append)
  • workspace/pipeline/applications/<id>-...md – dated Debrief section + prep-forward notes
  • workspace/pipeline/tracker.csv – status, next_action, next_action_date, notes
• Format: debrief uses the Start/Stop/Continue plus Well/Improve structure above. Each email ends with a receipt line writing-quality: PASS · artifact-eval: PASS (outreach v<ver>, score N).

Rules & quality bar

• Ground every claim in the transcript. Quote the actual line. A debrief that could apply to any interview is worthless. The recording exists precisely so the feedback is specific.
• Both gates on every email. writing-quality then artifact-eval (outreach spec). No follow-up is shown until both PASS. The transcript-grounded specifics are what make these emails clear the bar easily. Use them.
• One note per person, genuinely personalized. Never a copy-paste across interviewers. Each references something distinct to that conversation.
• Never auto-send. Every email is drafted, saved, and presented. The human reviews and sends.
• No fabrication. Don't invent praise, a result, or a conversation moment that isn't in the transcript. If the user fumbled, say so plainly and fix it. Flattery helps no one improve. Numbers in the recovered answers are the real numbers or marked [metric TK].
• Be honest about the read. If the transcript signals it went poorly, reflect that in the debrief and the tracker. The point of the loop is a better next round, not reassurance.
• The analysis must close the loop, not just record it. Patterns feed prep, strong answers feed the bank, fumbles get a fix. A debrief that doesn't change the next interview failed.

Related skills

• Pairs with interview-followup. That skill is the no-recording path (a fast, memory-based thank-you and debrief). This one is the recording path (deep transcript analysis and gated follow-ups). Route by whether a transcript exists.
• Reads from: interview-prep (expected vs. actual), company-research, story-bank, job-fit-scoring (fit gaps become the objections that got probed)
• Runs: writing-quality (mandatory gate) and artifact-eval (outreach spec, mandatory PASS) on every follow-up
• Feeds: story-bank (new questions + strong answers), the next interview-prep (recurring patterns to drill), application-tracker (status + next action)
• Escalates to: offer-negotiation when the debrief signals an offer is coming
• Routed here by: search-and-scale-os after a recorded interview