어시스턴트를 바꾸기 전에 먼저 측정하라

읽는 데 약 40분분 걸린다, 11절에 11개 예제이(가) 있음.

2026.11.3판 예제 통과 2026년 11월 21 54개 예제 중 54개 통과 변경 사항

AI로 번역함. 영어 원문을 사람이 검증함. 우리가 책을 만드는 방식

영어판 2026.11.3판을 번역한 것이다. 원문 읽기

이 장을 마치면 고정된 질문 집합으로 문서 안내 어시스턴트를 측정하고, 그 결과를 구간과 함께 읽으며, 질문 스무 개로는 두 프롬프트의 차이를 가려내기에 부족한 경우가 언제인지 말할 수 있다.

이 책의 어시스턴트는 sablefile에 관한 질문에 답한다. sablefile은 프로젝트의 생성 파일을 그 원본 템플릿과 일치하도록 유지해 주는 명령줄 도구다. 사용자는 명령을 어떻게 실행하는지, 설정이 무슨 역할을 하는지를 묻고, 어시스턴트는 이 도구의 문서를 근거로 답하면서 각 진술의 바탕이 되는 절을 인용한다. 팀의 누군가가 다른 프롬프트를 원한다고 해 보자. 그 사람은 질문 세 개로 새 프롬프트를 시험해 보고, 답이 더 나아 보이니 배포한다. 질문 세 개로는 이 변경이 도움이 되었는지 알 수 없다. 변경 이전에 어시스턴트가 어떠했는지도 아무도 말하지 못한다. 기록해 둔 것이 없기 때문이다.

그래서 가장 먼저 만들 것은 측정이다. 측정은 마땅히 나와야 할 답과 짝지은 질문 집합, 매번 같은 방식으로 어시스턴트를 돌리는 방법, 그리고 불확실성의 크기(구간)를 함께 제시하는 수치로 이루어진다. 변경은 그다음이다. 이 장은 측정을 가장 단순한 형태로 만들고, 그 형태가 어디에서 한계에 이르는지를 보여 주며 끝난다.

도구와 문서

평가는 측정 대상이 안정적인 만큼만 안정적이다. sablefile 문서는 1.0, 1.1, 2.0의 세 가지 버전으로 나뉘며, 일부 내용이 서로 어긋난다. 한 버전에서 맞는 답이 다른 버전에서는 틀릴 수 있으므로, 질문의 다른 어떤 것을 확정하기에 앞서 모든 질문은 먼저 자신의 버전을 밝혀야 한다.

문서부터 살펴보자. 세 버전을 불러오고, 각 버전의 절 수와 세 버전이 모두 공유하는 절 ID의 수를 센다.

