What Is CXL?

Module 26 was about failures. This module is about being asked, and it starts where every CXL interview starts: so, what is CXL?

The honest answer takes an afternoon. The answer you have is ninety seconds, and the phrase that fits in ninety seconds — "coherent memory over PCIe" — is true, is what most candidates say, and names none of the three protocols, neither of the memory semantics, and no reason anybody built it.

1. The Engineering Problem — Ninety Seconds Is A Budget

An answer is bounded by time, and the bound decides which points exist. Nine prepared points at fifteen seconds each against a ninety-second clock is six points heard and three delivered past a listener who stopped. Section 5.

Reciting facts is not answering a question. Six correct statements about CXL against a four-point question, two of them hit, is half an answer delivered fluently — and fluency is what the speaker hears. Section 6.

An answer pitched three tiers above the question fails. It fails differently from one pitched below, and only the under-pitched failure is ever noticed by the person making it. Section 7.

"Coherent memory over PCIe" names none of the three protocols. CXL.io, CXL.cache and CXL.mem are the answer; the phrase is the label on the box. Section 8.

An analogy carries truth for a fixed number of steps. Two steps of a good analogy against five steps taken is six truths carried and twelve falsehoods implied, and nothing marks the step where it turned. Section 9.

This chapter against the rest of module 27, stated precisely. The later chapters take one CXL topic each and go deep. This one owns the shape of an answer — which is why every model here is about what an answer contains rather than what CXL is, and why section 14's weak definition is the one-liner itself.

2. The One-Sentence Model

An answer has done its job when the one-line definition was given, it fitted the time, it hit the points the question wanted, it was pitched at the tier that was asked, every term it used was one the listener had, and nothing was asserted without backing — and "CXL is coherent memory over PCIe" is one of those six.

3. What This Chapter Owns

Before the models, the content — because an answer-shape chapter with no answer in it would be exactly the failure section 6 is about.

CXL is three protocols multiplexed over one PCIe physical link. That sentence is the spine and everything else hangs off it.

CXL.io is PCIe. Configuration, enumeration, interrupts, DMA — the discovery and management plane, unchanged in semantics from what a PCIe device already speaks. It is how the device is found and set up, it is mandatory for every CXL device, and it is the reason a CXL device drops back to being an ordinary PCIe device when the other two are unavailable. 27.2 is entirely about this one.

CXL.cache lets the device cache host memory coherently. An accelerator with a CXL.cache interface can pull a line of host memory into its own cache, hold it, modify it, and have the host's coherency protocol know about it — the same snoop-and-invalidate machinery the host's own cores live under, extended across the link.

CXL.mem lets the host access device memory as memory. Not as a block device, not through a driver, not with a DMA descriptor — as load-and-store addressable memory in the host's own physical address space, cacheable by host cores.

The two directions are the whole point, and they are what PCIe cannot do. PCIe moves data between a device and host memory by explicit transfer. CXL lets each side hold and address the other's memory with the memory model intact. That is one sentence longer than the one-liner and it is the sentence the one-liner is missing.

Three device types follow directly from which protocols are present. Type 1 is io plus cache — an accelerator with no memory of its own that wants coherent access to the host's. Type 2 is io, cache and mem — an accelerator with its own memory that both sides need coherent access to. Type 3 is io plus mem — a memory expander, no accelerator, the host's memory made larger. Type 3 is most of the deployed market and the one an interviewer is most likely to mean.

That is roughly a hundred and forty seconds of material. Section 5 is about what to do with ninety.

Three more facts belong in the reserve, to be used only if a follow-up asks for them.

The link is PCIe electrically and is negotiated at link training. A CXL device and a PCIe root port begin by training as PCIe; whether the link comes up as CXL is decided during that negotiation, through an alternate-protocol mechanism defined for exactly this purpose. That is why a CXL device in a PCIe-only slot works and works as a PCIe device — and it is the single most useful fact for making the PCIe relationship concrete rather than asserted.

Coherency is the host's, extended outward. CXL does not invent a coherency protocol for the device to run; it extends the host's existing one across the link, which is why the host remains the point of coordination and why a CXL device's coherent behaviour is described relative to the host's home agent rather than to a peer protocol. The asymmetry is deliberate and it is what makes the protocol implementable by device vendors who are not CPU vendors.

Latency is the constraint that shapes everything. CXL.mem is useful because a load from device memory is in the same order of magnitude as a load from DRAM behind the memory controller — further, but not a different kind of thing. If it were a hundred times further it would be a block device with extra steps, and the entire architecture would be pointless. An answer that mentions latency at all is immediately distinguishable from one assembled out of a datasheet, and it costs one clause.

None of these three belongs in the ninety seconds. All three belong in the next ninety, which is section 11's subject.

4. Teaching-Model Boundary

Every model in this chapter is a teaching model, not a scoring rubric to be applied to a real interview. It computes the one relationship the section is about and nothing else. There is no natural language, no transcript, no interviewer and no candidate anywhere in this file.

Each model is built twice from one source. A parameter selects between the measured build, which computes what an answer actually delivered, and the speaker's build, which computes what it felt like to give. The two are instantiated side by side against identical stimulus, and every section's headline number is the gap between them.

That framing is the reason this chapter is modelled rather than listed. The failure in every section is one the speaker cannot feel while speaking: the clock, the point count, the tier, the listener's vocabulary, the unbacked claim. A list of advice is forgettable. A number that says six of your nine points were heard is not.

5. RTL 1 — Ninety Seconds Is A Budget

Start with the constraint that is announced explicitly and then ignored immediately, because it is the only one in the chapter that is stated out loud.

"Tell me about CXL in a minute or two" is a budget. It converts directly into a number of points: how many things you can say, at whatever rate you say things. Everything prepared past that number is not a bonus — it is material that will be delivered to somebody who has already moved on, or will not be delivered at all because the interviewer interrupted.

The uncomfortable part is that the speaker cannot feel the boundary. There is no signal at second ninety-one.

