---
title: Claude Fable 5.1 프롬프팅
url: https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1
description: Claude Fable 5.1 및 Claude Mythos 5.1의 동작 차이와 프롬프팅 패턴을 설명합니다. effort, 진행 상황 업데이트, 도구 호출 일괄 처리, 대화 기록, 작문 스타일, 서식, 작업 완료, 압축 요약, 범위 및 테스트 커버리지, 검색 트리거, 안전장치 오탐, 파일 편집, 긴 출력, 하위 에이전트, 비전을 다룹니다.
---
모델의 기능, API 변경 사항, 가격 및 제공 여부는 [Claude Fable 5.1의 새로운 기능](https://platform.claude.com/docs/ko/models/fable-5-1/whats-new-fable-5-1)을 참조하세요. Claude 모델 전반에 적용되는 기법은 [프롬프팅 모범 사례](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/claude-prompting-best-practices)를 참조하세요.
기존 Claude Fable 5 프롬프트는 변경하지 않아도 Claude Fable 5.1에서 잘 작동합니다. 다만 알아 두면 좋은 동작 차이가 몇 가지 있습니다. 관찰한 현상에 해당하는 섹션부터 확인하세요:
* 어떤 "effort"(노력) 수준으로 실행해야 할지 확실하지 않거나, "latency"(지연 시간)와 비용이 작업에 비해 높은 경우: [모든 effort 수준 고려하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels)
* 도구 호출 사이에 텍스트가 거의 없거나 전혀 없는 경우: [사용자 대상 진행 상황 업데이트 요청하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates)
* 에이전트 루프에서 턴마다 도구를 하나씩만 호출하는 경우: [에이전트 루프에서 독립적인 도구 호출 일괄 처리하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops)
* 요청이 `bound to a different conversation` 오류로 실패하거나, "harness"(하네스)가 요청 사이에 이전 턴을 편집하는 경우: [대화 기록을 추가 전용으로 유지하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)
* 글이 길고 밀도가 높은 경우: [작문 밀도](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#writing-density)
* 채팅 응답의 구조가 콘텐츠에 필요한 수준보다 부족한 경우: [채팅에서의 서식](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#formatting-in-chat)
* 요약이 출처의 문구를 인용 표시 없이 그대로 옮기는 경우: [검색된 출처 인용하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#quoting-retrieved-sources)
* 작업이 끝나기 전에 턴이 종료되거나, 이미 요청한 작업에 대해 모델이 허락을 구하는 경우: [전체 작업 완료하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#finish-the-whole-task)
* 클라이언트 측 "compaction"(압축) 요약에서 제약 조건, 결정 사항 또는 정확한 세부 정보가 누락되는 경우: [압축 요약에서 보존할 내용을 모델에 알려 주기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries)
* 요청하지 않은 수정이나 확장이 이루어지거나, 작업에 필요한 것보다 많은 테스트 파일이 커밋되는 경우: [변경 사항과 테스트를 작업이 요구하는 범위로 제한하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-changes-and-tests-to-what-the-task-asks-for)
* 낮은 effort에서 검색하지 않고 기억에 의존해 답변하는 경우: [낮은 effort에서의 검색 트리거](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort)
* 무해한 코딩 요청이 `stop_reason: "refusal"`을 반환하는 경우: [안전장치 오탐 줄이기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#reduce-safeguard-false-positives)
* 작은 변경에도 파일 전체를 다시 작성하는 경우: [파일 전체 재작성보다 부분 편집 선호하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#prefer-targeted-edits-over-whole-file-rewrites)
* `xhigh` 또는 `max` effort에서 긴 결과물을 생성하는 데 오래 걸리거나 `max_tokens`에 도달하는 경우: [xhigh 및 max effort에서 긴 출력을 위한 여유 확보하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#leave-room-for-long-outputs-at-xhigh-and-max-effort)
* 하위 에이전트가 실행되는 동안 리드 에이전트가 유휴 상태로 있는 경우: [하위 에이전트 실행 중에도 리드 에이전트가 계속 작업하도록 하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#let-the-lead-agent-keep-working-while-subagents-run)
* 차트나 밀도 높은 이미지에 대한 답변에서 세부 정보가 누락되는 경우: [비전 작업에 자르기 및 확대 도구 제공하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#give-vision-work-tools-to-crop-and-zoom)
Claude Fable 5.1은 안전 분류기를 실행하며 `stop_reason: "refusal"`을 반환할 수 있습니다. [거부, 폴백 및 청구](https://platform.claude.com/docs/ko/models/fable-5-1/whats-new-fable-5-1#refusals-fallback-and-billing) 및 [안전장치 오탐 줄이기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#reduce-safeguard-false-positives)를 참조하세요.
모델에게 사고나 추론 과정을 작성하도록 요청하는 프롬프트, 스킬 및 도구 설명은 `reasoning_extraction` 카테고리로 거부될 수 있습니다. 대신 짧은 설명이나 수행한 작업의 요약을 요청하거나, [요약된 사고](https://platform.claude.com/docs/ko/build-with-claude/thinking#summarized-thinking) 블록(`display: "summarized"`)에서 추론을 읽으세요. [추론을 사고 블록에 유지하기](https://platform.claude.com/docs/ko/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks)를 참조하세요.
## 모든 effort 수준 고려하기
기본 [effort](https://platform.claude.com/docs/ko/build-with-claude/effort) 수준인 `high`에서 시작한 다음, 다른 수준(`low`, `medium`, `xhigh`, `max`)을 자체 평가로 테스트하세요. Claude Fable 5.1에서 effort는 지능, latency, 비용 사이의 균형을 조정하는 주요 수단입니다. Claude Fable 5에서 이미 수준별 비교를 실행했더라도 다시 실행하세요. 같은 이름의 effort 수준이라도 모델마다 사고량이 다릅니다.
Claude Fable 5 대비 Claude Fable 5.1의 성능 향상은 모든 effort 수준에서 나타나며, 높은 설정일수록 큽니다. `medium`에서는 더 낮은 비용으로 Claude Fable 5와 비슷한 결과를 내므로, 평가에서 품질이 유지된다면 `medium` 또는 `low`로 낮추세요. `low`에서 Claude Fable 5.1은 작업당 비용 면에서 Claude Opus 및 Claude Sonnet 모델과 견줄 만한 경우가 많으면서도 더 높은 점수를 기록합니다. 따라서 더 작은 모델을 더 높은 effort 수준으로 실행하려던 경우라면 `low`도 비교 대상에 포함하세요.
effort 수준에 따른 두 가지 동작은 별도 섹션에서 다룹니다. `low`에서 Claude Fable 5.1은 검색 및 조회 도구를 덜 자주 호출합니다([낮은 effort에서의 검색 트리거](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort) 참조). `xhigh`와 `max`에서는 긴 결과물을 작성하기 전에 더 오래 사고할 수 있습니다([xhigh 및 max effort에서 긴 출력을 위한 여유 확보하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#leave-room-for-long-outputs-at-xhigh-and-max-effort) 참조).
## 사용자 대상 진행 상황 업데이트 요청하기
Claude Fable 5.1은 기본적으로 긴 도구 호출 턴 동안 Claude Fable 5보다 사용자 대상 업데이트를 적게 작성합니다. 이 경향은 effort가 높을수록, 도구 체인이 길수록 두드러집니다. 그 결과 사용자는 에이전트가 몇 분씩 아무 말이 없거나, 최종 메시지가 전체 작업이 아닌 마지막 단계만 다루는 상황을 겪게 됩니다.
먼저 클라이언트가 진행 상황 업데이트를 실제로 받고 있는지 확인하세요. 모델이 도구 호출 사이에 남기는 짧은 메모(방금 발견한 내용과 다음에 할 일)는 [진행 상황 업데이트 `thinking` 블록](https://platform.claude.com/docs/ko/build-with-claude/thinking#progress-updates)으로 반환됩니다. 이 블록은 `thinking.display`의 기본값인 `"omitted"`에서는 비어 있습니다. `display: "updates"`(베타, `thinking-display-updates-2026-08-18` 헤더)를 설정하고 비어 있지 않은 각 `thinking` 블록을 상태 줄로 렌더링하세요. 또는 `"summarized"`를 설정하면 요약된 추론과 함께 업데이트를 받을 수 있습니다. 이를 요청하지 않으면 모델의 업데이트가 사용자에게 전달되지 않을 수 있습니다.
다음으로, 프롬프트에 진행 상황 설명을 억제하는 지시가 있는지 점검하세요. 일부 이전 모델은 작업 중에 업데이트를 지나치게 자주 제공했기 때문에 "모든 발견 사항은 최종 응답까지 보류하세요"와 같은 시스템 프롬프트 문구가 생겨났습니다. 새 지시를 추가하기 전에 이런 문구부터 제거하세요.
그래도 업데이트를 더 받고 싶다면(예: 페어 프로그래밍이나 기타 human-in-the-loop 작업), 모델이 언제 사용자 대상 텍스트를 작성해야 하는지와 각 업데이트에 무엇을 담아야 하는지 설명하는 짧은 시스템 프롬프트 문구를 추가하세요:
```text wrap
Before you start, say in a line what you're about to do; brief updates while you work help the user follow along. Close with a short recap that stands on its own — what you found, what you did, and what's next — so a reader who only sees the last message has the full picture.
```
제품에서 도구 출력을 접거나 숨긴다면 이 사실을 모델에 알려 주세요. 그렇지 않으면 모델이 UI에 표시되지도 않는 출력을 사용자에게 "보여 주려고" 명령을 실행할 수 있습니다. 이 메모는 [턴 범위 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)(`clear_at: "next_user_message"`, 베타)로 전달하세요:
```text wrap
Only you see that command's output — the user's terminal shows at most a few lines of it. If the user needs to read any of it, put it in your reply.
```
## 에이전트 루프에서 독립적인 도구 호출 일괄 처리하기
Claude Fable 5.1은 대개 예상대로 도구를 병렬로 호출합니다. 요청에서 가져올 항목을 여러 개 지정하면 해당 호출을 병렬로 실행합니다. 예외는 코딩 및 컴퓨터 사용 루프(맞춤형 코딩 에이전트, bash 및 편집기 하네스, 컴퓨터 사용)입니다. 이런 루프에서는 다음에 수행할 독립적인 호출이 명시적으로 요청되지 않고 작업에 암시되어 있을 뿐이므로, 모델이 턴마다 하나씩 호출할 수 있습니다. 답변 품질에는 영향이 없지만, 턴이 하나 늘어날 때마다 토큰, 왕복 요청, 실제 경과 시간이 추가로 소요됩니다. 현재 요청 끝에 유도 문구 한 문장을 추가하면 해결됩니다:
```text wrap
First privately list what you need next; then request every item that doesn't depend on another's result in this one response.
```
도구 결과를 다시 보낼 때마다 해당 사용자 메시지 뒤에 이 문구를 [턴 범위 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)로 추가하세요. 즉, `messages`에 `clear_at: "next_user_message"`가 포함된 `role: "system"` 항목을 넣습니다. 이후 사용자 메시지가 추가되면 API가 이전 사본을 지우므로 모델은 가장 최근 사본만 읽습니다. 턴 범위 시스템 메시지는 베타 기능이며 [베타 헤더](https://platform.claude.com/docs/ko/api/beta-headers) `mid-conversation-system-clear-at-2026-08-21`이 필요합니다. 베타를 사용하지 않는다면 같은 사용자 메시지에서 `tool_result` 블록 뒤에 텍스트 블록을 두고 그 안에 이 문장을 넣으세요.
매 턴마다 새 사본을 추가하고, 이전 사본은 바이트 단위까지 그대로 두세요. 이전 사본은 배열에 남아 있지만, 지워진 뒤에는 모델이 보지 않으며 입력 토큰 비용도 발생하지 않습니다. 이전 사본을 삭제하거나 다시 작성하면 이전 턴을 편집하는 셈이 됩니다. 그러면 [프롬프트 캐싱](https://platform.claude.com/docs/ko/build-with-claude/prompt-caching)이 해당 지점부터 다시 시작되고, 그 뒤에 오는 thinking 블록이 무효화됩니다([대화 기록을 추가 전용으로 유지하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only) 참조).
다음 루프는 이 배치 방식을 보여 줍니다. 각 어시스턴트 턴은 반환된 그대로 다시 전송되고, 각 사용자 턴에는 도구 결과만 담기며, 그 뒤에 유도 문구의 새 턴 범위 사본이 이어집니다.
```python Python
import anthropic
from anthropic.types.beta import (
BetaMessageParam,
BetaToolParam,
BetaToolResultBlockParam,
)
client = anthropic.Anthropic()
BATCH_NUDGE = (
"First privately list what you need next; then request every item "
"that doesn't depend on another's result in this one response."
)
# 인메모리 파일이 작업 디렉터리를 대신하므로 샘플을 어디서나 실행할 수 있습니다.
FILES = {
"pyproject.toml": """\
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
""",
"README.md": """\
# demo
A small demo project. Run `demo --help` for usage.
""",
}
tools: list[BetaToolParam] = [
{
"name": "read_file",
"description": "Read a UTF-8 text file from the working directory.",
"input_schema": {
"type": "object",
"properties": {"path": {"type": "string"}},
"required": ["path"],
},
}
]
messages: list[BetaMessageParam] = [
{"role": "user", "content": "Summarize pyproject.toml and README.md."}
]
while True:
response = client.beta.messages.create(
model="claude-fable-5-1",
max_tokens=16000,
betas=["mid-conversation-system-clear-at-2026-08-21"],
tools=tools,
messages=messages,
)
# thinking 블록을 포함하여 어시스턴트 턴을 반환된 그대로 추가합니다.
messages.append({"role": "assistant", "content": response.content})
if response.stop_reason != "tool_use":
break
tool_results: list[BetaToolResultBlockParam] = []
for block in response.content:
if block.type == "tool_use":
raw_path = block.input.get("path")
path = raw_path if isinstance(raw_path, str) else ""
if path in FILES:
tool_results.append(
{
"type": "tool_result",
"tool_use_id": block.id,
"content": FILES[path],
}
)
else:
tool_results.append(
{
"type": "tool_result",
"tool_use_id": block.id,
"content": f"File not found: {path}",
"is_error": True,
}
)
# 도구 결과를 사용자 턴으로 보낸 다음, 넛지의 새 사본을
# 턴 범위 시스템 메시지로 보냅니다. 이전 사본은 그대로 둡니다. API가 이를 지우므로
# 모델은 최신 사본만 보게 됩니다.
messages.append({"role": "user", "content": tool_results})
messages.append(
{"role": "system", "content": BATCH_NUDGE, "clear_at": "next_user_message"}
)
print(next((block.text for block in response.content if block.type == "text"), ""))
```
```typescript TypeScript
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const BATCH_NUDGE =
"First privately list what you need next; then request every item " +
"that doesn't depend on another's result in this one response.";
// 인메모리 파일이 작업 디렉터리를 대신하므로 샘플을 어디서나 실행할 수 있습니다.
const FILES = new Map([
[
"pyproject.toml",
`[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
`,
],
[
"README.md",
`# demo
A small demo project. Run \`demo --help\` for usage.
`,
],
]);
const tools: Anthropic.Beta.Messages.BetaTool[] = [
{
name: "read_file",
description: "Read a UTF-8 text file from the working directory.",
input_schema: {
type: "object",
properties: { path: { type: "string" } },
required: ["path"],
},
},
];
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Summarize pyproject.toml and README.md." },
];
let response: Anthropic.Beta.Messages.BetaMessage;
while (true) {
response = await client.beta.messages.create({
model: "claude-fable-5-1",
max_tokens: 16000,
betas: ["mid-conversation-system-clear-at-2026-08-21"],
tools,
messages,
});
// thinking 블록을 포함하여 어시스턴트 턴을 반환된 그대로 추가합니다.
messages.push({ role: "assistant", content: response.content });
if (response.stop_reason !== "tool_use") {
break;
}
const toolResults: Anthropic.Beta.Messages.BetaToolResultBlockParam[] = [];
for (const block of response.content) {
if (block.type !== "tool_use") {
continue;
}
const { input } = block;
const path =
typeof input === "object" &&
input !== null &&
"path" in input &&
typeof input.path === "string"
? input.path
: "";
const text = FILES.get(path);
if (text === undefined) {
toolResults.push({
type: "tool_result",
tool_use_id: block.id,
content: `File not found: ${path}`,
is_error: true,
});
continue;
}
toolResults.push({
type: "tool_result",
tool_use_id: block.id,
content: text,
});
}
// 도구 결과를 사용자 턴으로 보낸 다음, 넛지의 새 사본을
// 턴 범위 시스템 메시지로 보냅니다. 이전 사본은 그대로 둡니다. API가 이를 지우므로
// 모델은 최신 사본만 보게 됩니다.
messages.push({ role: "user", content: toolResults });
messages.push({
role: "system",
content: BATCH_NUDGE,
clear_at: "next_user_message",
});
}
const finalText = response.content.find((block) => block.type === "text");
console.log(finalText?.text ?? "");
```
```csharp C#
using System.Text.Json;
using Anthropic;
using Anthropic.Models.Beta.Messages;
using Model = Anthropic.Models.Messages.Model;
AnthropicClient client = new();
const string BatchNudge =
"First privately list what you need next; then request every item "
+ "that doesn't depend on another's result in this one response.";
// 인메모리 파일이 작업 디렉터리를 대신하므로 샘플을 어디서나 실행할 수 있습니다.
Dictionary files = new()
{
["pyproject.toml"] = """
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
""",
["README.md"] = """
# demo
A small demo project. Run `demo --help` for usage.
""",
};
List tools =
[
new BetaTool
{
Name = "read_file",
Description = "Read a UTF-8 text file from the working directory.",
InputSchema = new InputSchema
{
Properties = new Dictionary
{
["path"] = JsonSerializer.SerializeToElement(new { type = "string" }),
},
Required = ["path"],
},
},
];
List messages =
[
new() { Role = Role.User, Content = "Summarize pyproject.toml and README.md." },
];
BetaMessage response;
while (true)
{
response = await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Model.ClaudeFable5_1,
MaxTokens = 16000,
Betas = ["mid-conversation-system-clear-at-2026-08-21"],
Tools = tools,
Messages = messages,
});
// thinking 블록을 포함하여 어시스턴트 턴을 반환된 그대로 추가합니다.
messages.Add(new()
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
});
if (response.StopReason != BetaStopReason.ToolUse)
{
break;
}
List toolResults = [];
foreach (var block in response.Content)
{
if (block.TryPickToolUse(out var toolUse))
{
var path = toolUse.Input.TryGetValue("path", out var pathValue)
&& pathValue.ValueKind == JsonValueKind.String
? pathValue.GetString()!
: "";
if (files.TryGetValue(path, out var fileText))
{
toolResults.Add(new BetaToolResultBlockParam { ToolUseID = toolUse.ID, Content = fileText });
}
else
{
toolResults.Add(new BetaToolResultBlockParam
{
ToolUseID = toolUse.ID,
Content = $"File not found: {path}",
IsError = true,
});
}
}
}
// 도구 결과를 사용자 턴으로 보낸 다음, 넛지의 새 사본을
// 턴 범위 시스템 메시지로 보냅니다. 이전 사본은 그대로 둡니다. API가 이를 지우므로
// 모델은 최신 사본만 보게 됩니다.
messages.Add(new() { Role = Role.User, Content = toolResults });
messages.Add(new()
{
Role = Role.System,
Content = BatchNudge,
ClearAt = ClearAt.NextUserMessage,
});
}
foreach (var block in response.Content)
{
if (block.TryPickText(out var text))
{
Console.WriteLine(text.Text);
break;
}
}
```
```go Go
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/anthropics/anthropic-sdk-go"
)
const batchNudge = "First privately list what you need next; then request every item " +
"that doesn't depend on another's result in this one response."
// 인메모리 파일이 작업 디렉터리를 대신하므로 샘플을 어디서나 실행할 수 있습니다.
var files = map[string]string{
"pyproject.toml": `[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
`,
"README.md": `# demo
A small demo project. Run "demo --help" for usage.
`,
}
func main() {
client := anthropic.NewClient()
ctx := context.Background()
tools := []anthropic.BetaToolUnionParam{
{OfTool: &anthropic.BetaToolParam{
Name: "read_file",
Description: anthropic.String("Read a UTF-8 text file from the working directory."),
InputSchema: anthropic.BetaToolInputSchemaParam{
Properties: map[string]any{
"path": map[string]any{"type": "string"},
},
Required: []string{"path"},
},
}},
}
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize pyproject.toml and README.md.")),
}
var response *anthropic.BetaMessage
for {
var err error
response, err = client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeFable5_1,
MaxTokens: 16000,
Betas: []anthropic.AnthropicBeta{"mid-conversation-system-clear-at-2026-08-21"},
Tools: tools,
Messages: messages,
})
if err != nil {
log.Fatal(err)
}
// thinking 블록을 포함하여 어시스턴트 턴을 반환된 그대로 추가합니다.
messages = append(messages, response.ToParam())
if response.StopReason != anthropic.BetaStopReasonToolUse {
break
}
var toolResults []anthropic.BetaContentBlockParamUnion
for _, block := range response.Content {
toolUse, ok := block.AsAny().(anthropic.BetaToolUseBlock)
if !ok {
continue
}
var input struct {
Path string `json:"path"`
}
// 경로가 없거나 문자열이 아니면 input.Path가 비어 있게 되어 오류 결과 분기로 이동합니다.
if err := json.Unmarshal([]byte(toolUse.JSON.Input.Raw()), &input); err != nil {
input.Path = ""
}
text, found := files[input.Path]
if !found {
text = "File not found: " + input.Path
}
toolResults = append(toolResults, anthropic.NewBetaToolResultBlock(toolUse.ID, text, !found))
}
// 도구 결과를 사용자 턴으로 보낸 다음, 넛지의 새 사본을
// 턴 범위 시스템 메시지로 보냅니다. 이전 사본은 그대로 둡니다. API가 이를 지우므로
// 모델은 최신 사본만 보게 됩니다.
messages = append(messages, anthropic.NewBetaUserMessage(toolResults...))
messages = append(messages, anthropic.BetaMessageParam{
Role: anthropic.BetaMessageParamRoleSystem,
Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock(batchNudge)},
ClearAt: anthropic.BetaMessageParamClearAtNextUserMessage,
})
}
for _, block := range response.Content {
if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
fmt.Println(textBlock.Text)
break
}
}
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.messages.BetaContentBlockParam;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaStopReason;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.BetaTool.InputSchema;
import com.anthropic.models.beta.messages.BetaToolResultBlockParam;
import com.anthropic.models.beta.messages.BetaToolUseBlock;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
static final String BATCH_NUDGE =
"First privately list what you need next; then request every item "
+ "that doesn't depend on another's result in this one response.";
// 인메모리 파일이 작업 디렉터리를 대신하므로 샘플을 어디서나 실행할 수 있습니다.
static final Map FILES = Map.of(
"pyproject.toml", """
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
""",
"README.md", """
# demo
A small demo project. Run `demo --help` for usage.
""");
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
BetaTool readFileTool = BetaTool.builder()
.name("read_file")
.description("Read a UTF-8 text file from the working directory.")
.inputSchema(InputSchema.builder()
.properties(JsonValue.from(Map.of("path", Map.of("type", "string"))))
.required(List.of("path"))
.build())
.build();
List messages = new ArrayList<>();
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content("Summarize pyproject.toml and README.md.")
.build());
BetaMessage response;
while (true) {
response = client.beta().messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_FABLE_5_1)
.maxTokens(16000)
.addBeta("mid-conversation-system-clear-at-2026-08-21")
.addTool(readFileTool)
.messages(messages)
.build());
// thinking 블록을 포함하여 어시스턴트 턴을 반환된 그대로 추가합니다.
messages.add(response.toParam());
boolean requestedTools = response.stopReason()
.map(BetaStopReason.TOOL_USE::equals)
.orElse(false);
if (!requestedTools) {
break;
}
List toolUses = response.content().stream()
.flatMap(block -> block.toolUse().stream())
.toList();
List toolResults = new ArrayList<>();
for (BetaToolUseBlock toolUse : toolUses) {
Map input =
(Map) toolUse._input().asObject().orElseThrow();
JsonValue pathValue = input.get("path");
String path = pathValue != null && pathValue.asString().isPresent()
? pathValue.asStringOrThrow()
: "";
String fileText = FILES.get(path);
BetaToolResultBlockParam.Builder result = BetaToolResultBlockParam.builder()
.toolUseId(toolUse.id());
if (fileText != null) {
result.content(fileText);
} else {
result.content("File not found: " + path).isError(true);
}
toolResults.add(BetaContentBlockParam.ofToolResult(result.build()));
}
// 도구 결과를 사용자 턴으로 보낸 다음, 넛지의 새 사본을
// 턴 범위 시스템 메시지로 보냅니다. 이전 사본은 그대로 둡니다. API가 이를 지우므로
// 모델은 최신 사본만 보게 됩니다.
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.contentOfBetaContentBlockParams(toolResults)
.build());
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.SYSTEM)
.content(BATCH_NUDGE)
.clearAt(BetaMessageParam.ClearAt.NEXT_USER_MESSAGE)
.build());
}
String finalText = response.content().stream()
.flatMap(block -> block.text().stream())
.map(textBlock -> textBlock.text())
.findFirst()
.orElse("");
IO.println(finalText);
}
```
```php PHP
<<<'TOML'
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
TOML,
'README.md' => <<<'MD'
# demo
A small demo project. Run `demo --help` for usage.
MD,
];
$tools = [
[
'name' => 'read_file',
'description' => 'Read a UTF-8 text file from the working directory.',
'input_schema' => [
'type' => 'object',
'properties' => ['path' => ['type' => 'string']],
'required' => ['path'],
],
],
];
$messages = [
['role' => 'user', 'content' => 'Summarize pyproject.toml and README.md.'],
];
while (true) {
$response = $client->beta->messages->create(
model: 'claude-fable-5-1',
maxTokens: 16000,
betas: ['mid-conversation-system-clear-at-2026-08-21'],
tools: $tools,
messages: $messages,
);
// thinking 블록을 포함하여 어시스턴트 턴을 반환된 그대로 추가합니다.
$messages[] = ['role' => 'assistant', 'content' => $response->content];
if ($response->stopReason !== BetaStopReason::TOOL_USE->value) {
break;
}
$toolResults = [];
foreach ($response->content as $block) {
if ($block->type === 'tool_use') {
$path = is_string($block->input['path'] ?? null) ? $block->input['path'] : '';
if (array_key_exists($path, FILES)) {
$toolResults[] = [
'type' => 'tool_result',
'tool_use_id' => $block->id,
'content' => FILES[$path],
];
} else {
$toolResults[] = [
'type' => 'tool_result',
'tool_use_id' => $block->id,
'content' => "File not found: {$path}",
'is_error' => true,
];
}
}
}
// 도구 결과를 사용자 턴으로 보낸 다음, 넛지의 새 사본을
// 턴 범위 시스템 메시지로 보냅니다. 이전 사본은 그대로 둡니다. API가 이를 지우므로
// 모델은 최신 사본만 보게 됩니다.
$messages[] = ['role' => 'user', 'content' => $toolResults];
$messages[] = [
'role' => 'system',
'content' => BATCH_NUDGE,
'clear_at' => 'next_user_message',
];
}
$textBlock = array_find($response->content, fn ($block) => $block->type === 'text');
echo $textBlock?->text ?? '', PHP_EOL;
```
```ruby Ruby
require "anthropic"
client = Anthropic::Client.new
BATCH_NUDGE =
"First privately list what you need next; then request every item " \
"that doesn't depend on another's result in this one response."
# 인메모리 파일이 작업 디렉터리를 대신하므로 샘플을 어디서나 실행할 수 있습니다.
FILES = {
"pyproject.toml" => <<~TOML,
[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
TOML
"README.md" => <<~MD
# demo
A small demo project. Run `demo --help` for usage.
MD
}
tools = [
{
name: "read_file",
description: "Read a UTF-8 text file from the working directory.",
input_schema: {
type: "object",
properties: {path: {type: "string"}},
required: ["path"]
}
}
]
messages = [{role: "user", content: "Summarize pyproject.toml and README.md."}]
response = nil
loop do
response = client.beta.messages.create(
model: "claude-fable-5-1",
max_tokens: 16000,
betas: ["mid-conversation-system-clear-at-2026-08-21"],
tools: tools,
messages: messages
)
# thinking 블록을 포함하여 어시스턴트 턴을 반환된 그대로 추가합니다.
messages << {role: "assistant", content: response.content}
break unless response.stop_reason == :tool_use
tool_results = response.content.filter_map do |block|
next unless block.type == :tool_use
path = block.input[:path]
if FILES.key?(path)
{type: "tool_result", tool_use_id: block.id, content: FILES[path]}
else
{
type: "tool_result",
tool_use_id: block.id,
content: "File not found: #{path}",
is_error: true
}
end
end
# 도구 결과를 사용자 턴으로 보낸 다음, 넛지의 새 사본을
# 턴 범위 시스템 메시지로 보냅니다. 이전 사본은 그대로 둡니다. API가 이를 지우므로
# 모델은 최신 사본만 보게 됩니다.
messages << {role: "user", content: tool_results}
messages << {role: "system", content: BATCH_NUDGE, clear_at: "next_user_message"}
end
puts response.content.find { it.type == :text }&.text
```
## 대화 기록을 추가 전용으로 유지하기
각 어시스턴트 턴은 API가 반환한 그대로, thinking 블록까지 포함해 기록에 추가하세요. 요청 사이에 이전 턴을 편집해서는 안 됩니다. 2026년 8월 31일 이후에 생성된 신규 계정에서는 Claude Fable 5.1의 thinking 블록이 [해당 블록을 생성한 바로 그 대화에서만](https://platform.claude.com/docs/ko/build-with-claude/thinking#preserved-in-conversation) 유효합니다. 접두사(시스템 프롬프트, 도구 목록 또는 이전 메시지)가 바뀐 뒤에 thinking 블록을 다시 보내는 요청은 400 오류를 반환합니다. `thinking.block_binding.prefix_mismatch_behavior: "drop_block"`(베타, `thinking-binding-controls-2026-08-01` 헤더)을 설정한 경우에는 영향을 받는 블록이 제거됩니다. 계정에 이 검사가 적용되지 않더라도 이 패턴을 따르세요. 그래야 모든 계정에서 같은 코드가 작동합니다.
이 검사에 걸리는 기록 편집은 [프롬프트 캐싱](https://platform.claude.com/docs/ko/build-with-claude/prompt-caching)을 다시 시작하게 만드는 편집과 같습니다. 턴별 리마인더를 삽입했다가 제거하는 것, 이전 턴을 그 자리에서 요약하는 것, 세션 도중에 시스템 프롬프트를 변경하는 것이 여기에 해당합니다. 턴별 리마인더는 [턴 범위 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages)로 보내세요. 지시나 도구를 변경할 때는 `system`이나 `tools`를 다시 작성하지 말고 [대화 중간 시스템 메시지](https://platform.claude.com/docs/ko/build-with-claude/mid-conversation-system-messages)를 사용하세요. 기록을 줄이는 작업은 서버 측 [압축](https://platform.claude.com/docs/ko/build-with-claude/compaction) 또는 [컨텍스트 편집](https://platform.claude.com/docs/ko/build-with-claude/context-editing)에 맡기세요. 클라이언트에서 압축한다면 가장 간단한 방법은 전체 기록을 요약 메시지 하나와 새 사용자 턴으로 교체하고 그 외에는 아무것도 다시 보내지 않는 것입니다. 이어지는 thinking 블록이 없으므로 실패할 일이 없고, 모델은 압축된 대화를 바탕으로 새로 사고합니다([클라이언트에서의 맞춤형 압축](https://platform.claude.com/docs/ko/build-with-claude/preserved-thinking#custom-compaction-on-the-client) 참조). 이제 캐시 읽기 비용이 더 저렴해졌으므로([가격](https://platform.claude.com/docs/ko/models/fable-5-1/whats-new-fable-5-1#pricing) 참조), Claude Fable 5.1에서는 비용을 아끼려고 일찍 압축하는 것이 더 이상 최선의 비용-지능 트레이드오프가 아닐 수 있습니다. 압축 시점을 늦춰 가며 실험해 보세요.
하네스가 이미 수행하고 있는 편집을 찾는 방법은 두 가지입니다. [통합이 영향을 받는지 확인하는 방법](https://platform.claude.com/docs/ko/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted)에 설명된 대로 `prefix_mismatch_behavior: "drop_block"`으로 세션을 실행하고 `input_transformations`를 기록할 수 있습니다. 또는 일반적인 턴을 몇 번 진행하면서 하네스가 보내는 요청을 그대로 캡처하고, 연속된 요청이 새로 추가된 턴을 제외하면 바이트 단위로 동일한지 확인하세요.
## 작문 밀도
Claude Fable 5.1의 글에는 상투적인 표현이 적고 설명 없는 전문 용어도 거의 없습니다. 하지만 경우에 따라 산문이 Claude Fable 5보다 밀도가 높습니다. 문장이 더 길고 단락 구분이 더 적습니다. 피해야 할 패턴인 꾸민 듯한 문체(mannered prose)를 정의하는 지시가 도움이 됩니다. 이를 사용자 메시지(권장) 또는 시스템 프롬프트에 추가하세요:
```text wrap
Mannered prose substitutes metaphor and flourish for direct statement. Instead of "a parameter worth varying," the mannered writer produces "a dial worth turning." Instead of "this point still matters," they write "this point earns its keep." The phrases exist to display the writer, not to convey the idea, and readers can tell. That is why mannered prose irritates: it makes the reader work harder so the writer can perform. It is also imprecise. Metaphors drag in connotations the writer did not choose and cannot control. The fix is to say what you mean. When a literal phrase is available, use it.
```
짧은 버전도 대체로 효과가 있습니다:
```text wrap
Please remove all mannered prose.
```
## 채팅에서의 서식
이전 모델은 채팅에서 글머리 기호와 굵은 글씨를 과도하게 사용했기 때문에, 많은 프롬프트에 이를 억제하는 서식 금지 규칙이 들어 있습니다. Claude Fable 5.1은 반대 경향을 보입니다. 굵은 글씨를 덜 사용하고, 헤더, 목록, 따옴표도 잘 사용하지 않습니다. 프롬프트에 서식 금지 문구가 있다면 제거하거나, 다음과 같이 특정 서식이 적절한 경우를 명시하는 규칙으로 바꾸세요:
```text wrap
Use lists and bullet points when asked to, or when the content is multifaceted enough that they help with clarity. If the person explicitly requests minimal formatting, always format your responses without bullet points, headers, lists, or bold emphasis, as requested. In conversational, personal, or emotional exchanges, keep to plain prose.
```
## 검색된 출처 인용하기
문서를 요약할 때 Claude Fable 5.1은 Claude Fable 5보다 원문 구절을 인용 표시 없이 그대로 옮길 가능성이 높습니다. 이를 해결하려면 올바른 응답의 완전한 예시 하나를 시스템 프롬프트에 추가하세요. 예시에는 사용자의 요청, 응답, 그리고 그 응답이 올바른 이유를 설명하는 문장이 포함되어야 합니다.
```text wrap
look up how the Riverton Ledger and the Coast Dispatch each covered the Harbor Bridge closure and compare their reporting
[web_search: Harbor Bridge closure Riverton Ledger]
[web_search: Harbor Bridge closure Coast Dispatch]
Both outlets agree on the basics: the bridge closed on March 3 after inspectors found cracked welds, and the state expects repairs to take about eight months. Where they differ is emphasis. The Ledger treats it as a local-economy story. The Dispatch frames it as a funding failure; its editorial calls the closure "entirely foreseeable." Read together, the Ledger explains who is affected now and the Dispatch explains how it came to this — neither account alone gives the whole picture.
CORRECT: The response is organized around where the two outlets agree and differ, not as a walk through either article. Each outlet's reporting is conveyed in one or two sentences of the assistant's own indirect speech. One short marked phrase from one source; every other claim is reworded. The response is still specific and complete.
```
두 개의 `[web_search: ...]` 줄은 사용하는 도구의 이름으로 바꾸세요. 그래야 모델이 이 줄을 그대로 출력할 텍스트가 아니라 템플릿 형태의 도구 출력으로 인식합니다.
## 전체 작업 완료하기
Claude Fable 5.1은 특히 목표가 명확할 때 방법론에 대한 안내가 많지 않아도 매우 긴 작업을 수행할 수 있습니다. 하지만 복잡한 비동기 워크로드에서는 작업이 끝나기 전에 턴을 종료하지 않도록 유도하세요. 이런 유도가 없으면 모델이 다음에 할 일을 실행하지 않고 설명만 하거나("다음으로 …하겠습니다"), 원래 요청에 이미 포함된 단계에 대해 허락을 구하며 멈추기도 합니다("이것을 적용할까요?"). 그러면 사용자가 "계속" 또는 "진행해"라고 답해야 합니다. 이런 방식은 페어 프로그래밍이나 기타 human-in-the-loop 작업에는 적합하지만, 장기 작업을 수행하는 모델의 능력을 충분히 활용하지 못합니다.
시스템 프롬프트에 다음 두 가지를 함께 추가하면 이 문제를 완화할 수 있습니다. 둘 다 적용하세요. 프롬프트 길이를 제한해야 한다면 첫 번째만 사용해도 효과의 대부분을 얻을 수 있습니다. 첫 번째는 이미 요청된 작업에 대해 묻지 말고, 스스로 밝힌 다음 단계를 실행하라고 모델에 지시합니다:
```text wrap
You are operating autonomously. The user is not watching in real time and cannot answer questions mid-task, so asking 'Want me to…?' or 'Shall I…?' will block the work. For reversible actions that follow from the original request, proceed without asking. Stop only for destructive actions or genuine scope changes the user must decide. Offering follow-ups after the task is done is fine; asking permission before doing the work is not.
Exception: when the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment. Report your findings and stop. Don't apply a fix until they ask for one.
Before ending your turn, check your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or a promise about work you have not done ('I'll…', 'let me know when…'), do that work now with tool calls. That includes retrying after errors and gathering missing information yourself. Do not stop because the context or session is long. End your turn only when the task is complete or you are blocked on input only the user can provide.
Before running a command that changes system state (such as restarts, deletes, or config edits), check that the evidence actually supports that specific action. A signal that pattern-matches to a known failure may have a different cause.
```
사용자가 지켜보고 있지 않다고 알려 주는 첫 문장이 효과의 상당 부분을 차지합니다. 작성된 그대로 유지하세요. 제품에서 모델이 특정 확인을 위해 멈춰야 한다면, 그 문장 뒤에 해당 확인 사항을 나열하는 문장을 추가하세요. 이 블록을 사용하면 모델이 모호한 요청에 대해 질문하는 빈도도 줄어들 수 있으므로, 자체 작업에서 이 트레이드오프를 확인하세요.
두 번째는 사용자의 요청을 결과물의 범위로 정의합니다:
```text wrap
# Delivering work
The user's request — or the plan they approved — sets the scope, and the scope is the deliverable: don't quietly narrow, widen, or swap it. Read ambiguity the way a careful colleague would: make routine judgment calls yourself, and check in only when different readings would lead to materially different work. If you see a real problem with the task as specified, say so in a sentence or two and keep building under stated assumptions; if the user hears the concern and reaffirms, that is their decision, so deliver the full request.
If a question comes up partway, first do everything that doesn't depend on the answer; then state the assumption you made, or — when going ahead on a wrong guess would be unsafe or would make the work useless — put the question at the end of a turn that also delivers that progress. If one part turns out to be blocked, complete every other part in full and say exactly what you left out and why — the whole task is the deliverable, and scaling it down is the user's call, not yours. A step you have decided on is something to run, not to announce: describing the next step and ending the turn leaves it undone until the user replies.
Keep changes to what the request needs. Something else you notice worth doing — cleanup or documentation the task didn't call for, a change to a file the task didn't require — is a suggestion to make at the end, not a change to make; actions clearly beyond what the ask implies, and risky or destructive ones, still need the user's go-ahead.
```
## 압축 요약에서 보존할 내용을 모델에 알려 주기
긴 대화를 압축할 때 요약에 반드시 남겨야 할 내용을 명시적으로 알려 주면 Claude Fable 5.1이 잘 따릅니다. 서버 측 [압축](https://platform.claude.com/docs/ko/build-with-claude/compaction)은 이미 이렇게 동작합니다. 클라이언트 측에서 압축한다면 다음 요약 지시를 사용하세요:
```text wrap
Summarize the transcript inside tags. Include relevant information in the summary such that this conversation will be continued by a new context window without needing to redo work or be reprovided with relevant constraints or context. Be sure to preserve: (1) any difficulties or problems that came up, and how they were handled or resolved; (2) any possibilities, options, or approaches that were raised, tried, or set aside, and why; (3) anything that was asked for, decided, agreed, ruled out, or established as a preference, constraint, or boundary — stated exactly; (4) exactly where things stand now — what has been covered, settled, or completed so far; (5) anything still open, unresolved, promised, or expected to happen next; (6) specific details that would be hard to reconstruct — names, numbers, dates, exact wording, links or references — kept exactly. Be complete on these even at the cost of length; keep everything else concise. Weight the two voices differently: keep what the user said, asked for, shared, or established carefully and close to their own words; your own explanations and reasoning can be condensed much further, to what they concluded or produced — as long as nothing in the six items above is dropped.
```
## 변경 사항과 테스트를 작업이 요구하는 범위로 제한하기
범위가 열려 있는 기능 구현을 요청받으면 Claude Fable 5.1은 요청된 것을 제공하고, 때로는 그 이상을 제공합니다. 주변 코드를 수정하거나, 작업에서 언급하지 않은 동작을 확장하거나, 변경 규모에 비해 많은 테스트 파일을 커밋할 수 있습니다. 무엇을 제외해야 하는지 명시적으로 지시하면 잘 따릅니다. 다음 지시를 사용하면 작업 성공률에 측정 가능한 변화 없이 요청하지 않은 추가 사항과 커밋되는 테스트 코드가 크게 줄어듭니다:
```text wrap
If, while working or testing, you find a pre-existing bug, a performance concern, or behavior the task doesn't mention, don't fix, optimize or extend it in this change unless the requested behavior cannot work without it; report it as a follow-up in your summary. Where the task is ambiguous, implement the reading its wording and the surrounding code most directly support, state that assumption in your summary, and don't build for the other readings as well. Verify your work however you like; scratch scripts and quick checks need not be kept. Commit tests only where the task asks for them or this repository already keeps tests for this kind of change, sized like the neighboring test files — roughly one focused test per stated behavior — and don't turn scratch checks into additional permanent test files. This is about extras only: implement every behavior the task asks for, completely.
```
## 낮은 effort에서의 검색 트리거
`low` effort에서 Claude Fable 5.1은 Claude Fable 5보다 검색 또는 조회 도구를 덜 호출하고, 기억에 의존해 답변하는 경향이 더 강합니다. 경우에 따라 가장 간단한 해결책은 대화 전체가 아니라 영향을 받는 턴에서만 effort를 높이는 것입니다. [대화 중간에 effort 변경하기](https://platform.claude.com/docs/ko/build-with-claude/effort#changing-effort-mid-conversation)를 참조하세요.
그 밖의 경우에는 검증을 유도하는 프롬프트가 도움이 됩니다. 시스템 프롬프트에 이름을 알아본다고 해서 그 대상의 현재 상태를 아는 것은 아니며, 그런 이름은 사용자가 작성한 그대로 검색해야 한다고 명시하세요:
```text wrap
When a query centers on a name you do not confidently recognize, or recognize from a fast-moving area like AI models and developer tools where the landscape shifts within months, the name itself is the thing to verify: search before answering, and include the name as the user wrote it in at least one query alongside any reformulations. This holds even when you have some background on it — partial background is exactly what makes an out-of-date answer sound authoritative, so familiarity is not a reason to skip the search.
```
## 안전장치 오탐 줄이기
Claude Fable 5.1의 안전 분류기는 출시 당시의 Claude Fable 5보다 "false positive"(오탐)가 적으며, 소스 코드에서 취약점을 찾는 작업은 허용됩니다. 그래도 오탐은 여전히 발생하며, 차단된 요청은 `stop_reason: "refusal"`을 반환합니다([거부, 폴백 및 청구](https://platform.claude.com/docs/ko/models/fable-5-1/whats-new-fable-5-1#refusals-fallback-and-billing) 참조). 다음 세 가지 상황에서 오탐이 발생할 가능성이 높습니다:
* **컴파일 확인 문구:** "이 프로그램이 오류 없이 컴파일되나요?" 대신 "이 프로그램에 버그가 있나요?"라고 질문하세요.
* **잘 알려지지 않은 프로그래밍 언어:** 해당 언어가 무엇이고 어떻게 작동하는지에 대한 컨텍스트를 모델에 제공하세요. 예를 들어 해당 언어의 문서에 접근할 수 있게 할 수 있습니다.
* **도구 출력의 Base64:** base64로 인코딩된 데이터를 모델의 컨텍스트로 반환하는 도구는 오탐을 유발할 수 있으므로, 이런 도구를 제거하는 것이 권장되는 해결책입니다.
## 파일 전체 재작성보다 부분 편집 선호하기
Claude Fable 5.1이 작은 변경에도 파일 전체를 다시 작성한다면, 다음 지시를 시스템 프롬프트나 첫 번째 사용자 메시지에 추가하세요. Claude Fable 5.1은 Claude Fable 5보다 필요한 부분만 편집하지 않고 텍스트 파일 전체를 다시 작성하는 경향이 강합니다. 결과 파일은 대개 같지만, 파일이 짧거나 대부분이 바뀌는 경우가 아니라면 전체 재작성에는 출력 토큰과 시간이 더 많이 듭니다. 이 지시를 추가하면 작은 변경과 중간 규모 변경에서 Claude Fable 5.1이 Claude Fable 5와 비슷하게 동작합니다.
```text wrap
The number of tokens used to edit files is best minimized, all else being equal. Therefore, when it will not affect the end result, try to surgically edit a file rather than rewrite the entire thing.
```
## xhigh 및 max effort에서 긴 출력을 위한 여유 확보하기
`xhigh`, 특히 `max` effort에서 Claude Fable 5.1은 응답을 작성하기 전에 더 오래 사고할 수 있습니다. 긴 문서 전체를 다시 작성하는 것처럼 요청 하나로 긴 결과물을 요구하면, 모델이 결과물의 상당 부분을 사고 과정에서 초안으로 작성한 뒤 응답으로 다시 작성할 수 있습니다. 그만큼 대기 시간이 길어지고 출력 토큰도 늘어납니다. 가장 간단한 방법은 이런 요청을 권장 시작점인 `high`에서 실행하고, 품질 향상이 측정된 경우에만 `xhigh` 또는 `max`로 올리는 것입니다([모든 effort 수준 고려하기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels) 참조). `xhigh` 또는 `max`에서 실행한다면 다음을 적용하세요:
* `max_tokens`는 예상 응답 길이만이 아니라 사고와 응답을 모두 담을 수 있도록 여유 있게 설정하세요.
* 사용자 메시지 끝에 다음 메모를 추가하세요. 글쓰기 및 코드 요청에서 사고 과정이 훨씬 짧아집니다. `[max_tokens]`는 요청의 실제 `max_tokens` 값(예: 64,000)으로 바꾸세요.
```text wrap
Everything produced in one reply, including any reasoning or drafting done before the reply, counts toward a single limit of about [max_tokens] tokens. If that limit is reached before the reply is finished, the person receives a cut-off response and has to start over. Composing an entire output or deliverable in full as reasoning and then again as a reply would double the length of the turn without improving the result, so don't do that.
Instead, when the person has asked for a long or effort-intensive deliverable such as a multi-section document, a large table or dataset, or a complete code file, spend extra effort on understanding the request, checking the inputs the answer depends on, settling the structure and other difficult decisions, and otherwise using the reasoning space to reason and the output space to write an output. Usually it is not needed to draft an output multiple times.
```
## 하위 에이전트 실행 중에도 리드 에이전트가 계속 작업하도록 하기
코딩 에이전트에서 Claude Fable 5.1이 "subagent"(하위 에이전트)에 작업을 위임할 수 있다면, "lead agent"(리드 에이전트)가 하위 에이전트마다 멈춰서 기다리도록 강제하지 마세요. 코딩 작업에서 하위 에이전트가 실행되는 동안 리드가 계속 작업하게 하면, 품질, 토큰 사용량, 비용은 비슷하게 유지하면서 평균 완료 시간을 줄일 수 있습니다. 설정 방법은 다음과 같습니다:
* 하위 에이전트를 시작하는 도구가 즉시 반환되도록 하세요.
* 각 하위 에이전트의 결과가 준비되면 이후의 `user` 메시지로 리드에 전달하세요.
* 리드가 결과를 기다리고 싶을 때 호출할 수 있는 별도의 도구를 제공하세요.
그래도 모델은 기다리는 쪽을 선택하는 경우가 많습니다. 시간 절약 효과는 모델이 기다리지 않고 다른 작업을 계속 진행한 실행에서 나옵니다.
## 비전 작업에 자르기 및 확대 도구 제공하기
Claude Fable 5.1은 별도 설정 없이도 향상된 비전 기능을 제공합니다. 밀도 높은 차트처럼 복잡한 시각적 입력에서는 보이는 내용을 반복적으로 분석하고, 잘라 보고, 시각적으로 검증할 수 있을 때 가장 좋은 결과를 냅니다. 이 이점을 최대한 활용하려면 원본 이미지나 동영상이 들어 있고 기본 이미지 처리 라이브러리(예: PIL, OpenCV)가 사전 설치된 컨테이너에 접근할 수 있는 에이전트로 모델을 실행하세요. 컨테이너 실행이 부담스럽다면 이미지 자르기 도구만으로도 성능 향상의 대부분을 얻을 수 있습니다. 이미지에서 선택한 영역을 잘라 확대해 반환하는 도구가 있으면 모델이 특정 세부 사항을 더 깊이 살펴볼 수 있고, 이미지 토큰에 비례해 "test-time compute"(테스트 시점 연산)를 늘릴 수 있습니다. [자르기 도구 레시피](https://platform.claude.com/cookbook/multimodal-crop-tool)에서 바로 사용할 수 있는 도구 정의를 확인하세요.