list-the-docs.py Python 3.12.15 · numpy 2.5.5 통과
"""Loads the three doc versions and prints each one's section count, and how many section IDs all three share.The shared IDs are the sections whose concept keeps one ID across versions (plan section 2.2)."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.docs import load_sections, versionssections = load_sections()  # every version, sorted by version and section IDall_versions = versions()  # the version labels present, sortedfor version in all_versions:    print(f"sections in version {version}: {sum(1 for s in sections if s.version == version)}")ids = {version: {s.section_id for s in sections if s.version == version} for version in all_versions}shared = set.intersection(*ids.values())  # IDs present in every versionprint(f"section IDs in all {len(all_versions)} versions: {len(shared)}")print(f"section IDs in 2.0 but in neither 1.0 nor 1.1: {len(ids['2.0'] - ids['1.0'] - ids['1.1'])}")
출력python list-the-docs.py
sections in version 1.0: 35
sections in version 1.1: 36
sections in version 2.0: 40
section IDs in all 3 versions: 35
section IDs in 2.0 but in neither 1.0 nor 1.1: 4

출력은 절 수로 시작한다. 1.0은 35개, 1.1은 36개, 2.0은 40개이다.

대부분의 절은 버전이 바뀌어도 ID를 유지한다. 세 버전 모두에 나타나는 ID가 35개이기 때문이다. 마지막 줄은 이후의 논의에서 가장 중요하다. 2.0에만 존재하는 ID가 4개이므로, 이전 버전의 페이지로 답하는 어시스턴트는 이 ID들에 대해 인용할 근거가 없다.

버전마다 도구의 동작도 다르며, 여기서 문제가 되는 차이는 생성된 파일을 쓰는 명령인 sync에 있다. 1.1 문서는 플래그 없이 sync을 실행하면 파일을 쓰고 각 파일을 프로젝트 루트의 잠금 파일인 sablefile.lock에 기록한다고 설명한다. 2.0 문서는 플래그 없이 sync를 실행하면 계획만 출력하고 아무것도 쓰지 않으며, --apply를 지정해야 파일을 쓰고, 잠금 파일은 .sablefile/lock.json에 있다고 설명한다. sync에 대한 질문은 1.1에서의 정답과 2.0에서의 정답이 서로 다르다. 엉뚱한 버전의 페이지를 읽은 어시스턴트는 확신에 찬 어조로 틀린 답을 내놓는다.

이 책은 답을 측정한다. 검색 순위, 추적, 비용, 지연 시간, 공격, 에이전트의 과제 집합은 다른 책에서 다루며, 해당 주제가 나오는 곳에서 해당 책을 밝힌다.

작업 규칙: 모든 질문에 버전을 명시하고, 그 버전 자체의 문서만을 답의 유일한 출처로 삼는다. 두 버전이 같은 표현을 쓰면서 서로 다른 답을 줄 때는 버전별로 항목을 하나씩, 즉 두 개의 항목으로 만든다. 최신 버전의 페이지가 이전 버전을 대신하게 해서는 안 된다.

스무 개의 항목

테스트 세트는 질문의 목록이며, 각 질문에는 그 질문이 받아야 할 답이 붙어 있다. 스무 개는 일부러 적게 잡은 수다. 항목을 하나씩 읽고, 기대 답을 문서와 대조해 확인하고, 그 항목이 왜 있는지 설명할 수 있다. 아무도 읽지 않는 세트는 자신이 무엇을 측정하는지 알려 주지 못한다.

항목은 네 종류로 나뉜다. 답변 가능 항목은 문서에 답이 적혀 있다. 답변 불가 항목은 문서가 다루지 않는 내용을 묻는 항목이며, 올바른 응답은 답변을 거절하는 것이다. 버전 의존 항목은 버전에 따라 답이 달라지며, 이 가운데 여럿에는 쌍둥이가 있다. 같은 질문을 다른 버전에 대해 던진 항목이다. 모호 항목은 두 가지로 해석될 수 있으며, 기준 답은 두 해석을 모두 다룬다.

각 항목은 ID 순으로 출력되며, 버전, 종류, 쌍둥이, 심어 둔 항목인지 여부가 함께 표시된다.

twenty-questions.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Prints the twenty chapter items in id order: version, kind, planted flag and question, then the counts by kind.The counts are the set's make-up that the chapter describes (plan section 3.4)."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom collections import Counterfrom lib.answers import chapter_itemsitems = chapter_items()  # sorted by idfor item in items:    twin = item.twin_of if item.twin_of else "none"    planted = f"planted ({item.planted_why})" if item.planted else "not planted"    print(f"{item.id} | version {item.version} | {item.kind} | {planted} | twin {twin} | {item.question}")kinds = Counter(item.kind for item in items)for kind in ("answerable", "unanswerable", "version-dependent", "ambiguous"):    print(f"items of kind {kind}: {kinds[kind]}")print(f"planted items: {sum(1 for item in items if item.planted)}")print(f"items in the dev split: {sum(1 for item in items if item.split == 'dev')}")
출력python twenty-questions.py
q-0001 | version 1.1 | version-dependent | not planted | twin q-0002 | In sablefile 1.1, if I run sync with no flags, are the target files written straight away?
q-0002 | version 2.0 | version-dependent | not planted | twin q-0001 | In sablefile 2.0, if I run sync with no flags, are the target files written?
q-0003 | version 1.0 | version-dependent | planted (version-swap) | twin q-0004 | In sablefile 1.0, is ${project} the right way to insert the project name into a template?
q-0004 | version 2.0 | version-dependent | not planted | twin q-0003 | In sablefile 2.0, is ${project} the right way to insert the project name into a template?
q-0005 | version 2.0 | answerable | planted (near-miss-term) | twin none | Does sablefile 2.0 still read sablefile.lock in my project root?
q-0006 | version 2.0 | answerable | not planted | twin none | Is there a way to make check exit with status 0 even when a file has drifted in 2.0?
q-0007 | version 1.1 | answerable | not planted | twin none | In 1.1, will an ignore entry of docs/**/*.tmp catch a file two folders down, like docs/x/y/a.tmp?
q-0008 | version 2.0 | answerable | not planted | twin none | In 2.0, is there a way to re-include something that an earlier ignore line had excluded?
q-0009 | version 1.0 | answerable | not planted | twin none | What does one line of the 1.0 lock file hold?
q-0010 | version 2.0 | answerable | not planted | twin none | Will syncing the same content twice in 2.0 produce a different lock file each time?
q-0011 | version 1.1 | answerable | not planted | twin none | How many times does 1.1 retry a remote template fetch that keeps failing, and can a flag change that?
q-0012 | version 2.0 | answerable | not planted | twin none | I want sync to retry a slow remote template only twice in 2.0. What do I pass?
q-0013 | version 1.0 | answerable | not planted | twin none | In 1.0, which table in sablefile.toml holds the values a placeholder can name?
q-0014 | version 1.1 | answerable | not planted | twin none | What does sablefile init put into a new sablefile.toml in 1.1?
q-0015 | version 1.0 | unanswerable | planted (false-premise) | twin none | In sablefile 1.0, what does the --dry-run flag on sync print?
q-0016 | version 2.0 | unanswerable | not planted | twin none | Does sablefile 2.0 run on Windows?
q-0017 | version 2.0 | unanswerable | not planted | twin none | How fast is sablefile check on a project with several thousand generated files?
q-0018 | version 1.1 | unanswerable | not planted | twin none | Can sablefile 1.1 fetch a remote template from a private URL that needs a login token?
q-0019 | version 2.0 | ambiguous | planted (ambiguous-target) | twin none | If I edit the file and then run check, will it fail?
q-0020 | version 2.0 | ambiguous | not planted | twin none | Does sync change the lock file?
items of kind answerable: 10
items of kind unanswerable: 4
items of kind version-dependent: 4
items of kind ambiguous: 2
planted items: 4
items in the dev split: 20

마지막 줄들은 세트의 종류별 구성을 보여 주며, 답변 가능 항목이 가장 큰 집단이다. 심어 둔 항목은 4개다. 심어 둔 항목은 특정한 실수 하나를 잡아내려고 작성한 것으로, 세트에 그렇게 표시되어 있으므로 그 항목에서의 실패를 함정에 비추어 읽을 수 있다.

함정은 각각 단순하다. q-0003은 1.0에서 ${project}가 올바른 자리 표시자인지 묻는데, 1.0의 문법은 {{project}}이다. 그 쌍둥이인 q-0004은 2.0에 대해 같은 것을 묻는데, 2.0에서는 ${project}가 맞다. q-0005은 2.0이 프로젝트 루트에서 여전히 sablefile.lock을 읽는지 묻는다. 이 질문은 1.x의 파일 이름을 쓰고 있는데, 2.0에서 그 이름은 마이그레이션에만 의미가 있다. q-0015은 1.0에서 --dry-run 플래그가 하는 일을 묻지만, 1.0 문서에는 그런 플래그가 나오지 않는다. q-0019는 어느 파일인지 밝히지 않은 채, 파일을 편집한 뒤 검사에서 실패하는지 묻기 때문에 해석이 두 가지다.

작업 규칙: 어시스턴트를 실행하기 전에 각 항목을 버전, 종류, 기대 답과 함께 작성하고, 특정한 실수를 잡으려고 쓴 항목에는 그렇다고 표시한다. 세트는 한 번에 다 읽을 수 있을 만큼 작게 유지하고, 어시스턴트가 내놓은 답에 맞추려고 기대 답을 바꾸는 일은 하지 않는다.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Retrieve, then answer

The assistant doesn't read all the docs for every question. For each question it takes the three sections most likely to hold the answer, from the index of the version the question names, and answers from those three alone. A wrong answer can therefore come from two places: the right section was never retrieved, or the model misread the section it was given. A measurement that can't tell these apart can't say what to fix.

The index is built with BM25, which scores each section by the words it shares with the question. The scoring runs through bm25s at 0.3.16. Take one question: whether an ignore entry such as docs/**/*.tmp catches a file two folders down in 1.1. Its output shows the words the index keeps from the question, and the top three sections, ordered by score and then by section ID.

retrieve-top-sections.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Shows BM25 retrieval for one question (q-0007, version 1.1): the words kept, then the top three sections.The sections come from the version's own index, ranked by score and then by section ID, so a tie has one order.The tokeniser drops one-letter words, so the `3` of `3.5mm` is lost and only `5mm` is matched."""import lib  # first: fixes the thread counts and seeds before anything else loadsimport bm25sfrom lib.docs import load_sectionsfrom lib.retrieval import Retrieverfrom lib.testset import load_itemsitem = next(item for item in load_items() if item.id == "q-0007")print(f"question {item.id} (version {item.version}): {item.question}")# The words the index actually matches on: the same tokeniser, stopwords and token pattern as lib.retrieval.kept = bm25s.tokenize([item.question], stopwords="en", return_ids=False, show_progress=False)[0]print(f"words kept for matching: {' '.join(kept)}")dropped = bm25s.tokenize(["a 3.5mm jack"], stopwords="en", return_ids=False, show_progress=False)[0]print(f"words kept from the text 'a 3.5mm jack': {' '.join(dropped)}")hits = Retriever(load_sections(item.version)).retrieve(item.question, 3)  # top 3 of the version's indexfor rank, hit in enumerate(hits, start=1):    print(f"rank {rank}: {hit.section_id} | score {hit.score:.3f}")
출력python retrieve-top-sections.py
question q-0007 (version 1.1): In 1.1, will an ignore entry of docs/**/*.tmp catch a file two folders down, like docs/x/y/a.tmp?
words kept for matching: ignore entry docs tmp catch file two folders down like docs tmp
words kept from the text 'a 3.5mm jack': 5mm jack
rank 1: ignore-recursive | score 9.156
rank 2: sync-create-dirs | score 3.386
rank 3: ignore-syntax | score 3.348

