반응형
Claude Code에 프롬프트를 입력하면 그 뒤에서 무슨 일이 일어날까요? 단순히 "AI가 답변한다"가 아닙니다. 세션 초기화, 컨텍스트 로딩, 에이전틱 루프, 도구 실행, 컴팩션까지 — 정교한 생명주기가 작동하고 있습니다. 이 글에서는 Claude Code의 전체 생명주기를 처음부터 끝까지 해부합니다.
1. 전체 생명주기 한눈에 보기
Claude Code의 생명주기는 크게 5단계로 구분할 수 있습니다.
┌─────────────────────────────────────────────────────────────┐
│ Claude Code 전체 생명주기 │
│ │
│ ① 세션 시작 ─→ ② 컨텍스트 로딩 ─→ ③ 에이전틱 루프 │
│ │ │
│ ▼ │
│ ┌──────────┐ │
│ │컨텍스트가 │ ④ 컴팩션 │
│ │가득 찼나? │──→ (요약 후 │
│ └────┬─────┘ 루프 계속) │
│ │ No │
│ ▼ │
│ ⑤ 세션 종료 │
└─────────────────────────────────────────────────────────────┘
각 단계를 자세히 살펴보겠습니다.
2. 1단계: 세션 시작 (Session Start)
claude 명령을 실행하면 세션이 시작됩니다. 이 시점에서 여러 가지 초기화가 일어납니다.
┌────────────────────────────────────────────────────────┐
│ 세션 시작 시 발생하는 일 │
│ │
│ 1. 세션 ID 생성 │
│ └─ 대화 기록 저장, 재개/포크의 기준점 │
│ │
│ 2. 실행 환경 감지 │
│ └─ 작업 디렉토리, 플랫폼, 셸, OS, Git 상태 │
│ │
│ 3. 인증 확인 │
│ └─ API 키 또는 OAuth 토큰 검증 │
│ │
│ 4. SessionStart 훅 실행 │
│ └─ 환경 변수 설정, 컨텍스트 주입 등 │
│ │
│ 5. 컨텍스트 윈도우 초기화 │
│ └─ 다음 단계(컨텍스트 로딩)로 진행 │
└────────────────────────────────────────────────────────┘
세션의 특성
- 세션은 독립적: 새 세션은 이전 대화 기록 없이 시작됩니다
- 디렉토리에 연결: 현재 디렉토리 기준으로 세션이 생성되며, 재개 시에도 같은 디렉토리의 세션만 표시됩니다
- 브랜치 전환 가능: Git 브랜치를 전환하면 새 브랜치의 파일이 보이지만 대화 기록은 유지됩니다
세션 재개와 포크
┌─────────────────────────────────────────┐
│ 세션 연속성 │
│ │
│ --continue / --resume │
│ └─ 기존 세션 ID 유지 │
│ └─ 대화 기록 복원 │
│ └─ 세션 범위 권한은 재승인 필요 │
│ │
│ --fork-session │
│ └─ 새 세션 ID 생성 │
│ └─ 대화 기록은 복사 │
│ └─ 원본 세션 영향 없음 │
└─────────────────────────────────────────┘
3. 2단계: 컨텍스트 로딩 — 200K 토큰의 구성
세션이 시작되면 컨텍스트 윈도우에 다양한 정보가 순서대로 로딩됩니다. Claude Code의 컨텍스트 윈도우는 200,000 토큰이며, 무엇이 어떤 순서로 얼마나 차지하는지 이해하는 것이 핵심입니다.
┌─────────────────────────────────────────────────────────┐
│ 컨텍스트 윈도우 로딩 순서 (200K 토큰) │
│ │
│ ▼ 자동 로딩 (세션 시작 즉시) │
│ ┌──────────────────────────────────────────────────┐ │
│ │ 1. 시스템 프롬프트 ~4,200 토큰 ███░░░ │ │
│ │ 행동, 도구 사용, 응답 형식 핵심 지침 │ │
│ │ (사용자에게 보이지 않음) │ │
│ │ │ │
│ │ 2. Auto Memory (MEMORY.md) ~680 토큰 ░░░░░ │ │
│ │ 이전 세션에서 학습한 패턴, 빌드 명령 등 │ │
│ │ (첫 200줄 또는 25KB 중 먼저 도달하는 것) │ │
│ │ │ │
│ │ 3. 환경 정보 ~280 토큰 ░░░░░ │ │
│ │ 작업 디렉토리, 플랫폼, 셸, OS, Git 상태 │ │
│ │ │ │
│ │ 4. MCP 도구 (지연 로딩) ~120 토큰 ░░░░░ │ │
│ │ 도구 이름만 로딩, 스키마는 사용 시 로딩 │ │
│ │ │ │
│ │ 5. 스킬 설명 ~450 토큰 ░░░░░ │ │
│ │ 한 줄 요약만 로딩, 전체 내용은 사용 시 로딩 │ │
│ │ ※ 컴팩션 후 재주입되지 않음 │ │
│ │ │ │
│ │ 6. ~/.claude/CLAUDE.md ~320 토큰 ░░░░░ │ │
│ │ 전역 사용자 환경설정 │ │
│ │ │ │
│ │ 7. 프로젝트 CLAUDE.md ~1,800 토큰 █░░░░ │ │
│ │ 프로젝트 컨벤션, 빌드 명령, 아키텍처 참고 │ │
│ └──────────────────────────────────────────────────┘ │
│ │
│ ▼ 사용자 프롬프트 ~45 토큰 │
│ │
│ ▼ 에이전틱 루프에서 누적 (아래 3단계) │
│ - 파일 읽기, 검색 결과, 명령어 출력 │
│ - Claude의 분석과 응답 │
│ - 경로 매칭 규칙 (.claude/rules/) │
│ - 훅 출력 │
│ - 스킬 전체 내용 (사용 시) │
│ │
│ ═══════════════════════════════════════════ │
│ 합계: ~7,900 토큰이 시작 시 소비 │
│ 나머지 ~192,000 토큰이 작업에 사용 가능 │
└─────────────────────────────────────────────────────────┘
프롬프트 캐싱의 역할
매 턴마다 동일한 내용(시스템 프롬프트, 도구 정의, CLAUDE.md)은 자동으로 프롬프트 캐싱됩니다. 첫 요청만 전체 비용을 지불하고, 이후 턴에서는 캐시된 프리픽스 덕분에 비용과 지연 시간이 줄어듭니다.
지연 로딩(Lazy Loading) 전략
모든 것을 처음에 로딩하지 않습니다:
- MCP 도구: 이름만 로딩하고, 실제 스키마는 Claude가 해당 도구를 사용할 때 로딩
- 스킬: 한 줄 설명만 로딩하고, 전체 내용은 스킬 호출 시 로딩
- 경로 기반 규칙:
.claude/rules/의 파일은 해당 경로의 파일을 읽을 때 자동 로딩
이 전략 덕분에 컨텍스트 윈도우를 효율적으로 사용할 수 있습니다.
4. 3단계: 에이전틱 루프 — 핵심 실행 엔진
에이전틱 루프는 Claude Code의 심장입니다. 컨텍스트 수집 → 행동 → 검증의 세 단계가 작업 완료까지 반복됩니다.
┌─────────────────────────────────────────────────────────┐
│ 에이전틱 루프 상세 흐름 │
│ │
│ 사용자 프롬프트 │
│ │ │
│ ▼ │
│ ┌────────────────┐ │
│ │ Claude 추론 │ │
│ │ (모델 평가) │ ← 컨텍스트 전체 참조 │
│ └───────┬────────┘ │
│ │ │
│ ┌────────┴────────┐ │
│ │ │ │
│ ▼ ▼ │
│ 도구 호출 있음 도구 호출 없음 │
│ │ │ │
│ ▼ ▼ │
│ ┌──────────────┐ 최종 텍스트 응답 │
│ │ PreToolUse │ │ │
│ │ 훅 실행 │ ▼ │
│ └──────┬───────┘ ┌──────────┐ │
│ 허용? │ │ Stop │ │
│ ┌─────┼─────┐ │ 훅 실행 │ │
│ │ │ │ └──────────┘ │
│ 차단 허용 사용자 │
│ │ │ 확인 │
│ ▼ ▼ │ │
│ 피드백 도구 ┌┘ │
│ 전달 실행 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────────┐ │
│ │ │ PostToolUse │ │
│ │ │ 훅 실행 │ │
│ │ └──────┬───────┘ │
│ │ │ │
│ └─────────┘ │
│ │ │
│ ▼ │
│ 결과가 컨텍스트에 추가 │
│ │ │
│ └──────→ Claude 추론으로 돌아감 (반복) │
│ │
└─────────────────────────────────────────────────────────┘
320x100
턴(Turn)의 정의
하나의 턴 = Claude가 도구를 호출하고, 도구가 실행되고, 결과가 돌아오는 한 번의 왕복입니다. 간단한 질문은 1~2턴, 복잡한 리팩토링은 수십 턴이 소요됩니다.
실제 예시: "auth 모듈의 실패하는 테스트를 고쳐줘"
┌────────────────────────────────────────────────────────┐
│ 실제 에이전틱 루프 예시 │
│ │
│ 턴 1: 컨텍스트 수집 │
│ ├─ Claude: Bash 도구로 npm test 실행 │
│ ├─ 결과: 3개 테스트 실패 → 컨텍스트에 추가 │
│ │ (+600 토큰) │
│ │ │
│ 턴 2: 더 깊은 이해 │
│ ├─ Claude: Read로 auth.ts 읽기 (+2,400 토큰) │
│ ├─ Claude: Read로 auth.test.ts 읽기 (+1,600 토큰) │
│ ├─ .claude/rules/api-conventions.md 자동 로딩 │
│ │ (경로 매칭으로 트리거, +380 토큰) │
│ │ │
│ 턴 3: 행동 │
│ ├─ Claude: Edit로 auth.ts 수정 (+400 토큰) │
│ ├─ PostToolUse 훅: prettier 자동 실행 (+120 토큰) │
│ ├─ Claude: Edit로 auth.test.ts 수정 (+600 토큰) │
│ ├─ PostToolUse 훅: prettier 자동 실행 (+100 토큰) │
│ │ │
│ 턴 4: 검증 │
│ ├─ Claude: Bash로 npm test 재실행 │
│ ├─ 결과: 모든 테스트 통과 (+300 토큰) │
│ │ │
│ 최종 턴: 텍스트 응답 (도구 호출 없음) │
│ └─ "auth 버그를 수정했습니다. 3개 테스트 모두 통과." │
│ │
│ 총 소비: ~6,500 토큰 (4턴 + 최종 응답) │
└────────────────────────────────────────────────────────┘
도구 실행의 병렬성
Claude가 한 턴에서 여러 도구를 요청하면:
- 읽기 전용 도구 (Read, Glob, Grep, 읽기 전용 MCP): 병렬 실행
- 상태 변경 도구 (Edit, Write, Bash): 순차 실행 (충돌 방지)
5가지 도구 카테고리
┌─────────────────────────────────────────────────────┐
│ Claude Code 내장 도구 카테고리 │
│ │
│ 파일 조작 Read, Edit, Write │
│ ─────────── 파일 읽기, 코드 수정, 새 파일 생성 │
│ │
│ 검색 Glob, Grep │
│ ──────── 패턴으로 파일 찾기, 정규식으로 내용 검색 │
│ │
│ 실행 Bash │
│ ──────── 셸 명령, 서버 실행, 테스트, git 조작 │
│ │
│ 웹 WebSearch, WebFetch │
│ ──────── 웹 검색, 문서 가져오기, 에러 메시지 조회 │
│ │
│ 오케스트레이션 Agent, Skill, AskUserQuestion │
│ ───────────── 서브에이전트, 스킬 호출, 사용자 질문 │
└─────────────────────────────────────────────────────┘
5. 4단계: 컴팩션 — 컨텍스트가 가득 찰 때
에이전틱 루프가 반복되면서 컨텍스트 윈도우는 계속 채워집니다. 약 95% 용량(또는 25% 남은 시점)에 도달하면 자동 컴팩션이 트리거됩니다.
┌─────────────────────────────────────────────────────────┐
│ 컴팩션 프로세스 상세 │
│ │
│ 컨텍스트 윈도우 상태 (200K 토큰) │
│ │
│ ████████████████████████████████████████████░░░░░░ │
│ ← 사용 중: ~170K ────────────────→│← 남은: ~30K →│ │
│ │ │ │
│ 컴팩션 트리거! │ │
│ │ │ │
│ ▼ │ │
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ PreCompact 훅 실행 │ │
│ │ (전체 트랜스크립트 아카이브 등) │ │
│ └──────────────────┬──────────────────────────┘ │
│ ▼ │
│ ┌─────────────────────────────────────────────┐ │
│ │ 컴팩션 실행 │ │
│ │ │ │
│ │ 1단계: 오래된 도구 출력 먼저 제거 │ │
│ │ │ │
│ │ 2단계: 대화 기록 요약 │ │
│ │ - 최근 교환과 핵심 코드 스니펫 보존 │ │
│ │ - 오래된 대화를 간결한 요약으로 대체 │ │
│ │ - ~33K 토큰의 버퍼를 요약 과정 자체에 사용 │ │
│ │ │ │
│ │ 3단계: 시작 컨텍스트 재주입 │ │
│ │ - 시스템 프롬프트 ✅ │ │
│ │ - CLAUDE.md ✅ │ │
│ │ - Auto Memory ✅ │ │
│ │ - 스킬 설명 ❌ (재주입되지 않음!) │ │
│ │ - 사용한 스킬만 보존 ✅ │ │
│ └──────────────────┬──────────────────────────┘ │
│ ▼ │
│ ┌─────────────────────────────────────────────┐ │
│ │ PostCompact 훅 실행 │ │
│ │ SessionStart(compact) 훅으로 컨텍스트 재주입 │ │
│ └─────────────────────────────────────────────┘ │
│ │
│ ██████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │
│ ← 요약: ~60K →│← 새로 확보된 공간: ~140K ────→│ │
│ │
│ 에이전틱 루프 계속 → │
└─────────────────────────────────────────────────────────┘
컴팩션에서 손실되는 것
- 대화 초반의 상세한 지침
- 스킬 설명 목록 (사용한 스킬만 보존)
- 이전 도구 실행의 상세 출력
컴팩션에서 보존되는 것
- 최근 교환 내용
- 핵심 코드 스니펫
- CLAUDE.md의 모든 내용 (매 요청마다 재주입)
- 주요 결정 사항과 그 이유
컴팩션 대응 전략
CLAUDE.md에 "요약 지침" 섹션 추가:
# Summary Instructions
대화를 요약할 때 항상 다음을 보존하세요:
- 현재 작업 목표와 수용 기준
- 읽거나 수정한 파일 경로
- 테스트 결과와 에러 메시지
- 결정 사항과 그 이유
수동 컴팩션으로 초점 지정:
/compact API 변경 사항에 집중해서 요약해줘
/context 명령으로 현재 상태 확인
6. 5단계: 세션 종료 (Session End)
Claude가 도구 호출 없이 텍스트만 응답하면 에이전틱 루프가 종료됩니다.
┌─────────────────────────────────────────────────────┐
│ 세션 종료 과정 │
│ │
│ Claude의 최종 텍스트 응답 │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ Stop 훅 │──→ "아직 안 끝났어" │
│ │ 실행 │ → Claude 작업 계속 (차단) │
│ └──────┬───────┘ │
│ │ 통과 │
│ ▼ │
│ ┌──────────────┐ │
│ │ 결과 반환 │ │
│ │ - 최종 텍스트│ │
│ │ - 토큰 사용량│ │
│ │ - 비용 │ │
│ │ - 세션 ID │ │
│ └──────┬───────┘ │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ SessionEnd │ │
│ │ 훅 실행 │ │
│ └──────────────┘ │
│ │
│ 종료 이유 (subtype): │
│ ├─ success: 정상 완료 │
│ ├─ error_max_turns: 턴 제한 초과 │
│ ├─ error_max_budget_usd: 예산 초과 │
│ ├─ error_during_execution: API 오류 │
│ └─ prompt_input_exit: 사용자가 종료 │
└─────────────────────────────────────────────────────┘
체크포인트와 되돌리기
Claude가 파일을 수정하기 전에 항상 현재 상태를 스냅샷합니다. 문제가 생기면:
Esc두 번 누르기 → 이전 상태로 되돌리기- Claude에게 "되돌려줘"라고 요청
체크포인트는 로컬 파일 변경에만 적용됩니다. 데이터베이스, API 호출 등 외부 시스템에 대한 작업은 되돌릴 수 없습니다.
7. 권한 모델 — 도구 실행의 관문
에이전틱 루프에서 도구가 실행되기까지 권한 체크가 일어납니다.
┌─────────────────────────────────────────────────────┐
│ 권한 체크 흐름 │
│ │
│ Claude: "Bash로 rm -rf node_modules 실행할게" │
│ │ │
│ ▼ │
│ ┌──────────────────┐ │
│ │ 1. PreToolUse 훅 │──→ 차단? → Claude에게 피드백 │
│ └──────┬───────────┘ │
│ │ 통과 │
│ ▼ │
│ ┌──────────────────┐ │
│ │ 2. 거부 규칙 │──→ 매칭? → 즉시 차단 │
│ │ (deny rules) │ (훅의 allow도 무시됨) │
│ └──────┬───────────┘ │
│ │ 해당 없음 │
│ ▼ │
│ ┌──────────────────┐ │
│ │ 3. 허용 규칙 │──→ 매칭? → 실행 허용 │
│ │ (allow rules) │ │
│ └──────┬───────────┘ │
│ │ 해당 없음 │
│ ▼ │
│ ┌──────────────────┐ │
│ │ 4. 권한 모드에 │ │
│ │ 따라 결정 │ │
│ └──────┬───────────┘ │
│ │ │
│ ┌────┴────┬──────────┬──────────┐ │
│ ▼ ▼ ▼ ▼ │
│ default acceptEdits plan bypassAll │
│ 사용자에게 파일 수정 읽기 모두 │
│ 물어봄 자동 허용 전용 자동 허용 │
└─────────────────────────────────────────────────────┘
4가지 권한 모드
Shift+Tab으로 전환합니다:
- Default: 파일 편집과 셸 명령 전에 사용자 확인
- Auto-accept Edits: 파일 편집 자동 허용, 명령은 확인
- Plan Mode: 읽기 전용 도구만 사용, 계획 수립 후 승인
- Auto Mode: 백그라운드 안전 체크와 함께 자동 실행 (리서치 프리뷰)
8. 훅이 개입하는 생명주기 포인트
생명주기 전체에 걸쳐 25개의 훅 이벤트가 배치되어 있습니다. 각 단계별로 어떤 훅이 실행되는지 정리합니다.
┌──────────────────────────────────────────────────────┐
│ 생명주기와 훅 매핑 │
│ │
│ ① 세션 시작 │
│ SessionStart ─── 환경 변수 설정, 컨텍스트 주입 │
│ InstructionsLoaded ─── CLAUDE.md 로딩 감사 │
│ │
│ ② 사용자 입력 │
│ UserPromptSubmit ─── 입력 검증, 추가 컨텍스트 │
│ │
│ ③ 에이전틱 루프 │
│ PreToolUse ────── 도구 실행 전 차단/허용/수정 │
│ PermissionRequest ── 권한 다이얼로그 자동 처리 │
│ PostToolUse ───── 실행 후 포맷팅/로깅 │
│ PostToolUseFailure ── 실패 후 컨텍스트 추가 │
│ SubagentStart/Stop ── 서브에이전트 감시 │
│ TaskCreated/Completed ── 에이전트 팀 품질 관리 │
│ TeammateIdle ──── 팀원 유휴 처리 │
│ │
│ ④ 컴팩션 │
│ PreCompact ────── 전체 트랜스크립트 아카이브 │
│ PostCompact ───── 요약 후 처리 │
│ SessionStart(compact) ── 컨텍스트 재주입 │
│ │
│ ⑤ 세션 종료 │
│ Stop ──────────── 작업 완료 여부 검증 │
│ StopFailure ───── API 오류 로깅 │
│ SessionEnd ────── 정리 작업 │
│ │
│ 비동기 이벤트 │
│ Notification ──── 데스크톱 알림 │
│ FileChanged ───── .env 등 파일 변경 감지 │
│ CwdChanged ────── 디렉토리 변경 시 환경 갱신 │
│ ConfigChange ──── 설정 변경 감사 │
└──────────────────────────────────────────────────────┘
9. 컨텍스트 효율 관리 전략
장시간 세션에서 컨텍스트를 효율적으로 관리하는 전략입니다.
서브에이전트 활용
서브에이전트는 완전히 독립된 컨텍스트 윈도우에서 작업합니다. 메인 대화의 기록을 상속받지 않으며, 작업이 끝나면 요약만 메인 컨텍스트에 추가됩니다.
┌────────────────────────────────────────────────┐
│ 서브에이전트의 컨텍스트 격리 │
│ │
│ 메인 세션 컨텍스트 (150K 사용 중) │
│ ┌──────────────────────────────┐ │
│ │ ...기존 대화... │ │
│ │ "이 모듈 리서치해줘" │ │
│ └──────────────┬───────────────┘ │
│ │ Agent 도구 호출 │
│ ▼ │
│ 서브에이전트 컨텍스트 (0에서 시작) │
│ ┌──────────────────────────────┐ │
│ │ 시스템 프롬프트 + CLAUDE.md │ │
│ │ + 스폰 프롬프트만 포함 │ │
│ │ (메인 대화 기록 없음!) │ │
│ │ │ │
│ │ ...독립적으로 리서치 수행... │ │
│ └──────────────┬───────────────┘ │
│ │ 완료 │
│ ▼ │
│ 메인 세션에 요약만 추가 (+500 토큰) │
│ (전체 리서치 과정의 10K 토큰은 포함 안 됨) │
└────────────────────────────────────────────────┘
구체적인 프롬프트 작성
❌ "버그 좀 고쳐줘"
→ Claude가 많은 파일을 탐색적으로 읽음 (컨텍스트 소비 큼)
✅ "src/auth/auth.ts의 토큰 갱신 버그를 고쳐줘"
→ Claude가 정확한 파일만 읽음 (컨텍스트 절약)
MCP 도구 관리
각 MCP 서버는 모든 도구 스키마를 컨텍스트에 추가합니다. 도구가 많은 서버가 여러 개이면 작업 시작 전부터 상당한 컨텍스트를 소비합니다. ToolSearch를 활용해 온디맨드 로딩하세요.
10. 전체 생명주기 종합도
┌─────────────────────────────────────────────────────────────┐
│ │
│ $ claude │
│ │ │
│ ① 세션 시작 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
│ │ 세션 ID 생성 → 환경 감지 → SessionStart 훅 │
│ │ │
│ ② 컨텍스트 로딩 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
│ │ 시스템 프롬프트 → Auto Memory → 환경 정보 │
│ │ → MCP 도구(지연) → 스킬(요약) → CLAUDE.md │
│ │ │
│ 사용자 프롬프트 입력 │
│ │ UserPromptSubmit 훅 │
│ │ │
│ ③ 에이전틱 루프 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
│ │ ┌─────────────────────────────────────┐ │
│ │ │ Claude 추론 │ │
│ │ │ │ │ │
│ │ │ 도구 호출? ──No──→ 최종 응답 (⑤로) │ │
│ │ │ │ Yes │ │
│ │ │ ▼ │ │
│ │ │ PreToolUse 훅 → 권한 체크 │ │
│ │ │ │ │ │
│ │ │ 도구 실행 (파일R/W, 검색, Bash, 웹) │ │
│ │ │ │ │ │
│ │ │ PostToolUse 훅 (포맷팅, 로깅) │ │
│ │ │ │ │ │
│ │ │ 결과 → 컨텍스트에 추가 │ │
│ │ │ │ │ │
│ │ │ 컨텍스트 95%? ──Yes──→ ④ 컴팩션 │ │
│ │ │ │ No │ │
│ │ │ └──→ Claude 추론 (반복) │ │
│ │ └─────────────────────────────────────┘ │
│ │ │
│ ④ 컴팩션 (필요시) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
│ │ PreCompact 훅 → 오래된 출력 제거 → 대화 요약 │
│ │ → 시작 컨텍스트 재주입 → PostCompact 훅 │
│ │ → ③으로 복귀 │
│ │ │
│ ⑤ 세션 종료 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
│ Stop 훅 → 결과 반환 (텍스트, 토큰, 비용, 세션ID) │
│ → SessionEnd 훅 │
│ │
│ 세션 저장 (--continue로 재개 가능) │
│ │
└─────────────────────────────────────────────────────────────┘
마무리
Claude Code의 생명주기를 이해하면 더 효과적으로 활용할 수 있습니다.
- 컨텍스트 로딩을 이해하면 CLAUDE.md를 어떻게 구성할지 알게 됩니다
- 에이전틱 루프를 이해하면 프롬프트를 어떻게 작성할지 알게 됩니다
- 컴팩션을 이해하면 장시간 세션에서 정보 손실을 방지할 수 있습니다
- 권한 모델을 이해하면 안전하면서도 효율적인 자동화를 구성할 수 있습니다
- 훅 포인트를 이해하면 생명주기의 어느 지점에든 자동화를 삽입할 수 있습니다
결국 Claude Code는 단순한 챗봇이 아니라, 정교하게 설계된 에이전틱 하니스(agentic harness)입니다. 모델의 추론 능력과 도구의 실행 능력, 그리고 컨텍스트 관리와 권한 체계가 합쳐져 언어 모델을 유능한 코딩 에이전트로 만들어주는 것입니다.
참고 자료:
- Claude Code 공식 문서 - How Claude Code Works
- Claude Code 공식 문서 - Explore the Context Window
- Claude API 문서 - How the Agent Loop Works
- Claude API 문서 - Compaction
- Claude Code 공식 문서 - Hooks Reference
반응형
'프로그래밍 PROGRAMMING > 인공지능 AI' 카테고리의 다른 글
| AI에서 RAG란 무엇인가? — 환각을 없애고 최신 지식을 주입하는 검색 증강 생성 (3) | 2026.04.17 |
|---|---|
| 클로드 코드 team-onboarding 스킬 - 신규 팀원 온보딩을 자동화하는 최신 기능 (5) | 2026.04.16 |
| Claude code 에이전트 5개 띄워도 비용은 1개 수준? — Claude Code 유출 코드로 본 멀티 에이전트 캐시 공유의 경제학 (0) | 2026.04.13 |
| Claude Code 소스 유출이 밝힌 멀티 에이전트의 비밀 — 오케스트레이션은 코드가 아니라 프롬프트다 (1) | 2026.04.10 |
| Claude Code Hooks 란? - AI 코딩 워크플로우를 자동화하는 강력한 무기 (0) | 2026.04.08 |