Skip to content
Skills Library
Education · Building & coding

interview-builder

/interview-builder

Turn a source .md document into a complete, research-backed interview kit — conduct rules, a leveled question bank with a full answer key and scoring anchors, and an evaluation model. Use whenever the user wants to build, generate, or update interview questions, an assessment, a screening test, a question bank, an answer key, or a rubric from notes, documentation, a curriculum, a syllabus, a spec, or a job description. Produces the kit that the `interviewer` skill later runs against a live candidate. Not for conducting the interview itself.

Licence
MIT
Last repository change
31.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 31.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Turn a source .md document into a complete, research-backed interview kit — conduct rules, a leveled question bank with a full answer key and scoring anchors, and an evaluation model. Use whenever the user wants to build, generate, or update interview questions, an assessment, a screening test, a question bank, an answer key, or a rubric from notes, documentation, a curriculum, a syllabus, a spec, or a job description. Produces the kit that the `interviewer` skill later runs against a live candidate. Not for conducting the interview itself.

Original author description

Turn a source .md document into a complete, research-backed interview kit — conduct rules, a leveled question bank with a full answer key and scoring anchors, and an evaluation model. Use whenever the user wants to build, generate, or update interview questions, an assessment, a screening test, a question bank, an answer key, or a rubric from notes, documentation, a curriculum, a syllabus, a spec, or a job description. Produces the kit that the `interviewer` skill later runs against a live candidate. Not for conducting the interview itself.

How it works

  1. Inputs
  2. Process
  3. Updating an existing kit
Original SKILL.md headings · 140 lines, 1,014 words
SKILL.md preview
---
name: interview-builder
description: >-
  Turn a source .md document into a complete, research-backed interview kit —
  conduct rules, a leveled question bank with a full answer key and scoring
  anchors, and an evaluation model. Use whenever the user wants to build,
  generate, or update interview questions, an assessment, a screening test, a
  question bank, an answer key, or a rubric from notes, documentation, a
  curriculum, a syllabus, a spec, or a job description. Produces the kit that
  the `interviewer` skill later runs against a live candidate. Not for
  conducting the interview itself.
---

# Interview Builder

You build the material a strict interview runs on. You do not conduct
interviews — that is the `interviewer` skill, which consumes your output.

Your output is judged by one question: **does this kit reliably separate people
who understand the topic from people who can talk about it?** A kit full of
definitional questions fails that test no matter how polished it looks.

## Inputs

A source `.md` file. Optionally: a target role/seniority, question count, time
budget, and areas to emphasise or exclude. If the user gave a file but no role,
infer the role from the material and **state your inference in `kit.md`** rather
than stopping to ask. Ask only when the source is ambiguous enough that two
readings produce genuinely different kits.

## Process

### 1. Read the source completely

Read the whole file before planning anything. Extract:

- the **subject matter** and its natural sub-areas
- the **depth signalled** by the material — a syllabus outline and an
  architecture deep-dive imply very different question banks
- anything already framed as a requirement, competency, or learning objective —
  these become level boundaries
- explicit scope limits

### 2. Research

Do not build from the source alone; the source tells you the topic, research
tells you what competence in that topic actually looks like.

- Use `WebSearch` / `WebFetch` when available: current best practice, common
  failure modes, the misconceptions practitioners actually hold, what changed
  recently, and what real work in this area involves.
- Search specifically for **how this goes wrong in production** — failure modes
  are the raw material for `debug` and `scenario` questions.
- When web tools are unavailable, build from model knowledge and say so in the
  provenance table with `model knowledge` as the source and a `low`/`med`
  confidence. Never present unverified recall as researched fact.
- Record every non-obvious factual claim that ends up in an answer key in the
  provenance table. If it is version-dependent, it also goes under
  **Known-unstable areas**.

### 3. Design the bank

Read `references/question-design.md` before writing questions. Non-negotiables
from it:

- **`theory` at most 40% of the bank** — the applied types (`scenario`,
  `practical`, `debug`, `tradeoff`, `livecode`) therefore carry at least 60%.
- **Include a `livecode` question whenever the role writes code.** It is the
  highest-signal question in a kit. Read `references/livecode-contract.md`
  before writing one, and **run your reference solution against your hidden
  tests** — an unverified live-coding task may not even be solvable as stated.
- Every question passes the **discrimination test** — a well-read candidate who
  has never done the work must visibly fail it.
- Levels are depth, not trivia. Set gates that mean something.
- Key points are **claims the candidate must state**, weighted, so awarding them
  is a yes/no call.
- **Acceptable variants** enumerated wherever a different-but-correct approach
  exists — omitting these is how a good candidate gets marked wrong.
- **Probes must not leak the answer.**

Default sizing when the user gives none: 15–20 questions across 3 levels, ~45–60
minutes total. Scale to the source's breadth, not to a round number.

### 4. Write the kit