Read the two lines of kept words before the ranking. The tokeniser drops every token of one character. The a in the question goes, and so do both 1s of 1.1, so the version number never reaches the index. That does no harm here, because each question is searched only in the index of its own version. The same rule takes the 3 out of 3.5mm: what is left of a 3.5mm jack is 5mm jack, so a question about a 3.5 mm jack can match only on 5mm. Neither loss raises an error, and the second one changes what the index can find.

The ranking puts ignore-recursive first, the section on recursive ignore entries, and the next two are the section on creating folders and the one on ignore syntax. Ties are broken by section ID, so the same question gives the same three sections on every run.

Working rule: Check retrieval before you check the answer. For each item, record the sections the assistant was given next to its reply. A wrong reply that lacks the right section is a retrieval problem, and a wrong reply that had the right section is a problem with the prompt or the model. Keep the wording of questions plain, because a tokeniser that drops one-character tokens will lose a measurement or a version number.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Replay the answers

A model's reply to the same question can change with its runtime, its settings and the hardware it runs on. If every measurement calls the model again, each one measures something slightly different, and a change in the number might be noise. So the book records each reply once, from a pinned open model, and replays the recording. A replay returns the same text every time.

The recording is a folder of replies, one per item. It was made with a 4-bit build of Qwen3-4B-Instruct-2507, an open model pinned to one file and one revision, run at temperature zero on a CPU. It holds a reply for every item in the full set, and this chapter reads twenty of them by ID. Replay one of them: the reply to q-0006, which asks whether check can exit with status 0 when a file has drifted in 2.0.

replay-one-answer.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Replays the recorded baseline reply to q-0006 and parses it: the sections it was given, the reply, its citations.Nothing is generated here: the reply is the recorded text, read back as the same string."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.contract import format_problemsfrom lib.prompts import P1_SHA256, P1_SYSTEMassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)  # the prompt hash must match the manifestitem = next(item for item in chapter_items() if item.id == "q-0006")print(f"question {item.id} (version {item.version}, {item.kind}): {item.question}")for rank, section in enumerate(assistant.sections(item), start=1):  # the top 3, in rank order    print(f"section in context, rank {rank}: {section.section_id}")reply = assistant.reply(item)print("recorded reply:")print(reply.text)print(f"citations, in order: {' '.join(reply.citations)}")print(f"format problems: {', '.join(format_problems(reply, context_ids=assistant.context_ids(item), expect_decline=False)) or 'none'}")# A reply to an answerable item must answer and cite; this is the one fact the prose relies on here.assert reply.citations and not reply.declined, "q-0006 should be answered, with at least one citation"
출력python replay-one-answer.py
question q-0006 (version 2.0, answerable): Is there a way to make check exit with status 0 even when a file has drifted in 2.0?
section in context, rank 1: check-exit-status
section in context, rank 2: no-fail-flag
section in context, rank 3: quickstart-check
recorded reply:
Yes, there is a way to make `check` exit with status 0 even when a file has drifted in 2.0. Use the `--no-fail` flag with `sablefile check`. This flag ensures that the check exits with status 0 even when files have drifted, without changing which files are reported. [sec:no-fail-flag]
citations, in order: no-fail-flag
format problems: none

The output lists the three sections the assistant was given, in rank order, and then prints the reply exactly as it was recorded. The reply says yes, and it cites no-fail-flag, which was among the three. Check the citation against that list. The reply cites a section it was given, so it didn't reach outside its context. An assert also requires the reply to be an answer with at least one citation, since a decline on this answerable item would be an error.

To put a live model in place of the recording, pass live=True to Assistant. That loads the pinned Qwen3-0.6B on the CPU and answers each question as it's asked. It is a smaller model than the 4B build the recording was made with, so its live replies, and any rate built on them, will differ from the recorded ones. This book quotes no live replies. Its numbers come from the recording, so you can check each one against a file.

Working rule: Replay for every comparison. Record again only when the model, the prompt or the sections the assistant sees have changed, and note in the recording what changed. Each recording names its prompt by hash, and the example checks that hash against the recording's manifest, so one recording can't stand in for a different prompt.

두 가지 코드 검사

어떤 오류는 심사자가 필요하지 않다. 프롬프트에 없던 절을 인용한 경우나, 답변을 거절하면서 동시에 답을 내놓은 경우는 응답의 텍스트를 읽는 것만으로 찾아낼 수 있다. 코드로 하는 검사는 실행 비용이 들지 않고 매번 같은 결과를 내므로, 이 책은 어떤 모델에게 응답을 심사하게 하기 전에 두 검사를 모두 먼저 실행한다.