// RTL 1 - an answer is bounded by time. Ninety seconds is not a suggestion; it
// is the number of points that fit, and choosing them is the whole of the
// preparation.
module answer_budget #(parameter int SAY_IT_ALL = 0) (
  input  logic clk, rst_n,
  input  logic        deliver,
  input  logic [15:0] budget_sec, sec_per_point, points_prepared, points_needed,
  output logic [15:0] points_that_fit, points_made, spoken_sec, budget_pct,
  output logic        in_budget,
  output logic [7:0]  n_answers, n_overrun,
  output logic        overrun_err
);
  logic [15:0] fit_q, true_made;
  logic [31:0] s_q, b_q;
  logic        truly_over;
  // How many points the clock allows, and how many were actually prepared.
  assign fit_q = (sec_per_point == 16'd0) ? points_prepared
                                          : (budget_sec / sec_per_point);
  assign points_that_fit = (fit_q > points_prepared) ? points_prepared : fit_q;
  // The say-it-all delivery makes every prepared point regardless of the clock.
  assign true_made = points_that_fit;
  assign points_made = (SAY_IT_ALL != 0) ? points_prepared : true_made;
  assign s_q = {16'd0, points_made} * {16'd0, sec_per_point};
  assign spoken_sec = (s_q > 32'hFFFF) ? 16'hFFFF : s_q[15:0];
  assign b_q = (budget_sec == 16'd0) ? 32'd0
             : (({16'd0, spoken_sec} * 32'd100) / {16'd0, budget_sec});
  // This percentage is the one place in the chapter where exceeding a hundred
  // is the result rather than an error, so it saturates high rather than at
  // the budget: clamping it to a hundred hides exactly what it measures.
  assign budget_pct = (b_q > 32'd999) ? 16'd999 : b_q[15:0];
  assign in_budget = (spoken_sec <= budget_sec);
  assign truly_over = (points_prepared > points_that_fit) && (budget_sec != 16'd0)
                      && (points_needed != 16'd0);
  // Every prepared point delivered, past a clock that stopped listening.
  assign overrun_err = deliver && truly_over && (points_made > points_that_fit);

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_answers <= 8'd0; n_overrun <= 8'd0;
    end else if (deliver) begin
      n_answers <= n_answers + 8'd1;
      if (!in_budget) n_overrun <= n_overrun + 8'd1;
    end
  end
endmodule

Nine prepared points at fifteen seconds each is six points inside ninety seconds and three delivered past the clock — a hundred and fifty percent of the budget. The say-it-all delivery makes all nine, which is what preparation produces when it is not pruned against a clock.

Figure 1 — the same preparation, delivered two ways. The upper path is what happens when the material is not pruned against a clock: every prepared point is made, and the last three are made to somebody who stopped listening at second ninety. The lower path is the same nine points with the arithmetic done first. Nothing about the content differs; the only decision is whether the cut is made during preparation or by the interviewer.

The second case is the target state and it is worth naming as a goal rather than a constraint: six points prepared for a six-point budget uses the whole clock and overruns nothing. Preparation is not about having more to say; it is about having exactly as much as fits, chosen deliberately.

Two degenerate inputs are driven. Points with no duration attached cannot overrun anything, which is why any estimate of seconds-per-point beats none — the commonest form of this failure is preparing a list with no sense of how long each item takes. And an answer with no time allowed at all produces zero points in the measured build and all nine in the other: the interviewer who says "briefly" and means it.

The percentage in this model saturates at nine hundred and ninety-nine rather than at a hundred, and that is deliberate. Every other percentage in this track clamps at the whole, because exceeding the whole is an arithmetic error. Here, exceeding the budget is the result — a hundred and fifty percent is the number the section exists to produce, and clamping it to a hundred would hide exactly what is being measured.

There is a second-order effect in this model worth naming, because it is the reason an over-long answer is worse than it looks arithmetically. Points delivered past the clock do not merely fail to land — they displace the interviewer's next question, which is where the actual evaluation happens. An answer that runs to a hundred and thirty-five seconds has spent forty-five seconds of somebody else's time, and the follow-up that would have been asked in that window is a follow-up on ground the candidate chose. Section 11 prices that directly. The two sections compound: over-running does not just waste the tail of the answer, it spends the thing the answer was supposed to buy.

6. RTL 2 — Reciting Facts Is Not Answering A Question

The second failure, and the one that feels best from the inside.

A question has points it wants. What is CXL wants, roughly: what it is, what it is for, how it relates to PCIe, and why anybody built it. An answer that names the three protocols, gives the version history and explains the flit format has recited six correct facts and hit perhaps one of the four points.

Fluency is the trap. The speaker hears themselves being correct and concludes they were answering, and the two are only weakly related.

// RTL 2 - the points the question wanted against the points made. Naming the
// three protocols is a fact about CXL and is not, on its own, an answer to
// what CXL is for.
module answer_reach #(parameter int NAMING_IS_ANSWERING = 0) (
  input  logic clk, rst_n,
  input  logic        score_it,
  input  logic [15:0] points_wanted, points_hit, facts_recited, listener_tier,
  output logic [15:0] hit_ok, missed_points, reach_pct, recited_pct,
  output logic        question_answered,
  output logic [7:0]  n_scores, n_missed,
  output logic        reach_err
);
  logic [31:0] r_q, c_q;
  logic        truly_missed;
  // An answer cannot hit more points than the question had.
  assign hit_ok        = (points_hit > points_wanted) ? points_wanted : points_hit;
  assign missed_points = points_wanted - hit_ok;
  assign r_q = (points_wanted == 16'd0) ? 32'd100
             : (({16'd0, hit_ok} * 32'd100) / {16'd0, points_wanted});
  assign reach_pct = (r_q > 32'd100) ? 16'd100 : r_q[15:0];
  assign c_q = (points_wanted == 16'd0) ? 32'd0
             : (({16'd0, facts_recited} * 32'd100) / {16'd0, points_wanted});
  assign recited_pct = (c_q > 32'd100) ? 16'd100 : c_q[15:0];
  assign truly_missed = (points_wanted != 16'd0) && (missed_points != 16'd0)
                        && (listener_tier != 16'd0);
  // Counting recited facts instead of answered points always looks complete.
  assign question_answered = (NAMING_IS_ANSWERING != 0)
                             ? (facts_recited != 16'd0) : (missed_points == 16'd0);
  assign reach_err = score_it && truly_missed && question_answered;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_scores <= 8'd0; n_missed <= 8'd0;
    end else if (score_it) begin
      n_scores <= n_scores + 8'd1;
      if (truly_missed) n_missed <= n_missed + 8'd1;
    end
  end
endmodule

Four points wanted, two hit, six facts recited is half the question answered and more facts said than the question had points. The naming-is-answering view scores any recital as an answer, because from inside the answer the recital is the evidence.

The last case is the sharpest version. Nothing hit and eight facts recited — twice as many facts as the question had points, and none of them addressing it — is zero percent of the question answered and is the most fluent wrong answer available. It is also, in practice, a common one: a well-prepared candidate who has memorised material and has not asked what the question wanted.

The degenerate case matters for a different reason. A question with no points in it is answered by anything, and the naming view reports failure because nothing was recited. That inversion is the model's way of saying that the two builds are not ranked — the recital view is not simply worse, it is measuring something else, and the something else occasionally wins.

The fix this section argues for is one habit: name the points before preparing the answer. Four points for what is CXL is a decision that takes a minute and makes every subsequent choice — what to cut in section 5, what to lead with in section 13 — mechanical instead of intuitive.

Worth defending the specific four, since the list is the specification and a wrong list makes everything downstream wrong in a way nothing later catches. What it is — three protocols over one PCIe link. What it does that PCIe cannot — each side addressing the other's memory rather than transferring across it. What it is for — memory that is currently stranded in one host, made addressable by another. What shapes it are — the device types, which follow from which protocols are present. A candidate who hits those four has answered the question at tier one regardless of what else they did or did not say.

The reason to write this list down rather than hold it is that under pressure the recital is what surfaces. Prepared material is retrieved by association and answers are retrieved by decomposition, and only one of those two survives an interview room. A written list converts the retrieval from the first kind to the second, which is most of what preparation for this question actually buys.

7. RTL 3 — The Tier Is Part Of The Question

What is CXL asked of a new graduate and asked of a principal engineer are different questions with the same words. The tier is carried entirely by context — who is asking, what the role is, what came before — and answering at the wrong one is a failure in both directions.

Under-pitching is noticed by everybody, including the speaker. Over-pitching is noticed by nobody except the interviewer, because depth feels like competence from the inside. A beginner question answered with flit formats and bias-flip protocols demonstrates knowledge and does not answer the question, and the candidate leaves feeling it went well.

// RTL 3 - the tier the question was asked at. An answer pitched three tiers
// above the question is not a better answer; it fails in a different direction
// from one pitched below, and only one of the two is usually noticed.
module tier_match #(parameter int DEEPER_IS_BETTER = 0) (
  input  logic clk, rst_n,
  input  logic        score_it,
  input  logic [15:0] asked_tier, answer_tier, max_tier, points_wanted,
  output logic [15:0] tier_used, over_by, under_by, match_pct,
  output logic        level_matched,
  output logic [7:0]  n_scores, n_mismatched,
  output logic        depth_err
);
  logic [15:0] gap;
  logic [31:0] m_q;
  logic        truly_over;
  // An answer cannot be pitched above the deepest tier the scale has.
  assign tier_used = (answer_tier > max_tier) ? max_tier : answer_tier;
  assign over_by   = (tier_used > asked_tier) ? (tier_used - asked_tier) : 16'd0;
  assign under_by  = (asked_tier > tier_used) ? (asked_tier - tier_used) : 16'd0;
  assign gap       = over_by + under_by;
  assign m_q = (max_tier == 16'd0) ? 32'd100
             : (32'd100 - (({16'd0, gap} * 32'd100) / {16'd0, max_tier}));
  assign match_pct = (m_q > 32'd100) ? 16'd0 : m_q[15:0];
  assign truly_over = (over_by != 16'd0) && (points_wanted != 16'd0);
  // Treating depth as quality makes an over-pitched answer look like a win.
  assign level_matched = (DEEPER_IS_BETTER != 0) ? (under_by == 16'd0)
                                                 : (gap == 16'd0);
  assign depth_err = score_it && truly_over && level_matched;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_scores <= 8'd0; n_mismatched <= 8'd0;
    end else if (score_it) begin
      n_scores <= n_scores + 8'd1;
      if (gap != 16'd0) n_mismatched <= n_mismatched + 8'd1;
    end
  end
endmodule

A tier-one question answered at tier four is three tiers of gap and a forty percent match. The deeper-is-better view scores it as matched, because it only penalises answering below the question.

The third case is the one that keeps this honest. A senior question answered at tier one is caught by both views — under-pitching is the failure everybody agrees on, and it is therefore not the failure that needs a model. The asymmetry is the whole section: one direction is self-correcting and the other is self-reinforcing.

The mechanism behind the asymmetry is worth stating because it explains why experience alone does not fix it. An under-pitched answer produces an immediate correction — the interviewer asks a harder follow-up, the candidate notices, and the calibration improves. An over-pitched answer produces a follow-up that is also deep, because the interviewer is now working from the level the candidate established, and the candidate's evidence for having pitched correctly is that the conversation continued at that level. The feedback loop runs in the wrong direction: the error confirms itself, and the only external signal is an outcome weeks later with no attribution attached.

The clamp has a real meaning here. An answer pitched past the top of the scale — every detail, all of it, at maximum depth — is clamped to the deepest tier that exists, and the gap is counted from there. A model that let the tier run away would report an infinitely bad match and stop being usable; a candidate who does this reports an excellent interview.

The practical read is one question asked before answering: who is asking, and what tier is this? For what is CXL the answer is almost always tier one, and the correct response is almost always shorter and less impressive than the one that comes to mind.

8. RTL 4 — What The One-Liner Leaves Out

Now the phrase itself, because it is the most common answer to this question and it deserves a precise account rather than a dismissal.

"CXL is coherent memory over PCIe" is true. It is a good label, it is memorable, and it is the right thing to say in the first five seconds. It is also, taken alone, a sentence that names none of CXL.io, CXL.cache or CXL.mem, does not say which side caches what, and does not distinguish a memory expander from a coherent accelerator.

// RTL 4 - what the one-liner leaves out. "Coherent memory over PCIe" is a true
// sentence that names none of the three protocols and does not say what the
// memory semantic actually is.
module oneliner_reach #(parameter int THE_ONELINER_IS_ENOUGH = 0) (
  input  logic clk, rst_n,
  input  logic        score_it,
  input  logic [15:0] io_named, cache_named, mem_named, pcie_mentioned,
  output logic [15:0] protocols_named, protocols_missed, reach_pct, phrase_len,
  output logic        semantic_named,
  output logic [7:0]  n_scores, n_incomplete,
  output logic        oneliner_err
);
  logic [31:0] r_q;
  logic        truly_incomplete;
  assign protocols_named = ((io_named    != 16'd0) ? 16'd1 : 16'd0)
                         + ((cache_named != 16'd0) ? 16'd1 : 16'd0)
                         + ((mem_named   != 16'd0) ? 16'd1 : 16'd0);
  assign protocols_missed = 16'd3 - protocols_named;
  assign r_q = ({16'd0, protocols_named} * 32'd100) / 32'd3;
  assign reach_pct = (r_q > 32'd100) ? 16'd100 : r_q[15:0];
  // How much of the answer the phrase carries on its own.
  assign phrase_len = (pcie_mentioned != 16'd0) ? 16'd1 : 16'd0;
  assign truly_incomplete = (protocols_missed != 16'd0);
  // The one-liner build signs off as soon as PCIe has been mentioned.
  assign semantic_named = (THE_ONELINER_IS_ENOUGH != 0)
                          ? (pcie_mentioned != 16'd0)
                          : (protocols_named == 16'd3);
  assign oneliner_err = score_it && truly_incomplete && semantic_named;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_scores <= 8'd0; n_incomplete <= 8'd0;
    end else if (score_it) begin
      n_scores <= n_scores + 8'd1;
      if (truly_incomplete) n_incomplete <= n_incomplete + 8'd1;
    end
  end
endmodule

The phrase said with no protocol named is zero of three and zero percent of the definition reached, and the one-liner view signs off the moment PCIe is mentioned.

Figure 2 — the phrase and the definition, side by side. The upper path is not false and it is not useless: for a listener who knows PCIe it orients them in four seconds and makes everything after it easier to follow. What it does not do is name what CXL is made of. The lower path costs about twenty seconds and is the thing the question asked for, which is why the good answer contains both in that order.

The fifth case is the argument against overcorrecting. All three protocols named without ever mentioning PCIe is a complete definition in the measured build and a failure in the one-liner view. Both are defensible readings: the phrase is a genuinely useful orientation for a listener who knows PCIe, and dropping it to save four seconds makes the answer harder to follow. The phrase is a convenience, not the definition, and the mistake is treating it as either worthless or sufficient.

The two-of-three case is the one most real answers land in. Naming io and cache and forgetting mem — or the reverse — is a third of the definition missing, and which third is missing usually reveals what the candidate has actually worked on. An interviewer notices that immediately.

The number to carry: the three protocols are the answer to this question. Everything else — device types, use cases, the PCIe relationship — is elaboration on those three, and an answer that does not reach them has not started.

One refinement on the ordering of the three. CXL.mem is the one to explain most carefully, because it is the one that is genuinely unfamiliar and the one most deployments use. CXL.io is PCIe and can be dealt with in a clause. CXL.cache is the device caching host memory, which listeners map onto an existing mental model of caches without much difficulty. CXL.mem inverts the usual relationship — the host addressing memory that lives on a card, in its own physical address space, cacheably — and that inversion is the part a listener has no prior structure for. An answer that gives all three equal time has spent two thirds of it on the two that were easy.

9. RTL 5 — An Analogy Carries Truth For A Fixed Number Of Steps

Analogies are the highest-leverage tool available in a ninety-second answer and the one with the sharpest failure mode.

"CXL is like giving the device its own key to the host's memory" carries real structure for two or three steps and then starts implying things that are false — that the access is unmediated, that there is no coherency protocol, that the host cannot revoke it. The listener has no way to know which step they are on, and the speaker, who chose the analogy for the steps that work, is the least likely person to notice the ones that do not.

// RTL 5 - an analogy carries truths for a fixed number of steps and implies
// falsehoods after that. The step where it turns is not marked, and the
// listener does not know it has been passed.
module analogy_span #(parameter int AN_ANALOGY_IS_FREE = 0) (
  input  logic clk, rst_n,
  input  logic        use_it,
  input  logic [15:0] span_steps, steps_taken, truths_per_step, falsehoods_per_step,
  output logic [15:0] steps_ok, truths_carried, falsehoods_implied, net_value,
  output logic        analogy_safe,
  output logic [7:0]  n_uses, n_overrun,
  output logic        analogy_err
);
  logic [15:0] overrun_steps, true_false;
  logic [31:0] t_q, f_q;
  logic        truly_overrun;
  // An analogy carries truth only as far as it holds.
  assign steps_ok      = (steps_taken > span_steps) ? span_steps : steps_taken;
  assign overrun_steps = steps_taken - steps_ok;
  assign t_q = {16'd0, steps_ok} * {16'd0, truths_per_step};
  assign truths_carried = (t_q > 32'hFFFF) ? 16'hFFFF : t_q[15:0];
  assign f_q = {16'd0, overrun_steps} * {16'd0, falsehoods_per_step};
  assign true_false = (f_q > 32'hFFFF) ? 16'hFFFF : f_q[15:0];
  assign falsehoods_implied = (AN_ANALOGY_IS_FREE != 0) ? 16'd0 : true_false;
  assign net_value = (truths_carried > falsehoods_implied)
                     ? (truths_carried - falsehoods_implied) : 16'd0;
  assign analogy_safe = (falsehoods_implied == 16'd0);
  assign truly_overrun = (true_false != 16'd0);
  assign analogy_err = use_it && truly_overrun && analogy_safe;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_uses <= 8'd0; n_overrun <= 8'd0;
    end else if (use_it) begin
      n_uses <= n_uses + 8'd1;
      if (truly_overrun) n_overrun <= n_overrun + 8'd1;
    end
  end
endmodule

An analogy good for two steps, taken five, carries six truths and implies twelve falsehoods: a net value of zero. The analogy-is-free view banks the six truths and reports nothing on the other side of the ledger.

The sixth case is the analogy worth searching for. An analogy whose extra steps imply nothing false — one that simply stops helping rather than starting to mislead — is safe past its span, carries its six truths, and costs nothing when pushed. Those exist, they are rarer than the alternative, and finding one is worth more preparation time than polishing the sentences around it.

For CXL specifically there is one analogy with an unusually long span and it is worth knowing. CXL.mem is to PCIe roughly what a memory slot is to a disk controller — both put storage in the machine, and only one of them puts it in the address space. That comparison holds through the load-store semantics, through cacheability, through the reason latency matters, and through why a driver is not involved. It starts to mislead only when pushed to failure semantics, where a memory slot has none and a link does, and that is four or five steps in rather than two.

The analogy to avoid, because it is the one that comes to mind first, is anything involving a network. "It's like networked memory" carries one step and then implies packets, retries, addresses that are not physical addresses, and an absence of coherency — four falsehoods for one truth, which is section 5's worst case almost exactly.

The degenerate case is the worst analogy available and it is not uncommon. An analogy that does not hold for even one step carries no truth and implies sixteen falsehoods, and it is usually reached for under pressure — an unprepared comparison to something the speaker knows better than CXL. The free view reports zero truths as a clean result, which is exactly how it feels: nothing was said wrongly, because nothing specific was said at all.

The discipline this argues for is to know the span before using the analogy, and to say it: "that comparison holds as far as the device caching a line, and stops being useful past that". One clause, and it converts an unbounded liability into a bounded one.

10. RTL 6 — A Term The Listener Does Not Have Is Not An Explanation

Jargon density is measured against the listener. The speaker has every term, by definition, and therefore has no internal signal at all for this one.

"CXL.mem exposes HDM as host-managed device memory with coherency maintained through the host's home agent" is a correct sentence. For a listener who has HDM, home agent and host-managed it is dense and useful. For a listener who has none of them it is four seconds of noise, and it is indistinguishable from the useful version at the moment it is spoken.

// RTL 6 - a term the listener does not have is not an explanation. Jargon
// density is measured against the listener, not against the speaker, and the
// speaker has no way to feel the difference.
module jargon_grounding #(parameter int THEY_KNOW_THE_TERMS = 0) (
  input  logic clk, rst_n,
  input  logic        score_it,
  input  logic [15:0] terms_used, terms_known, terms_defined, minutes,
  output logic [15:0] grounded, ungrounded, grounded_pct, terms_per_min,
  output logic        jargon_ok,
  output logic [7:0]  n_scores, n_ungrounded,
  output logic        jargon_err
);
  logic [15:0] reachable, true_ungrounded;
  logic [31:0] g_q, d_q;
  logic        truly_ungrounded;
  // A term is grounded if the listener already had it or the answer defined it.
  assign reachable = terms_known + terms_defined;
  assign grounded  = (reachable > terms_used) ? terms_used : reachable;
  assign true_ungrounded = terms_used - grounded;
  assign ungrounded = (THEY_KNOW_THE_TERMS != 0) ? 16'd0 : true_ungrounded;
  assign g_q = (terms_used == 16'd0) ? 32'd100
             : (({16'd0, grounded} * 32'd100) / {16'd0, terms_used});
  assign grounded_pct = (g_q > 32'd100) ? 16'd100 : g_q[15:0];
  assign d_q = (minutes == 16'd0) ? 32'd0
             : ({16'd0, terms_used} / {16'd0, minutes});
  assign terms_per_min = (d_q > 32'hFFFF) ? 16'hFFFF : d_q[15:0];
  assign jargon_ok = (ungrounded == 16'd0);
  assign truly_ungrounded = (true_ungrounded != 16'd0);
  assign jargon_err = score_it && truly_ungrounded && jargon_ok;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_scores <= 8'd0; n_ungrounded <= 8'd0;
    end else if (score_it) begin
      n_scores <= n_scores + 8'd1;
      if (truly_ungrounded) n_ungrounded <= n_ungrounded + 8'd1;
    end
  end
endmodule

Ten terms used, three the listener had and two defined on the way past, is five terms grounded and five that explained nothing — half the vocabulary, at five terms a minute.

The model counts defined in passing as grounding, and that is the cheapest fix available. "CXL.mem — that is the host reading device memory as memory" costs three seconds and converts a term from noise into a handle the rest of the answer can use. Two such clauses in ninety seconds is a large fraction of the achievable improvement in any answer at this tier.

The last case is the limit. Eight terms, none known and none defined is a fully opaque answer at two terms a minute — not fast, not obviously wrong, and completely empty for this listener. The optimistic view calls it fine, which it does because the optimistic view is the speaker's own experience of having said true things.

The degenerate case is worth a line because it inverts the intuition: an answer with no terms in it grounds nothing wrongly. Density is not the problem this section owns — five terms a minute is fine when all five are shared, and two a minute is a disaster when neither is. The ratio is the measurement; the rate is not.

There is a failure adjacent to this one that the model does not cover and that is worth naming, because it can be mistaken for grounding. A term defined wrongly is worse than a term left undefined. "HDM — that's the device's own DRAM" is a definition, it grounds the term in the model's accounting, and it is subtly wrong in a way that will produce a confusing follow-up. The model counts definitions rather than correct definitions because counting correctness would require modelling content, which section 4 rules out — but the gap is real and the discipline that closes it is to define in passing only the terms you could define properly if pressed.

The corollary is that the two terms chosen for definition should be the two you know best, not the two that are hardest. The point of a passing definition is to give the listener a handle, not to demonstrate the depth of the term.

11. RTL 7 — The Follow-Up Is The Real Question

A ninety-second answer is almost never the thing being evaluated. It is a bid for the next question, and the next question is where anything interesting gets established.

This reframes what a good answer does. An answer that closes every thread — complete, tidy, nothing left hanging — has spent ninety seconds and bought nothing. An answer that mentions device types without expanding them, or names CXL.cache and leaves the coherency mechanism for later, has left the interviewer somewhere specific to go, and the somewhere is ground the candidate chose.

It is worth being precise about what this does not recommend, because the technique is easy to misapply into evasiveness. Leaving a thread open is not withholding an answer. It is finishing a point at the level the question was asked and not pre-emptively expanding it three levels further. "There are three device types, and which one an accelerator is depends on whether it has memory of its own" is a complete answer at tier one that has obviously more behind it. "There are three device types — Type 1 is io plus cache, Type 2 adds mem, Type 3 is io plus mem, and a Type 2 device's memory can be host-biased or device-biased depending on..." is the same point delivered until nobody needs to ask about it.

The first version answers and invites. The second answers and closes, and it also fails section 5 and probably section 7 on the way past. The three failures are the same behaviour seen from three angles, which is why over-answering is the single most common thing that goes wrong at this tier.

// RTL 7 - the follow-up is the real question. A ninety-second answer is a bid
// for the next ninety seconds, and an answer that closes every thread has spent
// its time buying nothing.
module followup_threads #(parameter int A_COMPLETE_ANSWER_IS_BEST = 0) (
  input  logic clk, rst_n,
  input  logic        score_it,
  input  logic [15:0] threads_open, threads_shut, strong_topics, minutes_left,
  output logic [15:0] kept_threads, wasted_threads, threads_left, kept_pct,
  output logic        invites_followup,
  output logic [7:0]  n_scores, n_closed,
  output logic        followup_err
);
  logic [31:0] k_q;
  logic        truly_wasted;
  // Threads left open, and threads closed, on topics worth being asked about.
  assign kept_threads   = (threads_open > strong_topics) ? strong_topics : threads_open;
  assign wasted_threads = (threads_shut > strong_topics) ? strong_topics : threads_shut;
  assign threads_left = (A_COMPLETE_ANSWER_IS_BEST != 0) ? 16'd0 : kept_threads;
  assign k_q = (strong_topics == 16'd0) ? 32'd0
             : (({16'd0, kept_threads} * 32'd100) / {16'd0, strong_topics});
  assign kept_pct = (k_q > 32'd100) ? 16'd100 : k_q[15:0];
  assign invites_followup = (threads_left != 16'd0);
  assign truly_wasted = (kept_threads != 16'd0) && (minutes_left != 16'd0);
  // There were threads worth leaving open and the answer closed all of them.
  assign followup_err = score_it && truly_wasted && (threads_left == 16'd0);

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_scores <= 8'd0; n_closed <= 8'd0;
    end else if (score_it) begin
      n_scores <= n_scores + 8'd1;
      if (!invites_followup) n_closed <= n_closed + 8'd1;
    end
  end
endmodule

Three threads left open on four strong topics is three quarters of the strong ground still available to be asked about, with one thread closed that need not have been. The complete-answer view leaves none.

The fourth case draws the boundary this model does not cross. Every strong thread closed and none left open is a wasted opportunity, and the model reports nothing — because this section owns threads that were kept, not threads that were closed. Closing a thread on ground you are weak on is correct. The failure is narrower than "do not be complete": it is leaving nothing open on ground you wanted to be asked about.

The degenerate case is the honest limit. With no topic worth being asked about, there is no opportunity to waste — a candidate with no strong ground gains nothing from leaving threads open, and would do better to close them. The model declines to report, which is the right behaviour and a useful reminder that this technique presupposes something to defend.

The practical form is a single decision made during preparation: which two topics do I want the next question to be about? Then mention them and do not finish them.

12. RTL 8 — A Claim And A Supported Claim Score Differently

Every sentence in a ninety-second answer is either a claim or a supported claim, and at speaking speed they feel identical.

"CXL reduces memory cost" is a claim. "CXL reduces memory cost because a pooled tier can be shared across hosts instead of stranded in one" is a supported claim. The first is faster, sounds equally confident, and evaporates under a follow-up. The second costs four seconds and survives.

// RTL 8 - a claim and a supported claim score differently, and only one of
// them survives a follow-up. The difference is invisible while you are the one
// speaking.
module claim_support #(parameter int A_CLAIM_IS_A_FACT = 0) (
  input  logic clk, rst_n,
  input  logic        score_it,
  input  logic [15:0] claims_made, claims_backed, probe_depth, points_wanted,
  output logic [15:0] supported, bare_claims, support_pct, survives,
  output logic        claims_stand,
  output logic [7:0]  n_scores, n_bare,
  output logic        support_err
);
  logic [15:0] true_bare;
  logic [31:0] s_q;
  logic        truly_bare;
  // A claim cannot be backed more than once.
  assign supported  = (claims_backed > claims_made) ? claims_made : claims_backed;
  assign true_bare  = claims_made - supported;
  assign bare_claims = (A_CLAIM_IS_A_FACT != 0) ? 16'd0 : true_bare;
  assign s_q = (claims_made == 16'd0) ? 32'd100
             : (({16'd0, supported} * 32'd100) / {16'd0, claims_made});
  assign support_pct = (s_q > 32'd100) ? 16'd100 : s_q[15:0];
  // A probe reaches as far as it reaches; bare claims below it survive.
  assign survives = (probe_depth > true_bare) ? 16'd0 : (true_bare - probe_depth);
  assign claims_stand = (bare_claims == 16'd0);
  assign truly_bare = (true_bare != 16'd0) && (points_wanted != 16'd0);
  assign support_err = score_it && truly_bare && claims_stand;

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_scores <= 8'd0; n_bare <= 8'd0;
    end else if (score_it) begin
      n_scores <= n_scores + 8'd1;
      if (truly_bare) n_bare <= n_bare + 8'd1;
    end
  end
endmodule

Six claims made with two backed is four standing on nothing — a third of the answer supported — and the claim-is-a-fact view counts none of them as bare, because from the inside a claim you believe and a claim you justified feel the same.

The survives output is the one to sit with. A probe reaches a certain depth — an interviewer asks about some of the claims, not all — and bare claims below that depth survive by luck. Four bare claims against a three-deep probe leaves one unexamined. That is not a defence; it is a description of how this failure sometimes goes unpunished and therefore never gets corrected.

The sixth case removes the luck. A probe deeper than the stack of bare claims finds all four, and the optimistic view walks into every one. That is what a thorough interviewer does, and it is why the ratio rather than the count is the thing to manage.

The cheapest form of support is a because clause, and it is worth practising as a reflex rather than a decision. "CXL.mem lets the host address device memory as memory, because the device exposes it into the host's physical address space rather than sitting behind a driver" is one sentence carrying a claim and its support. The claim alone is four words shorter and one follow-up away from trouble.

There is also a reason to prefer support over additional claims that has nothing to do with surviving a probe. A supported claim demonstrates the reasoning; a bare one only demonstrates recall. An interviewer at any tier is trying to distinguish those two, and an answer made of six bare claims gives them no evidence either way — which they will resolve by probing, which returns to the paragraph above.

The degenerate case says something useful about brevity: an answer that claimed nothing has nothing to defend. That is not an argument for saying nothing — section 6 already priced that — but it does mean that a shorter answer with three supported claims outscores a longer one with six claims and two backings, on every measurement in this chapter simultaneously.

13. RTL 9 — Which Point Leads

Sections 5 through 12 are about what an answer contains. This one is about the order, which matters for exactly one reason: the clock cuts from the end.

If nine points are prepared and six land, the ordering decides which six. The strongest point told first is heard; told last it is a point that was never made. This is entirely within the speaker's control, costs nothing, and is decided by default — chronologically, or in the order the material was learned — unless somebody decides otherwise.

// RTL 9 - which point leads. The clock cuts the answer at a fixed number of
// points, so the ordering decides which points land, and the highest-value
// point saved for the end is a point that was never made.
module lead_ordering #(parameter int TELL_IT_IN_ORDER = 0) (
  input  logic clk, rst_n,
  input  logic        plan_it,
  input  logic [15:0] points_total, points_that_fit, value_high, value_low,
  output logic [15:0] landed, value_landed, value_best, value_lost,
  output logic        lead_is_best,
  output logic [7:0]  n_plans, n_buried,
  output logic        lead_blind_err
);
  logic [15:0] value_used;
  logic [31:0] l_q, b_q;
  logic        truly_buried;
  // Only the points that fit are ever heard.
  assign landed = (points_that_fit > points_total) ? points_total : points_that_fit;
  // Best-first lands the high-value points; chronological lands whatever came first.
  assign value_used   = (TELL_IT_IN_ORDER != 0) ? value_low : value_high;
  assign l_q = {16'd0, landed} * {16'd0, value_used};
  assign value_landed = (l_q > 32'hFFFF) ? 16'hFFFF : l_q[15:0];
  assign b_q = {16'd0, landed} * {16'd0, value_high};
  assign value_best = (b_q > 32'hFFFF) ? 16'hFFFF : b_q[15:0];
  assign value_lost = value_best - value_landed;
  assign lead_is_best = (value_landed >= value_best);
  assign truly_buried = (value_high > value_low) && (landed != 16'd0)
                        && (points_total > landed);
  assign lead_blind_err = plan_it && truly_buried && (value_used == value_low);

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_plans <= 8'd0; n_buried <= 8'd0;
    end else if (plan_it) begin
      n_plans <= n_plans + 8'd1;
      if (truly_buried) n_buried <= n_buried + 8'd1;
    end
  end
endmodule

Nine points with six landing, at five units of value for the best and one for the rest, is thirty of value delivered leading with the best and six delivering them in order — twenty-four lost.

The second case is why this failure hides so well. When everything is heard the ordering does not matter — a practice run with no time pressure, or a genuinely short answer, produces identical results either way. The ordering only matters when the clock cuts, which is precisely the situation nobody practises.

The fourth case is the honest limit. When every point is worth the same there is no lead to get wrong, and both orderings deliver identically. That is worth checking before spending preparation time on ordering: if the points really are equal, order them for flow instead.

The last case shows the scaling and it is the wrong direction again. The longer the answer, the more the lead decides — a long prepared answer with a strong lead delivers nearly everything and the same answer told chronologically delivers almost none of its value. Preparation that adds material without reordering it makes this worse, not better.

There is a tension with section 8 worth resolving explicitly, because the two sections appear to disagree. Section 8 says the three protocols are the answer and must be reached. This section says lead with the highest-value point. Those are the same instruction: for this question the three protocols are the highest-value point, and they belong in the first thirty seconds rather than being built up to. The temptation to lead with context — what problem CXL solves, what came before it, why PCIe was not enough — is a temptation to spend the heard portion of the answer on the preamble and to reach the content just as the clock cuts.

The general rule underneath it is that an answer should be readable from its first third alone. If the first thirty seconds were the whole answer, would it be a correct if incomplete one? For the protocols-first ordering, yes. For the context-first ordering, it is thirty seconds about PCIe.

14. RTL 10 — A Ninety-Second Answer Assembled

Nine models, nine independent claims about an answer. This one puts them in one place and makes the weak claim visible as what it is: one bit of six.

"CXL is coherent memory over PCIe" is what the speaker hears themselves say, and it is not wrong — it is one of six conditions, and the only one of the six available from inside the answer.

// RTL 10 - a ninety-second answer assembled. Everything that must hold before
// an answer has done its job, with "CXL is coherent memory over PCIe" as one
// of the six rather than the whole claim.
module answer_signoff #(parameter int THE_ONELINER_IS_THE_ANSWER = 0) (
  input  logic clk, rst_n,
  input  logic       evaluate,
  input  logic       phrase_said,       // the one-line definition was given
  input  logic       in_budget,         // it fitted the ninety seconds
  input  logic       question_answered, // it hit the points the question wanted
  input  logic       level_matched,     // it was pitched at the tier asked
  input  logic       terms_grounded,    // every term used was one they had
  input  logic       claims_supported,  // nothing was asserted without backing
  output logic       answer_sound,
  output logic [5:0] fail_mask,
  output logic [7:0] n_eval, n_sound,
  output logic       false_answer_err
);
  assign fail_mask[0] = ~phrase_said;
  assign fail_mask[1] = ~in_budget;
  assign fail_mask[2] = ~question_answered;
  assign fail_mask[3] = ~level_matched;
  assign fail_mask[4] = ~terms_grounded;
  assign fail_mask[5] = ~claims_supported;
  // The one-liner build is what the speaker hears themselves say.
  assign answer_sound = (THE_ONELINER_IS_THE_ANSWER != 0)
                        ? phrase_said : (fail_mask == 6'd0);
  assign false_answer_err = evaluate && answer_sound && (fail_mask != 6'd0);

  always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
      n_eval <= 8'd0; n_sound <= 8'd0;
    end else if (evaluate) begin
      n_eval <= n_eval + 8'd1;
      if (answer_sound) n_sound <= n_sound + 8'd1;
    end
  end
endmodule

The stimulus walks all six bits one at a time. When the phrase was said and any one of the other five fails, the assembled model reports that the answer did not do its job and the speaker's build reports an answer. Only when the phrase was never said do the two agree.

Across the eight evaluations the stimulus drives, the assembled model calls one answer sound and the speaker's build calls six of them answers. The five it gets wrong are the five single-bit failures with the phrase bit set, and each one is an interview somebody left feeling it had gone well.

The bit order is by how available the check is to the person answering. Bit 0 is audible to the speaker. Bit 1 needs a clock. Bit 2 needs the question to have been decomposed beforehand. Bits 3 and 4 need a model of the listener, which is the hardest of the six and the reason section 7 and section 10 are the two that survive into senior interviews. Bit 5 is checkable in preparation and almost never checked.

Figure 4 — the mask as a preparation checklist rather than a post-mortem. Only the first decision is answerable while speaking; the rest have to be settled beforehand, which is why this is a chapter about preparation and not about performance.

15. Quantitative Reasoning

Numbers from the models, stated so they can be argued with rather than admired.

Nine points at fifteen seconds is a hundred and thirty-five seconds. Against a ninety-second budget that is a hundred and fifty percent, and three of the nine points were delivered to somebody who had stopped listening. There is no signal at second ninety-one.

Six facts recited against a four-point question can be fifty percent answered. More facts than the question had points, and half the question untouched. The two numbers are uncorrelated and only one of them is audible from inside.

Three tiers of over-pitch is a forty percent match. The same gap under-pitched is also forty percent and is noticed by everyone; over-pitched it is noticed by the interviewer alone.

Zero of three protocols named, and the phrase said. That is the most common answer to this question and it reaches zero percent of the definition.

Two steps of analogy taken five is six truths and twelve falsehoods. Net zero. The three extra steps did not add nothing — they subtracted twice what the first two added.

Five terms grounded of ten is half the vocabulary landing. At two terms a minute with nothing shared, it is none of it — the ratio is the measurement and the rate is not.

Three threads of four left open is seventy-five percent of the strong ground still reachable. The complete answer leaves zero and spends the same ninety seconds.

Two of six claims backed is thirty-three percent supported. Against a three-deep probe, one bare claim survives by luck; against a deeper one, none do.

Six points of nine landing at five versus one is thirty against six. The same material, the same time, a factor of five in what was delivered, decided entirely by which point went first.

One of eight answers sound; the speaker's build hears six. The assembled model's summary number, and the chapter's.

16. Assertions

The testbenches carry 523 checks across ten models.

Every output of every model is asserted as a value, in both builds. The output listing step reported twenty-five on the first run, and triaging them surfaced one real defect rather than one missing assertion: the time-budget model's percentage was clamped at a hundred, which made the say-it-all build report exactly the same number as the measured one in every scenario. A hundred and thirty-five seconds of a ninety-second budget is a hundred and fifty percent, and the clamp was deleting the section's headline figure. Raising the ceiling made the two builds differ and made the output assertable. A clamp copied from a neighbouring model is a clamp that was not chosen, and this one had been.

Both builds are asserted on every degenerate case. A question with no points, a scale with no tiers, an answer with no terms, an analogy nobody used, a claim nobody made, a budget of zero, points with no duration, a listener who was not asking.

Every clamp is driven past its limit exactly once. More points hit than the question had, an answer pitched past the top of the scale, more backing than claims, more threads than topics, more vocabulary than terms used, an analogy span exceeded by a factor of a thousand.

Every error output is checked in both directions in every case. Section 8's fifth case and section 11's fourth case exist purely to assert the quiet half — all three protocols named without the phrase, and every strong thread closed with none kept. In both, the measured build must stay silent.

17. Mutation Testing

99 mutations, 99 killed. Fifty against the first testbench, forty-nine against the second.

One mutation survived the first run, and it was the fourth instance in this batch of the same phenomenon: inverting the jargon-grounding counter changed nothing, because six scores split three-and-three. By this point the pattern had a rule attached to it — see 26.7 section 17 — and the rule turned out to be checkable without running anything. A counter inversion is undistinguishable exactly when the interesting cases number half the total, and both of those numbers are already asserted in the testbench, so the check reads them out of the source and compares.

Running that check across the whole batch found three more counters that would have survived an inversion and had not been caught, because during authoring the mutation had been quietly downgraded to a double-step instead. A double-step kills, so the campaign reported a clean score; the inversion — which is the more realistic bug, since it is what a wrong polarity produces — remained untestable. All four were repaired the same way: one more stimulus case to unbalance the split, then the real mutation.

A mutation that was weakened to make it pass is a testbench gap wearing a passing score. That is the batch's most useful finding and it came out of a single survivor.

The sequence is worth recording because it is the same shape as the batch's other tooling wins. A survivor appeared. Rather than adjusting the mutation to make it die, the survivor was treated as a claim about the testbench — which it was. The claim generalised into a rule stated in prose. The rule turned out to be checkable from the source without simulation, so it became a script. The script was run across work already believed to be finished and found three more instances. Every step of that is cheap except the first, and the first is only cheap if a survivor is treated as information rather than as an obstacle.

The same path produced the output-listing step two batches ago and the mutual-exclusivity check one batch ago. Three tools, three survivors, and in each case the survivor was pointing at a class rather than an instance.

The zero-guard family is now the largest it has been at thirteen. Every one of those guards exists because an input can legitimately be zero — a question with no points, a scale with no tiers, a budget of nothing — and each flipped guard produces a model that reports a confident percentage from an answer that contained nothing at all.

18. Verification Strategy

Preparation, expressed as a test plan, because that is what preparation is.

Time the answer once, out loud, against a clock. Not silently and not from a script. The number of points that fit is the only input section 5 needs and it cannot be estimated from reading.

Write down the points the question wants before writing the answer. Four for what is CXL. The list is the specification and everything else is implementation.

Decide the tier explicitly. Who asks this question, and at what level? For this one it is almost always tier one, and the correct answer is shorter than instinct suggests.

Name all three protocols in the first thirty seconds. This is the one content requirement the chapter makes, and an answer that has not reached it has not started.

Know each analogy's span and say it. One clause, and the liability becomes bounded.

Count the terms and ask which the listener has. Then pick two to define in passing, at three seconds each.

Choose two threads to leave open. Ground you want the next question to be on.

Back every claim or cut it. A shorter answer with supported claims outscores a longer one with bare ones on every measurement here at once.

Order the points by value, not chronology. The clock cuts from the end, and this is free.

19. Synthesis and Implementation Reality

What it costs to actually do this, since a plan nobody executes is worse than no plan.

The ninety-second answer is written once and reused. What is CXL is asked in essentially every CXL interview. An hour spent on it returns across every interview that follows, which is the highest-leverage hour in the whole of module 27.

Six points is the working size. Section 5's arithmetic at fifteen seconds a point, and fifteen seconds is roughly what a sentence-plus-elaboration takes. Fewer if the points are complex.

Two defined terms is the realistic budget. Six seconds of a ninety-second answer. More than that and the definitions crowd out the points.

One analogy, span known. Two is almost always one too many at this tier.

The three protocols are non-negotiable and cost about twenty seconds with a clause of explanation each. That is a fifth of the budget for the thing the question is actually about, which is the right proportion.

The remaining seventy seconds go roughly: ten on the one-liner and the PCIe relationship, twenty on why anybody built it, twenty on device types, and twenty held in reserve. The reserve is not slack — it is the margin that absorbs an interruption, a clarifying question, or the realisation halfway through that the tier is different from the one assumed. An answer prepared to fill exactly ninety seconds has no room to be adjusted while it is being given, and adjusting while giving is the skill this whole chapter is a substitute for until it develops.

Tier detection is the part that does not compress. It is judgement, it improves with exposure, and nothing in this chapter replaces it. What the chapter does is make the consequence of getting it wrong visible, which is the part that is usually missing.

The one structural aid that helps is preparing the answer at two tiers rather than one. A tier-one version of roughly six points and a tier-three version of roughly the same length but different points, with the three protocols in both. Choosing between two prepared answers is a decision that can be made in the two seconds after the question lands; constructing the right one on the fly cannot. This doubles the preparation cost of the highest-leverage answer in the module, which is still a good trade.

20. Silicon Observability

The analogue of observability here is what you can actually tell, during and after, about how the answer landed.

Free, and available immediately. Whether you finished before being interrupted. Interruption is a strong signal about section 5, and it is the only one of the six that reports itself in real time.

Cheap, if you ask. The follow-up question. What it is about tells you which thread was picked up, which is section 11's output, and whether it was one you chose.

Moderate. The interviewer's expression at the moment a term is used. This is section 10's only live signal and it is weak, late and easy to misread — but it is the only one there is.

Expensive. A recorded practice answer played back. It gives the timing, the point count, the term count and the claim-to-support ratio in one pass. Nearly everybody who does this once is surprised by at least two of the four.

Unobtainable. What the interviewer actually wanted from the question. Every model in this chapter takes the points-wanted as an input, and in a real interview it is a guess. The whole of section 6 is about narrowing that guess before the question is asked, because it cannot be narrowed afterwards.

One live signal deserves more credit than it usually gets: an interviewer who interrupts to ask a clarifying question has told you the tier and the points in one move. The instinct is to treat the interruption as a failure of the answer. It is usually a correction being offered for free, and the right response is to take it literally — answer the narrower question that was just asked, rather than resuming the prepared material with the clarification appended.

21. Debug Lab

A practice run, in the order that finds the most in the least time.

Step 1 — answer the question out loud against a clock, once, unrehearsed. Record it. Everything below reads off that recording.

Step 2 — count the seconds. Section 5. If it exceeded ninety, count how many points were past the line, and cut exactly those.

Step 3 — list the points the question wanted, then mark which you hit. Section 6. Do this from the recording, not from memory, and the gap is usually larger than expected.

Step 4 — check the three protocols were named. Section 8. This is a yes-or-no question and it is the content check the chapter exists for.

Step 5 — count the terms used and mark which the listener would have had. Section 10. Pick two to define in passing.

Step 6 — mark every claim and whether it was backed. Section 12. The ratio is the number to improve.

Step 7 — identify the analogy and its span. Section 9. Then decide whether to keep it and add the boundary clause.

Step 8 — name two threads worth leaving open, and check whether the answer left them. Section 11.

Step 9 — reorder the surviving points by value. Section 13. Free, last, and worth a factor of five.

The order is by how much it cuts. Steps 2 and 3 usually remove a third of the material, which makes every later step cheaper.

22. Design Review

Questions worth asking of a prepared answer before it meets an interviewer.

How long is it, out loud, timed? Not estimated.

What are the points the question wants, written down? If this list does not exist, section 6 is unmanaged.

Are all three protocols named, and in the first thirty seconds?

What tier is this pitched at, and what tier will be asked?

Which terms does it use, and which would a listener at that tier already have?

Which analogy does it use, and where does it stop being true?

Which two threads does it deliberately leave open?

What is the ratio of claims to supported claims?

If it is cut at sixty seconds instead of ninety, what survives — and is that the strongest third?

23. How This Appears In Real Engineering

The interview goes well. The candidate knows CXL, says true things fluently for two and a half minutes, and leaves confident. The feedback says "did not answer the question".

That feedback is almost never given in those words to the candidate, and it is what section 6 measures. The candidate recited; the interviewer wanted four points; two landed. Nobody in the room experienced it as a failure while it was happening, and the candidate has no way to reconstruct it afterwards because the recording does not exist.

The second shape is the over-pitched answer. A graduate role, a tier-one question, and an answer about bias-flip and flit formats. The candidate demonstrated depth and failed to demonstrate judgement, and judgement was what the question was for. This one is particularly hard to learn from because the failure looks, from inside, exactly like the success.

The third is the unbacked claim that meets a follow-up. Six claims, two backed, and the interviewer picks one of the four. The answer that comes back is a restatement rather than a justification, and a single exchange converts a good impression into a specific doubt. The four seconds of support that would have prevented it were available and were spent on a seventh claim instead.

There is a fourth shape that is less common and more damaging, and it belongs to section 9. An analogy is offered, the interviewer picks it up and extends it one step past its span, and the candidate — who chose the analogy and is invested in it — follows rather than stopping. The conversation then proceeds for a minute inside a model that is not true of CXL, with both parties reasoning carefully from a false premise. Recovering from that costs more than the original question was worth, and the recovery itself looks like backtracking.

The clause that prevents it is spoken before the analogy, not after it, and it costs about three seconds: "that comparison holds as far as the device caching a line, and stops being useful past that". Said afterwards it is a retraction. Said beforehand it is a boundary, and the interviewer will respect it because it demonstrates exactly the judgement the analogy was risking.

The pattern under all three is the same and it is the reason this chapter is modelled rather than listed: every one of these failures is invisible to the person making it, in real time, by construction. The speaker has the terms, believes the claims, feels the depth and cannot hear the clock. Six numbers, checked in preparation, are the only instrument available.

24. Common Misconceptions

"CXL is coherent memory over PCIe." True, and one of six bits. It names none of the three protocols. Section 8.

"I had two minutes and I used them well." How many points fit, and how many did you prepare? Section 5.

"I said a lot of correct things." How many of them were points the question wanted? Section 6.

"I gave a thorough answer." To a tier-one question, thoroughness is the failure. Section 7.

"The analogy really helped." For how many steps? Section 9.

"They're an engineer, they know the terms." Which terms, and had they got them? Section 10.

"I answered it completely." Then you bought no second question. Section 11.

"Everything I said was true." Supported is a different property from true. Section 12.

"I saved the best point for the end." The clock cuts from the end. Section 13.

25. Interview Reasoning

"What is CXL?" Three protocols over one PCIe link: CXL.io for discovery and management, CXL.cache for the device to cache host memory coherently, CXL.mem for the host to address device memory as memory. The two directions are what PCIe cannot do. Then device types if there is time. That is the answer; the rest of this chapter is about delivering it.

"How is CXL different from PCIe?" CXL.io is PCIe. The difference is the other two protocols, which extend the memory model across the link instead of moving data across it. A strong answer says the physical layer is shared and the semantics are not.

"Why would anyone want this?" Memory stranded in one host is memory bought and unused. CXL.mem lets a tier of memory be addressed by a host that did not buy it, and pooled across hosts that need it at different times. That is a supported claim; "CXL reduces memory cost" is a bare one.

"What are the device types?" Type 1 is io plus cache — an accelerator with no memory wanting coherent access to the host's. Type 2 adds mem — an accelerator with its own memory, coherent both ways. Type 3 is io plus mem — a memory expander. Type 3 is most of what ships.

"Give me the one-line version." "Coherent memory over PCIe" — and then, unprompted, the clause that makes it mean something: "three protocols, one link, and each side can address the other's memory". The one-liner is a good opening and a poor ending.

26. Exercises

1. Write the four points what is CXL wants. Now time your current answer and count how many of the four it hits.

2. You have 60 seconds and 12 seconds a point. How many points fit? Which of your four points do you cut, and what does that do to section 13's ordering?

3. Take an analogy you use for CXL. Write down the step at which it stops being true. Now write the one-clause boundary statement.

4. Count the technical terms in your current answer. Mark each as one a tier-one listener would have. What is the grounded percentage, and which two would you define in passing?

5. Mark every claim in your answer and whether it is backed. Compute the ratio. Cut the answer to five claims, all supported, and compare the length.

6. Which two threads do you want the next question to be about? Does your answer leave them open, and does it close anything you would rather have been asked?

7. Order your points by value. If the answer is cut at two thirds, does the strongest point survive? What does chronological ordering cost you?

8. Extend the assembled model with a seventh bit for a condition this chapter does not cover. Justify its position using the rule that the ordering is by how available the check is to the person answering.

27. Summary

Ninety seconds is a budget, and the budget decides which points exist. Nine prepared points at fifteen seconds is a hundred and fifty percent of it.

Reciting facts is not answering a question. Six correct statements can be half an answer, and fluency is what the speaker hears.

The tier is part of the question. Over-pitching is noticed by the interviewer alone, which is why it never self-corrects.

"Coherent memory over PCIe" names none of the three protocols. CXL.io, CXL.cache and CXL.mem are the answer.

An analogy carries truth for a fixed number of steps. Two steps taken five is six truths and twelve falsehoods.

A term the listener does not have is not an explanation. The ratio is the measurement; the rate is not.

The follow-up is the real question, and a complete answer buys none.

A claim and a supported claim feel identical at speaking speed and score differently the moment one is probed.

The clock cuts from the end, so the strongest point goes first — a factor of five, for free.

Six bits, and the one-liner is one of them. One answer of eight is sound; the speaker hears six.

27.2 takes the first of the three protocols and asks the question this chapter's answer is designed to invite.