Claude Agent SDK 실전 빌드 가이드 — 첫 에이전트 만들기
Claude Agent SDK로 30분 안에 '릴리즈 노트 작성기' 에이전트를 만든다. gather context → take action → verify work → repeat 루프, Python 보일러플레이트, 도구 설계 원칙, 컨텍스트 관리 4종 세트를 단계별로 설명한다.
들어가며
Claude Code의 내부를 해체하면 무엇이 나올까. Anthropic이 공개한 답은 명확하다 — Claude Code는 Claude Agent SDK로 빌드됐다.1 CLI·웹·IDE 확장판 모두 같은 인프라 위에서 돌아간다. 즉, Claude Code를 능숙하게 쓸수록 SDK의 작동 원리도 이미 체감하고 있다는 뜻이다.
이 글은 그 원리를 코드로 꺼내는 최단 경로다. 목표는 하나: Python anthropic SDK로 릴리즈 노트 작성기 에이전트 한 사이클을 30분 안에 돌려보기. 코드는 실행 가능한 보일러플레이트 수준으로 제공한다.
이 글에서 다루는 것:
- Claude Code와 Agent SDK의 인프라 공유 관계
- 에이전트 루프 4단계: gather context → take action → verify work → repeat
- Python 최소 에이전트 골격 (시스템 프롬프트, 도구 화이트리스트, 권한 모드)
- 도구 설계 3원칙과 Bash 권한 분리 패턴
- 검증 단계에서 어떤 방법을 언제 쓰는가
- 컨텍스트 관리 4가지 도구
- 다음 단계: 커스텀 도메인 에이전트와 Claude Code Action 연계
관련 포스트를 함께 읽으면 이해 깊이가 달라진다:
- Claude Code 서브에이전트 설계 패턴 — 에이전트 분리 기준
- AI 코딩 에이전트 평가(Evals) — 회귀 탐지 방법
- CLAUDE.md · AGENTS.md 설계 패턴 — 컨텍스트 주입 구조
- 컨텍스트 엔지니어링 for AI Agents — 컨텍스트 윈도우 전략
- 클라우드·백그라운드 코딩 에이전트 2026 — 운용 모델 선택 기준
1. Claude Code와 Agent SDK — 같은 엔진, 다른 운전석
Claude Code는 단순한 AI 채팅 인터페이스가 아니다. 터미널·파일 시스템·git·MCP 서버를 직접 다루는 자율 에이전트 런타임이다. Anthropic은 이 런타임의 핵심을 Claude Agent SDK로 추출해 외부에 공개했다.
인프라 공유가 의미하는 것은 세 가지다.
첫째, 동일한 에이전트 루프. Claude Code가 파일을 읽고, 수정하고, 결과를 검증하는 방식이 SDK의 agent.run() 내부와 구조적으로 동일하다. Claude Code의 동작을 이해한다면 SDK로 만든 에이전트의 동작도 예측할 수 있다.
둘째, 동일한 도구 추상화. Claude Code에서 Bash, Read, Write, Agent 도구가 작동하는 방식 — 허용 목록, 권한 확인, 부작용 가시화 — 이 SDK의 도구 인터페이스와 맞닿아 있다.
셋째, 동일한 컨텍스트 전략. Claude Code가 대형 저장소를 탐색하거나, 서브에이전트에게 작업을 위임하거나, 컨텍스트가 꽉 차면 요약(compaction)하는 방식이 SDK 레벨에서도 적용된다.
Claude Code를 잘 쓴다는 것은 Agent SDK의 동작 모델을 이미 체득했다는 것이다. SDK 빌드는 그 체득을 코드로 외재화하는 작업이다.
2. 에이전트 루프 — 4단계 사이클
에이전트를 빌드하기 전에 루프 구조를 명확히 잡아야 한다. Anthropic Engineering 블로그는 에이전트 루프를 네 단계로 정의한다.2
flowchart LR
A([시작]) --> GC
subgraph loop [" 에이전트 루프 "]
direction LR
GC["📥 Gather Context\n컨텍스트 수집"]
TA["⚡ Take Action\n액션 실행"]
VW["✅ Verify Work\n결과 검증"]
RP["🔁 Repeat\n반복 판단"]
GC --> TA --> VW --> RP
RP -- "미완료" --> GC
end
RP -- "완료" --> END([종료])
Gather Context — 무엇을 알아야 하는가
에이전트가 첫 번째로 하는 일은 현재 상태를 파악하는 것이다. 릴리즈 노트 작성기라면:
git log --oneline v1.2.2..HEAD로 커밋 목록 획득- 기존
CHANGELOG.md읽어 포맷 파악 - 태그된 마일스톤 혹은 이슈 참조 확인
이 단계의 핵심은 필요한 것만 읽는다는 것이다. 전체 저장소를 불러오는 것은 컨텍스트 낭비다. 에이전트는 목적에 맞는 탐색 전략을 가져야 한다.
Take Action — 무엇을 할 것인가
컨텍스트가 충분하면 에이전트는 도구를 호출한다. 릴리즈 노트 작성기는:
- 커밋 메시지를 카테고리별로 분류 (feat, fix, chore 등)
- 마크다운으로 포맷 생성
CHANGELOG.md에 섹션 추가
도구 호출은 최소 단위로 쪼개야 한다. 하나의 도구 호출이 실패해도 이전 단계는 살릴 수 있어야 한다.
Verify Work — 결과가 맞는가
액션 실행 후 에이전트는 스스로 결과를 검증한다:
- 파일이 실제로 생성됐는지 확인
- 포맷이 올바른지 확인
- 누락된 커밋은 없는지 확인
검증 실패 시 루프를 돌아 재시도한다.
Repeat — 언제 멈추는가
종료 조건이 명확해야 루프가 무한히 돌지 않는다. 릴리즈 노트 작성기의 경우:
- 지정 버전 범위의 커밋이 모두 포함됐을 때
- 파일 저장이 확인됐을 때
- 최대 반복 횟수 초과 시 (안전장치)
3. Python 보일러플레이트 — 릴리즈 노트 작성기
이제 코드로 옮긴다. 아래는 anthropic Python SDK를 사용하는 최소 구현이다.
설치
1
pip install anthropic
시스템 프롬프트 정의
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
SYSTEM_PROMPT = """
당신은 릴리즈 노트를 작성하는 에이전트입니다.
역할:
- git log를 읽어 커밋을 카테고리별로 분류한다
- 마크다운 CHANGELOG 포맷으로 정리한다
- CHANGELOG.md 파일에 새 섹션을 추가한다
분류 규칙:
- feat: 새 기능 → ## ✨ New Features
- fix: 버그 수정 → ## 🐛 Bug Fixes
- chore/refactor: 내부 정리 → ## 🔧 Internal Changes
- docs: 문서 업데이트 → ## 📚 Documentation
규칙:
- 이미 존재하는 섹션에 덮어쓰지 않는다
- 커밋 해시를 항상 포함한다
- 작업이 완료되면 "DONE" 한 단어를 출력하고 멈춘다
"""
에이전트 루프 구현
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
import anthropic
import subprocess
import json
client = anthropic.Anthropic()
# 도구 정의 — 화이트리스트 기반
tools = [
{
"name": "run_git_log",
"description": "지정한 태그 범위의 git 커밋 로그를 조회한다",
"input_schema": {
"type": "object",
"properties": {
"from_tag": {
"type": "string",
"description": "시작 태그 (예: v1.2.2). 생략 시 처음부터"
},
"to_ref": {
"type": "string",
"description": "끝 참조 (기본값: HEAD)"
}
},
"required": []
}
},
{
"name": "read_file",
"description": "파일 내용을 읽는다",
"input_schema": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "읽을 파일 경로"}
},
"required": ["path"]
}
},
{
"name": "write_changelog_section",
"description": "CHANGELOG.md 파일의 맨 위에 새 버전 섹션을 삽입한다",
"input_schema": {
"type": "object",
"properties": {
"version": {"type": "string", "description": "버전 문자열 (예: v1.2.3)"},
"content": {"type": "string", "description": "삽입할 마크다운 섹션 내용"}
},
"required": ["version", "content"]
}
}
]
def execute_tool(tool_name: str, tool_input: dict) -> str:
"""도구 실행 — 각 도구는 부작용이 명시적이다"""
if tool_name == "run_git_log":
from_tag = tool_input.get("from_tag", "")
to_ref = tool_input.get("to_ref", "HEAD")
range_arg = f"{from_tag}..{to_ref}" if from_tag else to_ref
result = subprocess.run(
["git", "log", "--oneline", "--no-merges", range_arg],
capture_output=True, text=True, timeout=10
)
return result.stdout or "(커밋 없음)"
elif tool_name == "read_file":
path = tool_input["path"]
try:
with open(path, "r", encoding="utf-8") as f:
return f.read()
except FileNotFoundError:
return "(파일 없음 — 신규 생성 가능)"
elif tool_name == "write_changelog_section":
version = tool_input["version"]
content = tool_input["content"]
changelog_path = "CHANGELOG.md"
try:
with open(changelog_path, "r", encoding="utf-8") as f:
existing = f.read()
except FileNotFoundError:
existing = ""
new_section = f"# {version}\n\n{content}\n\n---\n\n"
with open(changelog_path, "w", encoding="utf-8") as f:
f.write(new_section + existing)
return f"CHANGELOG.md 업데이트 완료 — {version} 섹션 추가"
return f"알 수 없는 도구: {tool_name}"
def run_release_notes_agent(version: str, from_tag: str = "") -> str:
"""에이전트 루프 실행"""
messages = [
{
"role": "user",
"content": f"{version} 릴리즈 노트를 작성하라. 이전 태그: {from_tag or '없음'}"
}
]
max_iterations = 10 # 안전 상한
for iteration in range(max_iterations):
response = client.messages.create(
model="claude-opus-4-7",
max_tokens=4096,
system=SYSTEM_PROMPT,
tools=tools,
messages=messages,
)
# 어시스턴트 응답을 메시지 히스토리에 추가
messages.append({"role": "assistant", "content": response.content})
# 종료 조건 확인
if response.stop_reason == "end_turn":
final_text = next(
(b.text for b in response.content if hasattr(b, "text")), ""
)
if "DONE" in final_text:
return f"완료 (반복 {iteration + 1}회)"
return final_text
# 도구 호출 처리
if response.stop_reason == "tool_use":
tool_results = []
for block in response.content:
if block.type == "tool_use":
result = execute_tool(block.name, block.input)
tool_results.append({
"type": "tool_result",
"tool_use_id": block.id,
"content": result,
})
messages.append({"role": "user", "content": tool_results})
return "최대 반복 횟수 초과"
if __name__ == "__main__":
outcome = run_release_notes_agent(version="v1.3.0", from_tag="v1.2.2")
print(outcome)
위 코드는 실행 가능한 최소 골격이다. 프로덕션 환경에서는 오류 처리, 로깅, 타임아웃 정책을 보강해야 한다.
핵심 파라미터 해설
| 파라미터 | 역할 | 릴리즈 노트 예시 |
|---|---|---|
system | 에이전트 정체성·규칙 정의 | 분류 규칙, 포맷, 종료 조건 |
tools | 허용 도구 화이트리스트 | git log, 파일 읽기, changelog 쓰기 |
max_iterations | 루프 안전 상한 | 10회 (무한 루프 방지) |
stop_reason | 루프 종료 신호 | end_turn 또는 tool_use |
4. 도구 설계 원칙 — 세 가지 규칙
에이전트가 잘못 작동할 때 가장 많은 원인이 도구 설계 실수다. 세 가지 원칙을 지키면 대부분의 문제를 예방한다.
원칙 1: 재사용성 — 도구는 목적이 아니라 능력을 표현한다
나쁜 예:
1
2
# 너무 구체적 — 이 에이전트에서만 쓸 수 있다
{"name": "write_v1_3_0_changelog", ...}
좋은 예:
1
2
# 재사용 가능 — 어떤 버전에도 쓸 수 있다
{"name": "write_changelog_section", ...}
도구 이름에 비즈니스 로직이 들어가면 에이전트가 도구의 적용 범위를 과도하게 제한한다.
원칙 2: 명시성 — 입력·출력이 명확해야 한다
에이전트는 도구의 description과 input_schema를 읽고 언제, 어떻게 호출할지 판단한다. 설명이 모호하면 에이전트는 잘못된 시점에 잘못된 인자로 도구를 호출한다.
1
2
3
4
5
# 모호한 설명 — 에이전트가 혼란스럽다
"description": "git을 실행한다"
# 명시적 설명 — 에이전트가 정확하게 판단한다
"description": "지정한 태그 범위의 git 커밋 로그를 한 줄씩 조회한다. 범위가 없으면 전체 히스토리를 반환한다."
원칙 3: 부작용 가시성 — 상태 변경 도구는 명확히 구분한다
읽기 전용 도구와 상태 변경 도구를 이름과 설명에서 구분한다:
read_*: 부작용 없음write_*/update_*/delete_*: 상태 변경
이 규칙은 에이전트가 스스로 “지금 무언가를 영구적으로 바꾸려 한다”는 것을 인식하게 만든다.
Bash 권한 분리 패턴
범용 bash 도구를 그대로 노출하는 것은 위험하다. 에이전트가 의도치 않은 명령을 실행할 수 있다. 대신 명령 화이트리스트 래퍼를 쓴다:
1
2
3
4
5
6
7
8
9
ALLOWED_COMMANDS = {"git", "cat", "echo", "ls"}
def safe_bash(command: str) -> str:
"""허용 명령어 집합으로 제한된 Bash 실행"""
parts = command.strip().split()
if not parts or parts[0] not in ALLOWED_COMMANDS:
return f"오류: '{parts[0]}' 명령은 허용되지 않습니다. 허용 목록: {ALLOWED_COMMANDS}"
result = subprocess.run(parts, capture_output=True, text=True, timeout=15)
return result.stdout + result.stderr
이 패턴은 Claude Code가 Bash(git log *) 같이 명령별 화이트리스트를 --allowedTools 로 제한하는 방식과 동일한 철학이다.
5. 검증 단계 — 무엇으로 검증할 것인가
에이전트 루프에서 Verify Work 단계는 세 가지 방법 중 하나 이상을 조합해 구현한다.
방법 1: Defining Rules — 규칙 기반 검증
결과물이 만족해야 할 조건을 코드로 명시한다. 명확한 기준이 있는 경우에 적합하다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def verify_changelog(version: str) -> tuple[bool, str]:
"""규칙 기반 검증 — 결정론적"""
with open("CHANGELOG.md", "r") as f:
content = f.read()
checks = [
(f"# {version}" in content, f"버전 헤더 누락: {version}"),
("## ✨ New Features" in content or "## 🐛 Bug Fixes" in content,
"카테고리 섹션 누락"),
(len(content.split("\n")) > 5, "내용이 너무 짧음"),
]
failures = [msg for passed, msg in checks if not passed]
return (len(failures) == 0), "\n".join(failures)
언제 쓰는가: 포맷 준수, 파일 존재 여부, 필수 섹션 포함 등 이진 판단이 가능한 경우.
방법 2: Visual Feedback — 시각적 검증
에이전트가 생성한 산출물을 사람이 직접 확인하거나, 렌더링 결과를 캡처해 피드백한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
def preview_changelog(version: str) -> None:
"""생성된 CHANGELOG 섹션 미리보기 출력"""
with open("CHANGELOG.md", "r") as f:
lines = f.readlines()
in_section = False
for line in lines:
if line.startswith(f"# {version}"):
in_section = True
elif line.startswith("# ") and in_section:
break
if in_section:
print(line, end="")
언제 쓰는가: 마크다운 렌더링, UI 스냅샷, 레이아웃처럼 코드로 완전히 검증하기 어려운 경우.
방법 3: LLM-as-Judge — 모델 기반 검증
다른 Claude 인스턴스가 결과물을 평가한다. Anthropic의 evals 프레임워크가 권장하는 방식이다.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def llm_judge_changelog(version: str, generated_content: str) -> dict:
"""LLM을 이용한 품질 평가"""
judge_prompt = f"""
다음 CHANGELOG 섹션을 평가하라.
버전: {version}
내용:
{generated_content}
평가 기준:
1. 커밋이 올바르게 카테고리화됐는가 (0~10점)
2. 사용자가 읽기 쉬운가 (0~10점)
3. 커밋 해시가 포함됐는가 (0~10점)
JSON으로 응답: category_score
"""
response = client.messages.create(
model="claude-haiku-4-5-20251001", # 검증에는 빠른 모델
max_tokens=512,
messages=[{"role": "user", "content": judge_prompt}]
)
import json
return json.loads(response.content[0].text)
언제 쓰는가: 문체, 명확성, 의미론적 완성도처럼 규칙으로 코드화하기 어려운 품질을 측정할 때. 단, LLM-as-Judge는 비용이 들고 비결정론적이므로 규칙 기반 검증을 통과한 후 보조적으로 사용한다.
검증 전략의 우선순위: Defining Rules → Visual Feedback → LLM-as-Judge 순으로 적용하라. 앞 단계에서 잡을 수 있는 오류를 비싼 LLM 호출에 맡기지 않는다.
6. 컨텍스트 관리 — 4가지 도구
에이전트가 긴 작업을 수행할수록 컨텍스트 윈도우를 어떻게 관리하는가가 품질과 비용을 결정한다. Anthropic은 4가지 도구를 제시한다.4
1. Agentic Search — 필요한 것만 탐색
전체 파일 트리를 컨텍스트에 올리지 않는다. 에이전트가 목적에 맞는 탐색 전략을 갖도록 설계한다.
1
2
3
4
5
6
# 나쁜 예 — 전체 저장소를 context에 올림
{"name": "read_entire_repo", ...}
# 좋은 예 — 목적에 맞는 탐색
{"name": "search_commits_by_keyword",
"description": "키워드로 커밋 메시지를 검색한다", ...}
릴리즈 노트 에이전트는 전체 저장소 대신 git log와 CHANGELOG.md만 읽는다.
2. Semantic Search — 의미 기반 탐색
대형 코드베이스에서 관련 파일을 찾을 때는 파일 트리 순회 대신 임베딩 기반 유사도 검색을 쓴다.
1
2
3
4
5
6
# 개념적 예시 — 실제 구현은 벡터 DB와 연동
def semantic_search_codebase(query: str, top_k: int = 5) -> list[str]:
"""의미적으로 관련된 파일 경로 반환"""
# embeddings = embed(query)
# return vector_db.search(embeddings, top_k=top_k)
...
Claude Code의 코드베이스 탐색이 내부적으로 이 전략을 활용한다.
3. Subagents — 컨텍스트 격리
독립적인 서브태스크는 별도 에이전트 인스턴스에 위임한다. 각 서브에이전트는 자신의 컨텍스트 윈도우를 사용하므로 부모 에이전트의 컨텍스트가 오염되지 않는다.
1
2
3
4
5
6
7
8
9
def run_with_subagent(task: str) -> str:
"""서브에이전트 위임 패턴"""
response = client.messages.create(
model="claude-haiku-4-5-20251001",
max_tokens=1024,
system="주어진 태스크를 완료하고 결과만 반환한다.",
messages=[{"role": "user", "content": task}]
)
return response.content[0].text
자세한 서브에이전트 분리 기준은 서브에이전트 설계 패턴 포스트에서 다룬다.
4. Compaction — 컨텍스트 압축
긴 대화 히스토리가 쌓이면 오래된 메시지를 요약으로 교체한다. Claude Code는 컨텍스트가 차오르면 자동 compaction을 실행한다. SDK에서는 이 동작을 명시적으로 구현해야 한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def compact_messages(messages: list[dict], keep_last: int = 6) -> list[dict]:
"""오래된 메시지를 요약으로 교체"""
if len(messages) <= keep_last:
return messages
old_messages = messages[:-keep_last]
summary_text = "\n".join(
f"[{m['role']}]: {str(m['content'])[:200]}"
for m in old_messages
)
summary_response = client.messages.create(
model="claude-haiku-4-5-20251001",
max_tokens=512,
messages=[{
"role": "user",
"content": f"다음 대화를 한 문단으로 요약하라:\n{summary_text}"
}]
)
summary_msg = {
"role": "user",
"content": f"[이전 대화 요약] {summary_response.content[0].text}"
}
return [summary_msg] + messages[-keep_last:]
7. 전체 흐름 다시 보기
릴리즈 노트 작성기를 기준으로 전체 흐름을 정리한다.
sequenceDiagram
participant U as 사용자
participant A as 에이전트 루프
participant T as 도구 실행
participant V as 검증
U->>A: run_release_notes_agent("v1.3.0", "v1.2.2")
loop 에이전트 루프 (최대 10회)
A->>T: run_git_log(from_tag="v1.2.2")
T-->>A: 커밋 목록 반환
A->>T: read_file("CHANGELOG.md")
T-->>A: 기존 파일 내용
A->>T: write_changelog_section(version, content)
T-->>A: 저장 완료
A->>V: verify_changelog("v1.3.0")
V-->>A: 검증 통과
A-->>A: stop_reason == end_turn → DONE
end
A-->>U: "완료 (반복 3회)"
8. 다음 단계 — 커스텀 도메인과 Claude Code Action
릴리즈 노트 작성기는 SDK의 가장 단순한 활용이다. 실제로는 더 넓은 도메인으로 확장할 수 있다.
커스텀 도메인 에이전트
에이전트 루프는 소프트웨어 개발 외 모든 반복·검증 작업에 적용된다:
| 도메인 | Gather Context | Take Action | Verify |
|---|---|---|---|
| 코드 리뷰 | diff 읽기 | 리뷰 댓글 생성 | 규칙 체크 |
| 인프라 감사 | terraform state 읽기 | 보고서 생성 | 정책 검증 |
| 문서 동기화 | 코드·docs 비교 | docs 업데이트 | 링크 검증 |
| 의존성 관리 | package.json 읽기 | 업그레이드 PR 생성 | CI 통과 확인 |
Claude Code Action 연계
Claude Code는 GitHub Actions를 통해 Claude Agent SDK 기반 에이전트를 CI/CD에 직접 연결한다.5 @claude 멘션만으로 PR에서 에이전트를 실행하고, 이 글에서 만든 패턴이 그대로 사용된다:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# .github/workflows/release-notes.yml
on:
push:
tags: ['v*']
jobs:
release-notes:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: anthropics/claude-code-action@v1
with:
prompt: "이 태그 버전의 릴리즈 노트를 작성하고 CHANGELOG.md를 업데이트하라"
allowed_tools: "Bash,Read,Write"
Claude Code Action이 내부적으로 에이전트 루프를 실행하고, 허용 도구 제한, 검증, 종료 조건 판단이 이 글에서 구현한 패턴과 구조적으로 동일하다.
SDK로 에이전트를 직접 빌드하면 Claude Code와 Claude Code Action의 동작 원리가 투명해진다. 블랙박스를 직접 만들어보는 것이 가장 빠른 이해 경로다.
마치며
Claude Agent SDK의 핵심은 루프다. Gather → Act → Verify → Repeat 네 단계가 반복될 수 있도록 도구, 검증, 종료 조건을 올바르게 설계하는 것이 에이전트 빌드의 90%를 차지한다.
이 글에서 다룬 릴리즈 노트 작성기는 그 패턴을 한 곳에서 볼 수 있는 가장 단순한 예다. 여기서 도구만 교체하면 코드 리뷰어, 의존성 감사자, 문서 동기화 에이전트를 동일한 뼈대로 만들 수 있다.
다음 단계로 추천하는 읽을거리:
- AI 코딩 에이전트 평가(Evals) — 에이전트 회귀를 측정하는 방법
- 컨텍스트 엔지니어링 for AI Agents — 컨텍스트 윈도우를 전략적으로 사용하는 방법
- CLAUDE.md · AGENTS.md 설계 패턴 — 에이전트에게 주는 지시를 구조화하는 방법
참고
Anthropic, “Building agents with the Claude Agent SDK”, 2025-09-29. https://claude.com/blog/building-agents-with-the-claude-agent-sdk. Claude Code는 이 SDK를 기반으로 빌드됐으며, 동일한 에이전트 인프라(컨텍스트 관리·도구 시스템·권한)를 공유한다. ↩︎
Anthropic, “Building agents with the Claude Agent SDK”, 2025-09-29. https://claude.com/blog/building-agents-with-the-claude-agent-sdk. “Building Your Agent Loop” 섹션이 gather context → take action → verify work → repeat 4단계 루프를 정의한다. ↩︎
Anthropic, “Building agents with the Claude Agent SDK”, 2025-09-29. https://claude.com/blog/building-agents-with-the-claude-agent-sdk. “Verify Your Work” 섹션이 “defining rules”, “visual feedback”, “LLM as a judge” 세 가지 검증 방법을 제시한다. ↩︎
Anthropic, “Building agents with the Claude Agent SDK”, 2025-09-29. https://claude.com/blog/building-agents-with-the-claude-agent-sdk. “Gather Context” 항이 agentic search · semantic search · subagents · context compaction 4가지 전략을 설명한다. ↩︎
Anthropic, Claude Code GitHub Actions 공식 문서. https://code.claude.com/docs/en/github-actions.
anthropics/claude-code-actionv1.0(2025-08-26)은 Claude Agent SDK 위에 구축됐다. 저장소: https://github.com/anthropics/claude-code-action. ↩︎