인용

어시스턴트는 모든 진술에 인용 형식, 곧 대괄호 안의 절 ID로 출처를 밝혀야 하며, 주어진 ID만 인용해야 한다. 인용은 두 가지 방식으로 틀릴 수 있다. ID가 아예 존재하지 않을 수도 있고, 다른 버전에 존재할 수도 있다. 후자는 버전 바꿔치기 항목이 일부러 유도하도록 작성된 실수다. 검사는 프롬프트에 없던 절을 가리키는 인용을 어떤 방식으로 틀렸든 unknown-section로 판정한다. 인용이 하나도 없는 답변도 함께 표시한다.

인용 검사와 형식 검사는 기준선 응답 스무 개 전체에 대해 실행되며, 출력에는 실패 유형별 횟수가 집계된다.

check-citations.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Runs the citation and format checks on the baseline replies to the twenty chapter items, and counts each problem.A citation is a problem when its section was not in the item's prompt, which covers a section of another version."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.contract import PROBLEMS, format_problems, parse_reply, section_ids_by_versionfrom lib.prompts import P1_SHA256, P1_SYSTEMfrom lib.stats import pctassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)items = chapter_items()counts = {name: 0 for name in PROBLEMS}  # items with each problem, by its fixed nameitems_with_problems = 0answered = 0answered_uncited = 0citations = 0citations_outside = 0  # cited IDs that were not in the item's promptfor item in items:    reply = assistant.reply(item)    problems = format_problems(reply, context_ids=assistant.context_ids(item), expect_decline=item.kind == "unanswerable")    items_with_problems += bool(problems)    for name in problems:        counts[name] += 1    if not reply.declined and reply.text:        answered += 1        answered_uncited += not reply.citations    citations += len(reply.citations)    citations_outside += sum(1 for cid in reply.citations if cid not in assistant.context_ids(item))assert citations_outside == 0, "every citation must point at a section that was in its item's prompt"# A zero rate shows nothing unless the check can fire: a 1.1 section cited for a 2.0 item must be flagged as unknown.planted_item = next(item for item in items if item.version == "2.0")planted = sorted(section_ids_by_version()["1.1"] - assistant.context_ids(planted_item))[0]planted_problems = format_problems(parse_reply(f"Yes. [sec:{planted}]"), context_ids=assistant.context_ids(planted_item), expect_decline=False)assert "unknown-section" in planted_problems, "the check must fire on a planted bad citation"print(f"items: {len(items)}")print(f"items with a format problem: {pct(items_with_problems, len(items))}")for name in sorted(counts):  # sorted by problem name    print(f"items with problem {name}: {counts[name]}")print(f"answered items: {answered}")print(f"answered items with no citation: {pct(answered_uncited, answered)}")print(f"citations: {citations}")print(f"citations to a section not in the prompt: {pct(citations_outside, citations)}")
출력python check-citations.py
items: 20
items with a format problem: 0.0% (0 of 20)
items with problem answered-declined-expected: 0
items with problem declined-with-text: 0
items with problem empty: 0
items with problem no-citation: 0
items with problem unknown-section: 0
answered items: 15
answered items with no citation: 0.0% (0 of 15)
citations: 16
citations to a section not in the prompt: 0.0% (0 of 16)

기준선은 총 16개의 인용을 냈고, 그 하나하나가 주어진 절을 가리킨다. 출력은 이에 대한 비율도 보여 준다. 프롬프트 밖의 절을 가리키는 인용은 0.0% (0 of 16)이고, 인용 없이 답변한 항목은 0.0% (0 of 15)이다.

작업 규칙: 모든 응답에 인용 검사를 실행하고, 그 비율은 답변율과 따로 보고한다. 두 수치는 서로 다른 실수를 세기 때문이다. 비율이 0이라는 것은 검사가 문제를 찾아낼 수 있었을 때만 의미 있는 결과이므로, 프롬프트 밖을 인용하는 고정 응답을 하나 두고 그것에 검사를 실행하여 검사가 여전히 작동함을 확인한다.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Declines

When the docs don't answer a question, the assistant must reply with the decline phrase, "The docs don't say.", and nothing else. When the docs do answer, it must not use that sentence. These are two different errors, so each gets its own rate. A false refusal is an answerable item declined, and a false answer is an unanswerable item answered. Version-dependent and ambiguous items are left out of both rates. A version-dependent item has a rate of its own, version-correctness, which chapter 9 builds. An ambiguous item is judged by the pass rate alone, since a reply's text alone can't show which version or which reading was meant.

Both decline errors are counted over the baseline's replies.

check-declines.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Counts the two decline errors over the baseline replies: answerable items declined, and unanswerable items answered.Version-dependent and ambiguous items are left out of both rates: a version-dependent item is scored by its own rate,version-correctness, and an ambiguous item has no rate yet. The last lines name any excluded item the baseline declined."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.prompts import P1_SHA256, P1_SYSTEMfrom lib.stats import pctassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)items = chapter_items()answerable = [item for item in items if item.kind == "answerable"]unanswerable = [item for item in items if item.kind == "unanswerable"]false_refusals = [item.id for item in answerable if assistant.reply(item).declined]  # already in id orderfalse_answers = [item.id for item in unanswerable if not assistant.reply(item).declined]print(f"answerable items: {len(answerable)}")print(f"false refusal rate (answerable items declined): {pct(len(false_refusals), len(answerable))}")for item_id in false_refusals:    print(f"false refusal: {item_id}")print(f"unanswerable items: {len(unanswerable)}")print(f"false answer rate (unanswerable items answered): {pct(len(false_answers), len(unanswerable))}")for item_id in false_answers:    print(f"false answer: {item_id}")print(f"items not counted here (version-dependent and ambiguous): {len(items) - len(answerable) - len(unanswerable)}")excluded = [item for item in items if item.kind in ("version-dependent", "ambiguous")]declined_excluded = [item.id for item in excluded if assistant.reply(item).declined]  # the decline is not countedprint(f"declined, not counted here: {', '.join(declined_excluded) or 'none'}")
출력python check-declines.py
answerable items: 10
false refusal rate (answerable items declined): 0.0% (0 of 10)
unanswerable items: 4
false answer rate (unanswerable items answered): 0.0% (0 of 4)
items not counted here (version-dependent and ambiguous): 6
declined, not counted here: q-0004