Follow `references/output-contract.md` exactly — the `interviewer` skill parses
these structures, so headings, IDs, and field labels are load-bearing.

```
<kit-name>/
  kit.md          manifest, levels, thresholds, scope, provenance
  rules.md        references/rules-boilerplate.md verbatim + topic-specific rules
  questions.md    the bank and the answer key
  evaluation.md   references/evaluation-template.md verbatim + topic-specific notes
  livecode/       starter, hidden tests, reference solution (if the kit has a segment)
```

`rules.md` and `evaluation.md` are **copied verbatim** and then extended with a
topic-specific section. Do not edit the boilerplate rules or the scoring
formulas per kit — comparability across candidates depends on them being fixed.

Write the topic-specific sections with real content, not placeholders:

- **`rules.md` → `## Topic-specific rules`** — terminology that counts as
  equivalent; misconceptions common enough that the interviewer must mark them
  wrong even when stated confidently; questions where "it depends" is the
  correct answer rather than evasion.
- **`evaluation.md` → `## Topic-specific behavioral notes`** — what hedging
  looks like in this domain, and which domain habits are easily mistaken for
  deviation.

### 5. Verify before delivering

Check and report each of these — do not skip the count:

- [ ] `theory` counted and ≤40% of the bank. State the actual number.
- [ ] Every question has all contract fields; `none` written where empty.
- [ ] IDs unique, zero-padded, correctly leveled.
- [ ] No probe leaks its answer — re-read each one as someone who doesn't know.
- [ ] Point weights sum sensibly and the core insight outweighs the periphery.
- [ ] Every version-dependent fact appears under **Known-unstable areas**.
- [ ] Live coding, if present: reference solution **executed** against the hidden
      tests and passing; starter file leaks no approach; `kit.md` has the
      **Live coding** section; traps named.
- [ ] Provenance table covers every non-obvious claim in the answer key.
- [ ] `rules.md` and `evaluation.md` boilerplate is byte-identical to the
      references.

Then tell the user the kit path, the question count and type ratio, the levels
and gates, what you researched, and — honestly — which areas you are least
confident in.

## Updating an existing kit

Read the current kit first. Preserve existing question IDs; new questions get new
IDs. Never silently renumber — reports from past candidates cite these IDs.

**Refresh the boilerplate whenever the references have moved on.** A kit built
against an older version of `rules-boilerplate.md` or `evaluation-template.md`
is missing rules the interviewer is supposed to be bound by, and tags the report
is supposed to contain. To refresh without losing the kit's own content:

1. Split the kit file at its topic-specific heading (`## Topic-specific rules` /
   `## Topic-specific behavioral notes`) and keep the tail.
2. Rewrite the file as the current reference followed by that tail.
3. Verify the prefix is byte-identical to the reference — the same check as in
   step 5.

Then re-check the kit against the current contract: the type ratio, and whether
a role that writes code is still missing a `livecode` question. Say what you
refreshed and what it changed.
Files in this package (6)
  • SKILL.md 7 KB
  • references/evaluation-template.md 9 KB
  • references/livecode-contract.md 6 KB
  • references/output-contract.md 6 KB
  • references/question-design.md 5 KB
  • references/rules-boilerplate.md 6 KB

Versions

The database has no other skills named interview-builder.

Database snapshot: 13.11.2026 · package version 7203297f1609 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100interview-question-kit
    Generates a structured candidate-interview question set where every behavioral (STAR) and role-specific item maps to a defined competency and ships with strong/borderline/red-flag answer anchors plus delivery notes. Use when someone asks "write interview questions for this…
  • 100build-question-bank
    Build or revise the AI interviewer's versioned, AI-focused question corpus (AI fundamentals, building AI systems, evaluating AI models, and AI problem solving), plus its validation, offline lexical retrieval, and question-bank tests from CONTEXT.md step 7. Use for the workshop…
  • 90interviewer
    Conduct a strict, unbiased, interactive technical interview from a prepared interview kit, then produce a scored report with knowledge results, percentage-based behavioral metrics (deviation, distraction, hint dependency, intellectual honesty) and a personality assessment. Use…
  • 100qa-hiring-kit
    End-to-end structured hiring for QA / SDET / automation / test-lead / quality-manager roles - one chain from job description through interview question bank, competency-anchored scoring rubric, interviewer calibration guide, and post-interview panel debrief, to the 30-60-90 day…
  • 100mock-interview
    Runs a mock interview for a specific job description. Plays the interviewer in a chosen round (recruiter screen, hiring manager, behavioral, coding, system design, case, product sense, panel), persona and difficulty; asks one question at a time, probes vague answers, and gives…
  • 90interview-guide-builder
    Writes a non-leading user-research discussion guide with warm-up flow, open core questions, an attached probe bank, time budgets, and a pre-field bias audit. Use when someone asks "write my interview guide", "what should I ask users in discovery interviews", "review my questions…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.