---
name: interview-loop-design
source: https://app.decimal.ai/s/interview-loop-design@1/SKILL.md
source_sha256: e4bc32e07066
---

# Design an interview loop as a competency-coverage matrix

Asked to "set up the interviews for role X", a base model lists rounds: phone screen, technical,
onsite, culture fit, final. The rounds sound reasonable but overlap heavily — three of them
quietly re-test "problem solving" and "communication" — while a competency the role actually
depends on gets no dedicated signal. The loop is longer than it needs to be and still has holes.

Design the loop from the **competencies**, not from a count of rounds. Build a matrix, assign one
owner per competency, and only then decide how many stages you have.

## The method

1. **List the must-have competencies first.** What must this role be able to do? Name 3-6 concrete
   competencies (e.g. coding, system design, debugging, cross-team collaboration, ownership). These
   are the rows of the matrix. Ignore how many interviews you think you want — that falls out later.

2. **Give each competency exactly one owner stage.** For every competency, pick the single stage
   that produces the *deciding* signal on it. That stage is its **primary owner**. A stage may touch
   another competency in passing (a system-design round hears the candidate communicate), but only
   the owner's signal counts toward the hire decision on that competency. One owner per row.

3. **Give each stage a distinct set of competencies and one defined signal.** A stage exists to own
   a set of competencies nothing else owns and to emit one output — a scorecard section, a go/no-go
   on its dimension. Write down what each stage's signal *is*.

4. **Run the coverage check.** Two failures to hunt for:
   - **Gap** — a must-have competency with no owner stage. Assign it to a stage or add one.
   - **Overlap** — a competency with more than one primary owner, or two stages whose competency
     sets are near-duplicates. Merge the stages or move one competency so each has a single owner.

5. **Prune redundant stages.** A stage that owns no competency other stages don't already cover is
   redundant — cut it or fold its unique piece into a neighbor. "Final round" and "culture fit" earn
   a slot only if they own a competency (e.g. values alignment, executive presence) nothing else
   tests. The right loop is the **fewest stages that cover every must-have with one owner each**.

## Output shape

Produce the matrix (competencies down the side, stages across the top, one primary owner marked per
competency), then per stage state the competencies it owns and its one signal, then the coverage
check: list any GAP (uncovered competency) and any OVERLAP (competency owned by more than one stage,
or duplicate stages) with the fix. If the loop is clean, say so explicitly — no gaps, no overlaps.

Don't invent competencies the ask didn't imply, don't grade a specific candidate, and don't write
the questions inside each stage — that's a separate step. Design the loop; leave the interviews to
the interviewers.

## Worked example

> Role: **backend engineer**. Must-have competencies: coding, system design, debugging under
> pressure, cross-team collaboration.

Matrix (one primary owner per row):

| Competency              | Recruiter screen | Coding round | System-design round | Behavioral round |
|-------------------------|:---:|:---:|:---:|:---:|
| coding                  |     | **owner** |     |     |
| system design           |     |     | **owner** |     |
| debugging under pressure|     | **owner** (live-debug segment) |     |     |
| cross-team collaboration|     |     |     | **owner** |

Per-stage signal:
- **Coding round** — owns coding + debugging under pressure. Signal: a scorecard on code correctness
  and how the candidate recovers when a test fails live.
- **System-design round** — owns system design. Signal: a scorecard on decomposition and trade-offs.
- **Behavioral round** — owns cross-team collaboration. Signal: STAR evidence of working across teams.

Coverage check: **No gap** — all four competencies owned. **No overlap** — each owned once. Note the
loop dropped a generic "onsite culture fit" round the base model would have added: it owned no
competency the behavioral round didn't already cover, so it was redundant. Four competencies, three
signal-bearing stages plus the recruiter screen.

Counter-example the method catches: a loop with "technical phone screen", "onsite coding", and
"take-home" all owning *coding* is three owners for one row — overlap. Collapse to one coding owner
and reclaim two slots (or leave the role with a shorter loop).