Among the answerable and unanswerable items, the baseline makes neither error. The false refusal rate is 0.0% (0 of 10) of the 10 answerable items. The false answer rate is 0.0% (0 of 4) of the 4 unanswerable ones, so every unanswerable item got the decline, q-0015 among them.

The rates leave out 6 items, and the last line names the one of them that the baseline declined: q-0004. Item q-0004 asks whether ${project} is the right placeholder in 2.0, where it is. The baseline replied with the decline phrase, but the 2.0 docs answer it, in the placeholders section, so the decline is a wrong reply. The rate above doesn't count it as a false refusal, because that rate covers answerable items only. Version-correctness does count it as a miss.

Working rule: Keep the two decline rates apart, and leave version-dependent and ambiguous items out of both. A reply counts as a correct decline only when it is the decline phrase and nothing else, so a reply that gives the sentence and then an answer counts as the error it is. Read each false refusal by hand before you change the prompt, since one of them may point at a real gap in the docs. Read each decline on a version-dependent item too, since the rate doesn't count those.

하나의 심사자

인용과 거절은 응답의 형태를 확인한다. 응답이 옳은지는 확인하지 못하며, 팀이 정작 알고 싶은 것은 그 점이다. 이를 위해 이 책은 심사자(judge)를 쓴다. 심사자는 질문, 문서로 작성된 기준 답변, 어시스턴트의 응답을 읽고 PASS 또는 FAIL을 반환하는 모델이다. 여기서 심사자는 응답을 작성한 모델과 같은 Qwen3-4B-Instruct-2507이다. 심사자와 어시스턴트가 하나의 모델이면 같은 사각지대를 공유할 수 있고, 그러면 심사자는 어시스턴트가 같은 이유로 저지르는 오류를 놓친다. 이 책은 지금의 구성으로는 이를 검증할 수 없다. 대신 같은 모델을 보정 평가 기준(calibration rubric)에 따라 공개된 사람의 평가와 대조하고, 그 비율을 이 심사자에게 적용하려면 무엇을 가정해야 하는지를 6장에서 밝힌다.

심사자의 규칙은 짧으며 전문을 읽어 볼 만하다. 응답은 기준 답변이 말하는 바를 말할 때에만 옳다. 표현이 다른 것은 상관없고, 기준 답변과 모순되지 않는 추가 세부 정보도 괜찮다. 기준 답변이 뒷받침하지 않는 내용을 말하거나 기준 답변과 모순되는 응답은 FAIL이다. 기준 답변이 둘 이상으로 읽히면 응답은 그 모두에 답해야 하며, 일부만 답하면 FAIL이다. 기준 답변이 "none"이면 문서에 답이 없다는 뜻이고, 유일하게 옳은 응답은 거절이다. 답을 제시하면서 거절 문구까지 덧붙인 응답은 FAIL이다. 심사자는 첫 줄에 판정을 쓰고 그 뒤에 짧은 이유를 쓴다. 프롬프트는 한 문장을 요구하지만, 심사자가 항상 거기서 멈추는 것은 아니다.

아슬아슬한 오답이었던 q-0005에 대한 심사자의 판정은 다음과 같다. 이 질문에 대한 어시스턴트의 응답은 2.0이 sablefile.lock을 읽지 않는다고 말하고, 마이그레이션을 막연하게 가리킨다.

judge-one-answer.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Reads the reference-guided judge's verdict on the baseline reply to q-0005, a planted near-miss item, from its recording.The judge sees the question, the written reference and the reply; the first line of its reply is the verdict."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.contract import parse_verdictfrom lib.prompts import P1_SHA256, P1_SYSTEM, REF_SHA256from lib.replay import ReplayModelassistant = Assistant("assistant-baseline", P1_SYSTEM, P1_SHA256)item = next(item for item in chapter_items() if item.id == "q-0005")print(f"question {item.id} (version {item.version}, {item.kind}, planted: {item.planted_why}): {item.question}")print(f"reference answer: {item.reference_answer}")reply = assistant.reply(item)print(f"assistant reply: {reply.text}")judge = ReplayModel("judge-answers-baseline", REF_SHA256)  # the prompt hash must match the judge's manifestraw = judge.reply(item.id, 0)verdict = parse_verdict(raw)assert verdict is not None, "the judge's first line must be a verdict"print(f"judge verdict: {verdict}")reason = [line.strip() for line in raw.splitlines() if line.strip()][1:]  # the line after the verdictprint(f"judge reason: {reason[0] if reason else 'none'}")
출력python judge-one-answer.py
question q-0005 (version 2.0, answerable, planted: near-miss-term): Does sablefile 2.0 still read sablefile.lock in my project root?
reference answer: Only as a fallback. If the new file is missing and an old sablefile.lock is present, a 2.0 command reads the old file but warns you about it. Once the new file exists, 2.0 reads only that one, and sablefile never deletes the old file.
assistant reply: No, sablefile 2.0 does not read `sablefile.lock` in the project root. Version 2.0 moves the lock file to a new place. The first 2.0 command that reads an older lock file handles it as described in lock-migration. [sec:install-upgrade]
judge verdict: FAIL
judge reason: The response incorrectly states that sablefile 2.0 "does not read `sablefile.lock`" and that it "moves the lock file to a new place," which contradicts the reference answer that says sablefile 2.0 reads the old lock file as a fallback and only reads the new file once it exists. The reference explicitly states that it reads the old file as a fallback and warns users, not that it moves or stops reading it.

기준 답변은 다른 내용을 말한다. 2.0은 새 파일이 없을 때에만 예전 파일을 대체용으로 읽으며, 그렇게 할 때 경고를 낸다. 심사자의 판정은 FAIL이고, 그 이유는 응답이 기준 답변과 모순된다고 말한다. 문서의 2.0 마이그레이션 절은 기준 답변과 같은 내용을 말하므로, 이 항목에서는 심사자가 옳다. 그러나 옳은 판정 하나가 심사자의 신뢰성을 보여 주지는 않는다.

그래서 심사자를 사람과 대조해 확인해야 한다. 자신의 레이블과 일치하는 심사자가 그 사실만으로 보정된 것은 아니다. Shankar와 동료들의 Who Validates the Validators?(2024)는 참가자 아홉 명을 대상으로 한 연구이며, 사람들이 출력을 채점하는 동안 채점 기준을 다듬어 간다는 점을 발견했다. 더 많은 출력을 읽을수록 그들이 정착하는 기준이 바뀐다는 뜻이다. 한 번 작성한 평가 기준은 채점자들이 점차 뜻하게 되는 기준에서 벗어날 수 있다. 5장은 평가 기준을 문서로 적는 방법을 다루며, 이는 그 자체로 할 만한 가치가 있다. 문서로 작성된 평가 기준은 제2의 독자가 판정을 대조해 볼 수 있는 기준이고, 이후의 판정과 비교할 수 있는 기준이기 때문이다. 사람의 평가와 대조하는 검증은 6장에 있다.

작업 규칙: 모든 항목에 대해 심사자에게 문서로 작성된 기준 답변을 주고, 그 판정에 기반한 비율을 신뢰하기 전에 FAIL 판정을 PASS 판정만큼 꼼꼼히 읽는다. 자신의 레이블과 일치하는 것을 보정으로 치지 않는다. 심사자가 사람의 평가와 대조되어 확인되기 전까지는, 그 비율을 어시스턴트의 품질 척도가 아니라 심사자의 비율로 보고한다.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

A pass rate and its interval

마지막으로 변경된 판: 2026.11.3판

A pass rate is a count divided by a denominator, and the denominator decides what the rate means. The same rate on a much larger set is a different claim, and a set of twenty moves a lot when one item changes. Here the denominator is every item in the set, and a correct decline counts as a pass.

pass rate = passed items / items

An interval answers a different question from the pass rate: how far would the rate move if the set had been another twenty items drawn the same way? The method is a percentile bootstrap. The bootstrap itself is Efron's: his 1979 paper Bootstrap Methods: Another Look at the Jackknife, in the Annals of Statistics, set out resampling as a way to estimate how much a statistic varies. The percentile bootstrap is the simplest interval built on resampling, the middle 95% of the resampled rates. The procedure draws items from the set with replacement, without regard to kind, so one draw can hold any mix of kinds. It computes the pass rate of each draw, and repeats the draws many times. The interval shows how much twenty items could say.

Compute the rate and its interval for the baseline, then break the rate down by kind.

pass-rate-interval.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""The baseline's pass rate over the twenty chapter items, judged by the reference-guided judge, with its 95% interval.Every item is in the denominator, and a correct decline counts as a pass. The interval resamples items."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import chapter_itemsfrom lib.judging import passed, verdictsfrom lib.stats import bootstrap_mean, interval_pct, pctitems = chapter_items()found = verdicts("judge-answers-baseline", [item.id for item in items])  # keyed in sorted id orderscores = passed(found)  # 1.0 for PASS, 0.0 for FAIL, in the same orderprint(f"items: {len(items)}")print(f"pass rate: {pct(int(scores.sum()), len(items))}")lo, hi = bootstrap_mean(scores)  # level 0.95 for one comparison; seed SEED, 2,000 resamplesprint(f"95% interval of the pass rate: {interval_pct(lo, hi)}")kind_of = {item.id: item.kind for item in items}for kind in ("answerable", "unanswerable", "version-dependent", "ambiguous"):    ids = [item_id for item_id in found if kind_of[item_id] == kind]    passes = sum(1 for item_id in ids if found[item_id] == "PASS")    print(f"pass rate, {kind}: {pct(passes, len(ids))}")
출력python pass-rate-interval.py
items: 20
pass rate: 85.0% (17 of 20)
95% interval of the pass rate: [70.0%, 100.0%]
pass rate, answerable: 90.0% (9 of 10)
pass rate, unanswerable: 100.0% (4 of 4)
pass rate, version-dependent: 75.0% (3 of 4)
pass rate, ambiguous: 50.0% (1 of 2)

The baseline's pass rate is 85.0% (17 of 20). Its 95% interval is [70.0%, 100.0%]. The interval sits the same distance either side of the rate. Its upper end sits at the ceiling for any rate. It reaches the ceiling because more than 2.5% of the draws contain no failing item, so the top of the middle 95% is that ceiling. That means the interval can't rule out an assistant that never fails, which is what the single number hides.

Answerable items pass at 90.0% (9 of 10), unanswerable items at 100.0% (4 of 4), version-dependent items at 75.0% (3 of 4), and ambiguous items at 50.0% (1 of 2). The three failures fall in three different kinds. The one answerable failure is q-0005, read above. The one version-dependent failure is the decline on q-0004, read above. The one ambiguous failure is q-0019, which the judge fails under the baseline's reply, as the example in the next section shows.

Only the answerable kind has more than a few items: 10 of them. Each other kind holds 4 items or fewer, so their lines are notes about a few items, not results.

The interval covers only the spread that comes from drawing items. It says nothing about whether the twenty items represent the questions real users ask, and no interval can say that. Chapter 3 covers what a set must contain before a score on it means anything, and why this one is written from the docs rather than sampled from users.

Working rule: Report every pass rate with its denominator, its interval and its rate for each kind of item. Treat a kind with only a few items as a note, not a result, and say how many items it rests on.

이 부분은 아직 번역되지 않았으므로 영어로 표시된다.

Two prompts

마지막으로 변경된 판: 2026.11.3판

The team's proposed prompt is the change to measure. P1 is the baseline prompt. P2 keeps the same ground rules and changes the form of the reply: it asks the model to quote first the sentence its answer relies on, then give the answer, with the citation on each line. The question is whether the quote helps. Two pass rates over different items mostly measure the items, so the comparison has to pass the same items through both prompts. Each item then gets two verdicts, and the difference is taken item by item. That's a paired comparison.

Both prompts run over the same twenty items, and the output reports the difference with its interval.

compare-two-prompts.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Compares the baseline prompt (P1) with prompt-b (P2) on the twenty chapter items: each pass rate, the paired difference, its interval and n.The word 'better' is used only when the whole interval is above zero, and 'worse' only when it is below zero. A differencewhose interval includes zero is reported as no difference detected."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import chapter_itemsfrom lib.judging import pairedfrom lib.stats import interval_points, pctresult = paired("judge-answers-baseline", "judge-answers-prompt-b", [item.id for item in chapter_items()])first, second = result.first, result.second  # 1.0 or 0.0 per item, in id orderprint(f"P1 (baseline) pass rate: {pct(int(first.sum()), result.n)}")print(f"P2 (prompt-b) pass rate: {pct(int(second.sum()), result.n)}")print(f"items that P2 passes and P1 fails: {int(((second == 1) & (first == 0)).sum())}")print(f"items that P1 passes and P2 fails: {int(((second == 0) & (first == 1)).sum())}")print(f"paired items (n): {result.n}")print(f"difference, P2 minus P1: {100 * result.difference:+.1f} points")print(f"95% interval of the difference: {interval_points(result.diff_lo, result.diff_hi)}")if result.diff_lo > 0:    reading = f"P2 is better at n = {result.n}"elif result.diff_hi < 0:    reading = f"P2 is worse at n = {result.n}"else:    reading = f"no difference detected at n = {result.n}"print(f"reading: {reading}")# The two prompts tie: the same number of items pass under each, so the pass rates and the reading say the same thing.assert int(first.sum()) == int(second.sum()), "the two prompts must tie: the same pass count under each"
출력python compare-two-prompts.py
P1 (baseline) pass rate: 85.0% (17 of 20)
P2 (prompt-b) pass rate: 85.0% (17 of 20)
items that P2 passes and P1 fails: 1
items that P1 passes and P2 fails: 1
paired items (n): 20
difference, P2 minus P1: +0.0 points
95% interval of the difference: [-15.0, +15.0] points
reading: no difference detected at n = 20

On this set the two prompts tie. P1 passes 85.0% (17 of 20) of the items, and P2 passes 85.0% (17 of 20).

The paired view shows what sits under the tie. P2 passes 1 item that P1 fails, and P1 passes 1 item that P2 fails. These are the judge's verdicts, not facts about the prompts. The first is q-0019, and the judge's PASS on it breaks the judge's own rule 3. The difference, P2 minus P1, is +0.0 points, and its interval is [-15.0, +15.0] points. The interval includes zero, so at this size the example reports no difference detected.

Here the judge's verdicts on q-0019 are read under both prompts, and the rule the PASS breaks is printed beside them.

judge-gets-one-wrong.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Shows one judge verdict that breaks the judge's own rule: on q-0019, the judge passes P2's reply, which answers only one of thetwo readings in the reference. The rule it breaks is rule 3 of the judge's prompt, printed below from that prompt.The hand verdict is a person's reading, written into this file. It is printed beside the judge's verdict and is the onlynumber here that is not a recorded one; the count of passes with it is taken from the judge's own verdicts."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import Assistant, chapter_itemsfrom lib.judging import verdictsfrom lib.prompts import P1_SHA256, P1_SYSTEM, P2_SHA256, P2_SYSTEM, REF_SYSTEMfrom lib.replay import ReplayModelITEM_ID = "q-0019"HAND = {"q-0019": "FAIL"}  # read by hand against rule 3: the reply answers reading 1 and not reading 2item = next(item for item in chapter_items() if item.id == ITEM_ID)print(f"question {item.id} (version {item.version}, {item.kind}, planted: {item.planted_why}): {item.question}")print(f"reference answer: {item.reference_answer}")print(f"P2 reply: {Assistant('assistant-prompt-b', P2_SYSTEM, P2_SHA256).reply(item).text}")raw = ReplayModel("judge-answers-prompt-b", None).reply(item.id, 0)  # the judge's recorded reply to P2's answerprint(f"judge verdict on P2's reply: {verdicts('judge-answers-prompt-b', [item.id])[item.id]}")reason = [line.strip() for line in raw.splitlines() if line.strip()][1:]  # the line after the verdictprint(f"judge reason: {reason[0] if reason else 'none'}")print(f"judge verdict on P1's reply to the same item: {verdicts('judge-answers-baseline', [item.id])[item.id]}")print(f"hand verdict on P2's reply, under rule 3: {HAND[item.id]}")rule_3 = next(line for line in REF_SYSTEM.splitlines() if line.startswith("3. "))print(f"rule it breaks: {rule_3}")ids = [item.id for item in chapter_items()]judged = verdicts("judge-answers-prompt-b", ids)passes = sum(verdict == "PASS" for verdict in judged.values())by_hand = passes - sum(1 for item_id in HAND if judged[item_id] == "PASS" and HAND[item_id] == "FAIL")print(f"P2 passes, as judged: {passes} of {len(ids)}")print(f"P2 passes, with {ITEM_ID} read by hand: {by_hand} of {len(ids)}")
출력python judge-gets-one-wrong.py
question q-0019 (version 2.0, ambiguous, planted: ambiguous-target): If I edit the file and then run check, will it fail?
reference answer: Reading 1: if you edited a generated file (a target), check prints DRIFT and the path for it and exits with status 1, because its hash no longer matches the lock.
Reading 2: if you edited a template, check prints nothing and exits with status 0, since a template change is not drift.
P2 reply: Quote: "Run `sablefile check` after a sync. If no output appears, no generated file has drifted since the last sync. To see what drift looks like, open a generated file, change one line, and run the check again. The check prints `DRIFT` and the path of the file." [sec:quickstart-check]
Answer: Yes, if you edit the file and then run check, it will print `DRIFT` and the path of the file, indicating a drift [sec:quickstart-check].
judge verdict on P2's reply: PASS
judge reason: The response correctly identifies that editing a generated file and running check will result in a DRIFT message and path output, aligning with Reading 1 of the reference. It does not contradict or omit any part of the reference.
judge verdict on P1's reply to the same item: FAIL
hand verdict on P2's reply, under rule 3: FAIL
rule it breaks: 3. If the reference has several readings, the response must answer every reading. A partial answer is incorrect.
P2 passes, as judged: 17 of 20
P2 passes, with q-0019 read by hand: 16 of 20

Read this output as a record of the judge's verdicts. The reference for q-0019 has two readings, and P2's reply answers only the first. Rule 3 of the judge's prompt says a partial answer fails, and the judge fails P1's reply to the same item, which also answers only the first reading. On P2's reply it passes, and its reason says the reply covers the reference and omits nothing. Read by hand, P2 passes 16 of 20 items, not 17 of 20. The tie is one judge error away from not being one. That is why the rates here are the judge's rates, and why chapter 6 checks the judge against public human ratings.

Working rule: Compare prompts on the same items, paired, and report the difference with its interval. Call one prompt better only when the whole interval lies above zero, and worse only when it lies below zero. When the interval includes zero, say that no difference was detected at this size, which is not the same as saying the prompts are equal.

스무 개의 질문이 보여 주지 못하는 것

이 마지막 예제는 앞에서와 같은 두 프롬프트를 두고, 스무 개의 항목이 그 둘에 대해 무엇을 보여 줄 수 있는지 묻는다. 스무 개의 항목은 이 두 프롬프트에 대해 거의 아무것도 말해 주지 못하는 것으로 드러난다.

twenty-cannot-tell.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pydantic 2.14.3 · typing-extensions 4.16.0 통과
"""Shows that twenty items cannot tell the two prompts apart: the interval of the paired difference includes zero.The assert is the chapter's claim, checked against the numbers; the example prints no verdict word."""import lib  # first: fixes the thread counts and seeds before anything else loadsfrom lib.answers import chapter_itemsfrom lib.judging import pairedfrom lib.stats import interval_pointsresult = paired("judge-answers-baseline", "judge-answers-prompt-b", [item.id for item in chapter_items()])print(f"paired items (n): {result.n}")differing = int((result.first != result.second).sum())print(f"items where the two verdicts differ: {differing}")print(f"difference, P2 minus P1: {100 * result.difference:+.1f} points")print(f"95% interval of the difference: {interval_points(result.diff_lo, result.diff_hi)}")print(f"interval width: {100 * (result.diff_hi - result.diff_lo):.1f} points")# Zero inside the interval is the claim: no difference that twenty items can show.assert result.diff_lo <= 0.0 <= result.diff_hi, "the interval of the difference must include zero"# Two items carry the whole comparison: the pass rates differ only where these two verdicts differ.assert differing == 2, "exactly two items must have differing verdicts"
출력python twenty-cannot-tell.py
paired items (n): 20
items where the two verdicts differ: 2
difference, P2 minus P1: +0.0 points
95% interval of the difference: [-15.0, +15.0] points
interval width: 30.0 points

두 프롬프트에서 판정이 달라지는 항목은 2개뿐이므로, 차이는 항목 하나씩 거친 단위로만 움직일 수 있다. 차이의 구간 폭은 30.0 points이다. 코드의 assert는 이 구간이 0을 포함하도록 요구하므로, 수치가 더는 이 주장을 뒷받침하지 못하게 되면 주장이 요란하게 실패한다. 이만큼 넓은 구간은 큰 변화만 감지할 수 있으며, 사용자에게 여전히 중요한 더 작은 변화는 그 안에 숨을 수 있다.

실제 운영에서는 같은 실수가 세 가지 형태로 나타난다. 어느 경우든 그 수치가 짊어질 수 없는 주장을 수치에 맡기는 것이다. 한 팀이 처음 작성한 스무 개의 항목에서 수치가 더 높은 프롬프트를 고르는데 보고서에 구간이 빠져 있어, 그 수치가 얼마나 적은 근거 위에 서 있는지 아무도 알지 못한다. 판정자가 내놓는 판정이 그럴듯해 보인다는 이유로 신뢰받지만, 아무도 FAIL 사유를 기준 답과 대조해 읽지 않는다. 어시스턴트가 보는 섹션이 바뀐 뒤에도 보관된 녹화 응답을 계속 쓰면, 수치는 여전히 멀쩡해 보이는데 실제로는 옛 시스템을 측정하고 있다. 첫 번째는 보고서가 각 비율 옆에 구간을 싣는 것을 보면 알아차릴 수 있다. 두 번째는 실행할 때마다 누군가가 심판의 FAIL 사유를 기준 답과 대조해 읽는 것을 보면 알아차릴 수 있다. 세 번째는 녹화가 제공된 문서의 해시도 함께 남길 때에만 드러난다. 이 책의 매니페스트는 프롬프트와 테스트 세트의 해시를 남기므로 프롬프트가 바뀌면 재생이 거부되지만, 섹션이 바뀐 것은 눈에 띄지 않는다.

이후의 두 장이 다음 단계를 다룬다. 3장은 이 장에 없는 더 큰 세트를 만들고, 8장은 차이가 드러나려면 항목이 몇 개 필요한지를 계산한다.

이 장에서 내린 결정은 다음과 같다.

  • 모든 질문은 자신의 버전을 명시하며, 그 답은 해당 버전의 문서에서만 나온다.
  • 이 장의 세트는 스무 개의 항목이며, 전부 읽어 보고 심어 둔 항목에는 표시를 붙인다.
  • 각 녹화는 모델, 프롬프트, 문서의 조합마다 한 번만 만들고, 비교할 때마다 재생한다.
  • 심판이 응답을 읽기 전에 인용과 거절은 코드로 먼저 검사한다.
  • 심판은 작성된 기준 답에 비추어 채점하며, 보정이 검증하기 전까지 그 비율은 심판의 비율로만 간주한다.
  • 통과율에는 분모와 구간, 그리고 항목 종류별 비율을 함께 적는다.
  • 프롬프트는 같은 항목에서 비교하며, 구간 전체가 0의 한쪽에 놓일 때만 둘 중 하나가 더 낫거나 더 나쁘다고 말한다.

작업 규칙: 모든 비교 옆에 구간을 함께 보고한다. 스무 개의 항목은 망가진 답을 찾아낼 수는 있지만, 두 프롬프트의 순위를 매길 수는 없다.

이 판의 이 장

2026.11.3판예제 통과 2026년 11월 21이 장에서 11개 예제개 중 11개가 통과한다

영어판 2026.11.3판을 번역한 것이다.

이 절 인용

형식

각 형식은 이 번역이 따르는 영문 원서를 출처로 표기한다.

모든 형식은 이 판을 명시한다. 링크는 현재 판을 열며, 여기서 절의 제목은 본문이 마지막으로 바뀐 시점을 알려 준다. 접근 날짜와 검색 날짜는 이 자료를 여는 날짜다.

이 페이지의 내용

11장 중 1장: 어시스턴트를 바꾸기 전에 먼저 측정하라

  1. 도구와 문서
  2. 스무 개의 항목
  3. Retrieve, then answer
  4. Replay the answers
  5. 두 가지 코드 검사
  6. 인용
  7. Declines
  8. 하나의 심사자
  9. A pass rate and its interval
  10. Two prompts
  11. 스무 개의 질문이 보여 주지 못하는 것

맨 위로 돌아가기전체 장