references/block0-concept.md
> 공식 문서: https://code.claude.com/docs/ko/sub-agents
## EXPLAIN
### 1. Multi-agent란?
**비유: "회사 퇴근 전 마감 회의"**
회사에서 퇴근 전에 팀장 4명에게 동시에 보고를 받는 상황을 떠올려보세요.
- 문서담당 팀장: "오늘 보고서 3건 업데이트했습니다"
- 자동화담당 팀장: "매주 반복되는 이 작업, 자동화할 수 있습니다"
- 학습담당 팀장: "이번 주 프로젝트에서 이런 걸 배웠습니다"
- 후속작업담당 팀장: "다음 주에 이것부터 해야 합니다"
**Claude Code도 똑같이 합니다.** 하나의 Claude가 혼자 다 하는 게 아니라, 여러 전문 에이전트(sub-agent)에게 동시에 일을 시킵니다. 각자 맡은 분야를 분석하고, 결과를 모아서 보고합니다.
이건 Day 1 Block 3-4에서 배운 subagent(Task)의 확장입니다. 그때는 하나의 subagent에게 하나의 일을 시켰다면, 이제는 **여러 subagent에게 동시에 여러 일을 시키는 것**입니다.
---
### 2. 2-Phase Pipeline (핵심 패턴)
Multi-agent를 실제로 쓸 때, 가장 많이 쓰는 패턴이 **2-Phase Pipeline**입니다.
**Phase 1: 4명의 전문가가 동시에 분석 (병렬)**
> "병렬"이란? 여러 작업을 동시에 처리하는 것입니다. 4명의 팀장에게 한꺼번에 보고를 받는 것과 같습니다. (반대: "순차" = 한 명씩 차례로 보고받는 것)
| 전문가 | 하는 일 |
|--------|---------|
| doc-updater | 문서 중 업데이트가 필요한 곳을 찾아냄 |
| automation-scout | 반복되는 패턴을 발견하고 자동화를 제안 |
| learning-extractor | 오늘 배운 것을 정리 |
| followup-suggester | 다음에 할 일을 제안 |
4명이 **동시에** 각자 분석합니다. 순서대로 하나씩 하는 게 아니라, 한꺼번에 진행하니까 빠릅니다.
**Phase 2: 검증 담당이 중복 확인**
| 전문가 | 하는 일 |
|--------|---------|
| duplicate-checker | Phase 1 결과에서 겹치는 내용을 걸러냄 |
왜 Phase 2가 필요할까요? **전문가 4명이 독립적으로 일하면, 비슷한 걸 제안할 수 있기 때문입니다.** 예를 들어 doc-updater가 "README 업데이트 필요"라고 하고, followup-suggester도 "다음에 README 수정하세요"라고 할 수 있죠. duplicate-checker가 이런 중복을 정리해서 깔끔한 결과만 남깁니다.
---
### 3. session-wrap이란?
**비유: "퇴근 전 책상 정리 루틴"**
매일 퇴근 전에 하는 루틴이 있다고 생각해보세요.
- 오늘 한 일 정리
- 배운 것 메모
- 내일 할 일 목록 작성
- 책상 위 서류 정돈
**session-wrap**은 Claude Code 세션을 끝낼 때 자동으로 실행되는 "종합 정리 스킬"입니다. 위에서 배운 Multi-agent + 2-Phase Pipeline을 활용해서, 오늘의 작업을 체계적으로 정리해줍니다.
**전체 흐름 다이어그램:**
```
┌─────────────────────────────────────────────────┐
│ 1. 변경 내용 확인 (오늘 뭘 했나?) │
├─────────────────────────────────────────────────┤
│ 2. Phase 1: 4명의 전문가 동시 분석 │
│ ┌────────────────┬────────────────┐ │
│ │ 문서 업데이트 │ 자동화 발견 │ │
│ ├────────────────┼────────────────┤ │
│ │ 배운 것 정리 │ 다음 할 일 │ │
│ └────────────────┴────────────────┘ │
├─────────────────────────────────────────────────┤
│ 3. Phase 2: 중복 검증 (같은 말 안 하게) │
├─────────────────────────────────────────────────┤
│ 4. 결과 통합 + 사용자 선택 │
├─────────────────────────────────────────────────┤
│ 5. 선택한 작업 실행 │
└─────────────────────────────────────────────────┘
```
정리하면, session-wrap은 **"내가 퇴근 전에 일일이 정리할 필요 없이, Claude가 알아서 팀장 4명에게 보고를 받고 정리해주는 것"**입니다.
---
## EXECUTE
아래 순서대로 따라해보세요.
### Step 0. 플러그인 확인
session-wrap 원본 스킬은 플러그인으로 이미 설치되어 있습니다. 아래 명령어로 확인하세요:
```
설치된 플러그인 목록을 보여줘
```
목록에 `session-wrap`이 있으면 다음 단계로 넘어갑니다. 없다면 강사에게 문의하세요.
### Step 1. session-wrap 원본 읽어보기
Claude Code에서 아래 명령어를 입력하세요:
```
설치된 session-wrap 스킬의 SKILL.md 내용을 보여줘
```
Claude가 session-wrap 스킬의 전체 내용을 보여줄 것입니다. 천천히 읽어보세요.
> 만약 "session-wrap 스킬을 찾을 수 없다"고 나오면, `npx skills add ai-native-camp/camp-2 --agent claude-code --yes`를 실행해서 최신 스킬을 설치하세요.
### Step 2. 구조 분석
원본 스킬을 읽고 다음 3가지를 파악해보세요:
- **에이전트가 몇 개인지** - 이름과 역할을 세어보세요
- **어떤 순서로 실행되는지** - Phase 1이 먼저인지, Phase 2가 먼저인지
- **왜 Phase 1과 Phase 2로 나눠져 있는지** - EXPLAIN에서 배운 이유를 떠올려보세요
### Step 2.5. 원본 스킬 구조 매핑
Claude에게 아래와 같이 요청해보세요:
```
session-wrap SKILL.md에서 각 섹션이 하는 역할을 표로 정리해줘. 이름표 부분, 실행 흐름, 단계별 내용을 구분해서.
```
> "frontmatter"라는 용어가 나올 수 있는데, 이것은 파일 맨 위에 적는 "이름표"입니다. Block 1에서 자세히 배웁니다.
이 표가 Block 1에서 직접 만들 때의 "설계도"가 됩니다.
### Step 3. 자유 탐색 (선택)
시간이 있다면, 원본 스킬을 보면서 아래 중 하나를 Claude에게 질문해보세요:
- "이 스킬에서 doc-updater가 구체적으로 뭘 분석하는 거야?"
- "왜 에이전트를 4개로 나눈 거야? 2개나 6개는 안 돼?"
- "이걸 마케팅 업무에 적용하면 어떤 모습이 될까?"
> 정답이 있는 질문이 아닙니다. 구조를 탐색하는 과정 자체가 학습입니다.
---
## QUIZ
```json
AskUserQuestion({
"questions": [{
"question": "session-wrap의 2-Phase Pipeline에서, Phase 2(duplicate-checker)가 필요한 이유는?",
"header": "Quiz 0",
"options": [
{"label": "4명의 전문가가 비슷한 제안을 할 수 있어서", "description": "중복을 걸러내야 깔끔한 결과가 나온다"},
{"label": "Phase 1의 에이전트가 틀릴 수 있어서", "description": "정확도 검증이 목적"},
{"label": "속도를 높이기 위해서", "description": "병렬 처리와 관련된 이유"}
],
"multiSelect": false
}]
})
```
**정답: 1번.** Phase 1에서 4명의 전문가가 독립적으로 분석하면, 비슷한 제안이 나올 수 있다. Phase 2의 duplicate-checker가 이런 중복을 걸러내서 깔끔한 결과만 사용자에게 보여준다.
references/block1-build-session-wrap.md
# Block 1: session-wrap 스킬 직접 만들기
> 공식 문서: https://code.claude.com/docs/ko/skills
> 참고: https://code.claude.com/docs/ko/sub-agents
## EXPLAIN
Block 0에서 session-wrap의 구조와 multi-agent 원리를 이해했습니다. 이제 직접 SKILL.md를 만들어봅니다.
### 스킬 파일 구조 복습 (Day 1 Block 3-2 복습)
스킬은 파일 하나면 됩니다:
```
my-session-wrap/
└── SKILL.md <- 이것만 만들면 스킬이 된다
```
Day 1에서 배운 것처럼, `SKILL.md` 파일 하나가 스킬의 전부입니다. 이 파일 안에 "언제 실행할지", "무엇을 할지", "어떤 순서로 할지"를 모두 적습니다.
### SKILL.md를 6단계로 만든다
오늘은 session-wrap 스킬의 SKILL.md를 6단계에 걸쳐 완성합니다:
| 단계 | 내용 | 하는 일 |
|------|------|---------|
| Step 1 | frontmatter (이름표) | 스킬 이름과 설명 |
| Step 2 | Execution Flow | 실행 흐름 다이어그램 |
| Step 3 | 변경 내용 확인 | 오늘 뭘 했는지 파악 |
| Step 4 | Phase 1 - 병렬 에이전트 4개 | 동시에 4가지 분석 |
| Step 5 | Phase 2 - 검증 에이전트 | 결과 중복 체크 |
| Step 6 | 결과 통합 + 사용자 선택 | 보여주고 선택받기 |
### 비유: "레시피 작성하기"
요리 레시피를 쓴다고 생각해보세요. 우리가 만드는 SKILL.md도 같은 구조입니다:
```
Step 1: 요리 이름과 소개 -> frontmatter (이 스킬이 뭔지 한 줄 소개)
Step 2: 완성 사진 -> 다이어그램 (전체 흐름을 한눈에)
Step 3: 재료 준비 -> 변경 내용 확인 (오늘 뭘 했는지 파악)
Step 4: 4가지 반찬 동시 조리 -> 병렬 에이전트 (각자 다른 분석을 동시에)
Step 5: 맛 검수 -> 검증 에이전트 (중복이나 빠진 게 없는지 확인)
Step 6: 상차리기 -> 결과 통합 (정리해서 보여주고, 실행할 것 선택)
```
핵심은 **Step 4**입니다. 반찬 4가지를 한 명이 순서대로 만들면 오래 걸리지만, 4명이 각자 하나씩 동시에 만들면 빠릅니다. session-wrap도 4개 에이전트가 동시에 분석해서 시간을 절약합니다.
### 각 단계를 하나씩 Claude에게 시키면서 만든다
중요한 점: 한 번에 다 만들라고 하지 않습니다. **한 단계씩** Claude에게 시키면서 결과를 확인하고, 다음 단계로 넘어갑니다. 마치 요리할 때 재료 손질 끝내고, 다음 조리 단계로 가는 것처럼요.
---
## EXECUTE
아래 순서대로 진행합니다.
> **안심하세요**: 아래 프롬프트를 Claude에게 복사해서 붙여넣기만 하면 됩니다. **코드는 Claude가 작성합니다.** 여러분은 프롬프트를 주고 결과를 확인하는 것이 전부입니다. 지금 이 세션에서 그대로 입력하면 됩니다.
### 준비
아래 프롬프트를 Claude에게 입력합니다:
```
나만의 session-wrap 스킬을 만들 거야.
.claude/skills/my-session-wrap/ 폴더를 만들고, SKILL.md 파일을 생성해줘.
먼저 빈 파일로 시작하자.
```
### Step 1: frontmatter(이름표) 추가
스킬의 이름표를 붙입니다. 요리 레시피의 제목과 소개글에 해당합니다.
> **frontmatter란?** 파일 맨 위에 `---`로 감싸서 적는 "이름표"입니다. 책의 표지에 제목과 저자를 적는 것처럼, 스킬 파일에도 이름(name)과 설명(description)을 적어야 Claude가 "아, 이 스킬은 세션 정리할 때 쓰는 거구나"라고 인식합니다.
```
my-session-wrap/SKILL.md에 frontmatter(이름표)를 추가해줘:
- name: my-session-wrap
- description: 세션 종료 시 작업 정리, 문서 업데이트, 학습 기록을 하는 스킬. "/wrap", "세션 정리", "마무리" 요청에 사용.
```
### Step 2: Execution Flow 다이어그램 추가
완성된 요리의 사진을 먼저 보여주는 것처럼, 전체 실행 흐름을 한눈에 볼 수 있는 다이어그램을 추가합니다.
```
SKILL.md에 실행 흐름 다이어그램을 추가해줘.
5단계로 구성해:
1. Git 상태 확인
2. Phase 1: 4개 분석 에이전트 병렬 실행
3. Phase 2: 검증 에이전트 순차 실행
4. 결과 통합
5. 사용자 선택 + 실행
ASCII 박스 다이어그램으로 만들어줘.
```
> 다이어그램이 있으면 Claude도 전체 구조를 이해하고 각 단계를 정확히 실행합니다. 사람과 AI 모두에게 "지도" 역할을 합니다.
### Step 3: 변경 내용 확인 섹션 추가
재료를 확인하는 단계입니다. "오늘 이 세션에서 뭘 했는지"를 파악합니다.
```
SKILL.md에 Step 1: 변경 내용 확인 섹션을 추가해줘.
"오늘 이 세션에서 어떤 파일을 만들거나 수정했는지" 파악하는 부분이야.
변경 내용을 자동으로 요약하는 구조로 만들어줘.
```
> 이 부분은 "오늘 뭘 했는지" 확인하는 단계입니다. Claude가 자동으로 변경 사항을 확인합니다. 여러분이 직접 뭔가를 칠 필요는 없습니다. 스킬이 실행되면 Claude가 알아서 처리합니다.
> 여기까지 완료했으면, Claude에게 "지금까지 만든 SKILL.md를 보여줘"라고 입력해서 중간 결과를 확인하세요. Step 1~3이 모두 들어가 있으면 다음 단계로 넘어갑니다.
> **Fast Track**: 시간이 부족하거나 빠르게 진행하고 싶다면, Step 4~6을 한 번에 요청할 수도 있습니다:
> "session-wrap 원본을 참고해서 Phase 1(4개 병렬 에이전트), Phase 2(검증), 결과 통합 섹션을 한꺼번에 추가해줘"
### Step 4: Phase 1 병렬 에이전트 추가
4가지 반찬을 동시에 만드는 단계입니다. 이 부분이 session-wrap의 핵심입니다.
```
SKILL.md에 Phase 1 섹션을 추가해줘.
4개의 전문가 에이전트가 동시에 분석하는 부분이야:
1. doc-updater: 문서 중 업데이트할 곳 찾기
2. automation-scout: 반복 패턴 발견 -> 자동화 제안
3. learning-extractor: 오늘 배운 것 정리
4. followup-suggester: 다음에 할 일 제안
각 에이전트가 동시에 실행되도록 작성해줘.
Block 0에서 본 session-wrap 원본의 구조를 참고해서 만들어줘.
```
> 4개 에이전트는 각자 독립적으로 분석합니다:
> - **doc-updater**: "CLAUDE.md에 오늘 작업 내용을 반영해야 할까?"
> - **automation-scout**: "반복되는 패턴이 있으면 스킬이나 스크립트로 만들 수 있을까?"
> - **learning-extractor**: "오늘 배운 것을 정리"
> - **followup-suggester**: "내일 이어서 할 일은 뭐가 있을까?"
>
> 이 4개가 서로 의존하지 않으므로 동시에(병렬로) 실행됩니다.
### Step 5: Phase 2 검증 에이전트 추가
맛 검수 단계입니다. Phase 1에서 4명이 만든 결과를 한 명이 검수합니다.
```
SKILL.md에 Phase 2 섹션을 추가해줘.
duplicate-checker 에이전트가 Phase 1 결과를 검증하는 부분이야.
Phase 1 결과를 받아서 중복을 확인하고,
완전 중복은 제거, 부분 중복은 병합을 제안하는 구조로.
```
> 왜 검증이 필요할까요? 예를 들어 doc-updater가 "CLAUDE.md에 새 스킬 추가 기록"을 제안하고, followup-suggester도 "CLAUDE.md 업데이트 필요"를 제안하면 중복입니다. duplicate-checker가 이런 중복을 잡아냅니다.
### Step 6: 결과 통합 + 사용자 선택 추가
상차리기 단계입니다. 모든 결과를 정리해서 보여주고, 사용자가 실행할 작업을 고릅니다.
```
SKILL.md의 마지막에 결과 통합과 사용자 선택 섹션을 추가해줘.
1. 4개 에이전트 결과 + 검증 결과를 합쳐서 보여주기
2. AskUserQuestion으로 사용자에게 어떤 작업을 실행할지 선택받기
(커밋, 문서 업데이트, 자동화 생성, 건너뛰기)
3. 선택된 작업만 실행
```
> 자동으로 모든 것을 실행하지 않고, 사용자에게 선택권을 줍니다. "커밋만 할게", "문서 업데이트도 해줘", "오늘은 건너뛸게" 등 상황에 맞게 선택할 수 있습니다.
### (선택) 언제 쓰고 언제 안 쓸지
원본 session-wrap에는 "언제 사용하고, 언제 건너뛸지" 가이드가 있습니다. 여러분의 스킬에도 넣고 싶다면:
```
SKILL.md 마지막에 Quick Reference 섹션을 추가해줘.
- 언제 사용하면 좋은지 (긴 작업 세션 후, 프로젝트 전환 시)
- 언제 건너뛰어도 되는지 (짧은 질문, 코드만 읽은 경우)
```
### 최종 확인
모든 단계가 끝나면 전체 결과를 확인합니다:
```
만들어진 my-session-wrap/SKILL.md 전체 내용을 보여줘.
```
완성된 SKILL.md가 6개 섹션(이름표, 다이어그램, 변경 내용 확인, Phase 1, Phase 2, 결과 통합)을 모두 갖고 있는지 확인합니다.
> **만약 내용이 이상하거나 빠진 부분이 있다면**, Claude에게 이렇게 요청하세요:
> "session-wrap 원본 스킬을 참고해서, 내 my-session-wrap 스킬을 완성해줘"
> Claude가 원본과 비교해서 빠진 부분을 채워줍니다.
> **파일은 안전합니다**: 만든 `SKILL.md` 파일은 프로젝트 폴더에 저장됩니다. 이 세션을 닫거나 새 세션을 열어도 파일은 사라지지 않습니다. Block 2에서 새 세션을 열었을 때도 그대로 남아 있습니다.
---
## QUIZ
```json
AskUserQuestion({
"questions": [{
"question": "session-wrap 스킬에서 Phase 1의 4개 에이전트가 '병렬'로 실행되는 이유는?",
"header": "Quiz 1",
"options": [
{"label": "서로 의존하지 않아서 동시에 실행 가능", "description": "4개 에이전트가 각자 독립적으로 분석"},
{"label": "순서대로 하면 결과가 달라져서", "description": "실행 순서가 결과에 영향"},
{"label": "에이전트끼리 대화해야 해서", "description": "협업을 위한 병렬 처리"}
],
"multiSelect": false
}]
})
```
정답: 1번. 4개 에이전트는 각자 독립적인 분석을 수행한다. doc-updater는 문서만 보고, automation-scout는 패턴만 보고, 각자 다른 관점에서 분석하므로 서로 기다릴 필요가 없다. 그래서 동시에(병렬로) 실행해서 시간을 절약한다.
references/block2-run-session-wrap.md
> 공식 문서: https://code.claude.com/docs/ko/skills
## EXPLAIN
**주제: 만든 session-wrap 스킬 실행 + 검증**
### 1. 스킬이 만들어졌으면 실행해봐야 한다
Block 1에서 `my-session-wrap` 스킬을 만들었습니다. 이제 실제로 실행해볼 차례입니다.
레시피를 작성했으면 요리를 해봐야 맛을 알 수 있습니다. 스킬도 마찬가지로, 만들기만 하면 의미가 없습니다. 직접 돌려보고 결과를 확인해야 진짜 내 것이 됩니다.
### 2. 실행 전 확인할 것
스킬을 실행하기 전에 3가지를 확인합니다.
- **파일 존재 여부**: `.claude/skills/my-session-wrap/SKILL.md` 파일이 실제로 있는지 확인합니다. 이 파일이 없으면 Claude는 스킬을 인식하지 못합니다.
- **frontmatter(이름표) 확인**: 파일 맨 위의 `name`과 `description`이 올바르게 적혀 있는지 봅니다. `name`은 스킬을 부르는 이름이 되고, `description`은 Claude가 "이 스킬을 언제 쓸지" 판단하는 기준이 됩니다.
- **Claude 인식 확인**: "어떤 스킬이 설치되어 있어?"라고 물어보면, Claude가 인식하고 있는 스킬 목록을 보여줍니다.
### 3. 실행 후 볼 것
스킬이 실행되면 아래 3가지가 순서대로 일어나야 합니다.
- **4개 에이전트 병렬 실행**: 화면에 "Task 실행 중..." 또는 에이전트 이름이 여러 개 표시되면 정상입니다. 4개 에이전트가 동시에 분석을 시작합니다.
- **Phase 2 검증 동작**: 에이전트들의 결과물을 종합하는 검증 단계가 실행됩니다. 이 과정에서 중복이 정리됩니다.
- **AskUserQuestion 선택지 제시**: 최종 결과를 바탕으로 "어떻게 할까요?"라는 선택지가 나옵니다. 사용자가 직접 다음 행동을 고르는 것입니다.
### 4. 문제가 있으면 수정
실행했는데 의도대로 동작하지 않을 수 있습니다. 그때는 아래를 확인합니다.
- **에이전트가 실행되지 않으면**: SKILL.md 안에 Task 호출 부분이 올바르게 작성되어 있는지 Claude에게 확인을 요청합니다.
- **병렬이 아니라 순차로 실행되면**: 하나의 메시지 안에 4개 Task 호출이 모두 들어 있는지 확인합니다. 따로따로 호출하면 순차 실행이 됩니다.
- **결과가 이상하면**: 각 에이전트에게 주는 지시문을 수정합니다. 지시가 모호하면 결과도 모호해집니다.
---
## EXECUTE
아래 순서대로 실행해보세요.
### Step 1. 새 터미널 탭에서 작업 세션 열기
스킬을 테스트하려면 **별도의 세션**이 필요합니다. 지금 이 교육 세션에서 직접 실행하면 교육 흐름이 끊길 수 있기 때문입니다.
**새 터미널 탭을 열어주세요:**
- Mac: `Cmd + T` (터미널에서 새 탭)
- 새 탭에서 같은 프로젝트 폴더로 이동합니다. 캠프 시작할 때 사용한 `cd` 명령어를 다시 입력하면 됩니다.
- 폴더로 이동한 뒤 `claude`를 입력해서 Claude Code를 시작합니다
> 이 교육 세션은 그대로 두고, 새 탭에서 작업합니다. Block 2 실습이 끝나면 이 교육 세션 탭으로 돌아오면 됩니다.
> **이 새 탭에서 그대로 Step 2~5를 진행합니다.** Step 1 확인 후 교육 탭으로 돌아가지 마세요.
새 세션에서 아래를 입력합니다:
```
어떤 스킬이 설치되어 있어?
```
Claude가 보여주는 목록에 `my-session-wrap`이 있는지 확인합니다. 목록에 없다면 `.claude/skills/my-session-wrap/SKILL.md` 파일이 올바른 위치에 있는지 다시 확인하세요.
### Step 2. 먼저 작업을 좀 하기
wrap(세션 정리)을 하려면 정리할 작업이 있어야 합니다. 간단한 작업을 먼저 해봅니다.
```
간단한 README.md 파일을 만들어줘. 내 이름, 오늘 날짜, "Day 4 실습"이라고 적어줘.
```
이렇게 하면 세션에 변경사항이 생기고, wrap 스킬이 분석할 대상이 만들어집니다.
### Step 3. 스킬 실행하기
아래 명령으로 만든 스킬을 실행합니다. Step 1에서 확인한 스킬 이름을 사용하세요:
```
/my-session-wrap
```
> 만약 "스킬을 찾을 수 없습니다"라고 나오면, Step 1에서 확인한 스킬 목록의 이름을 확인하세요. `name`이 다르게 설정되었을 수 있습니다.
자연어로도 실행할 수 있습니다:
```
세션 정리해줘
```
두 방법 모두 같은 스킬이 실행됩니다. `/` 명령어는 직접 호출, 자연어는 `description`을 기반으로 Claude가 자동으로 매칭합니다.
### Step 4. 결과 관찰하기
실행 결과를 주의 깊게 관찰합니다. 아래 질문에 답해보세요.
- 에이전트 4개가 실행되는 것이 보이는가? (화면에 "Task 실행 중..." 또는 에이전트 이름이 여러 개 표시되면 정상)
- 각 에이전트의 분석 결과가 나오는가?
- 최종 선택지가 나오는가?
세 가지 모두 "예"라면 스킬이 정상 동작하는 것입니다.
### Step 5. 문제 발견 시 수정
만약 의도대로 동작하지 않으면 Claude에게 수정을 요청합니다.
```
my-session-wrap 스킬의 [문제점]을 수정해줘
```
`[문제점]` 부분에 구체적으로 무엇이 잘못되었는지 적어줍니다. 예를 들어:
- "에이전트가 2개만 실행돼" → 나머지 2개의 Task 호출이 빠진 것
- "병렬이 아니라 하나씩 실행돼" → Task 호출을 한 메시지에 모아야 함
- "선택지가 안 나와" → AskUserQuestion 호출 부분을 확인
> **실행이 전혀 안 되면 Plan B**: "session-wrap 원본 스킬을 참고해서 내 my-session-wrap을 완성해줘"라고 입력하세요. Claude가 원본을 참고해서 자동 보정합니다.
### Step 6. 교육 세션으로 돌아오기
실습이 끝났으면 **이 교육 세션이 열려 있는 터미널 탭**으로 돌아옵니다. 작업 세션 탭은 열어둔 채로 두어도 괜찮습니다.
> Block 3, 4에서도 같은 방식으로 별도 탭에서 실습하고, 이 교육 세션으로 돌아오면 됩니다.
---
## QUIZ
```json
AskUserQuestion({
"questions": [{
"question": "만든 스킬이 의도대로 동작하지 않을 때, 가장 먼저 확인해야 할 것은?",
"header": "Quiz 2",
"options": [
{"label": "SKILL.md의 frontmatter (name, description)", "description": "스킬 인식의 기본 조건"},
{"label": "에이전트 프롬프트 내용", "description": "분석 결과의 품질"},
{"label": "Git 상태", "description": "변경사항이 있는지"}
],
"multiSelect": false
}]
})
```
**정답: 1번. SKILL.md의 frontmatter (name, description)**
스킬이 인식되지 않으면 아무것도 실행되지 않습니다. frontmatter의 `name`이 스킬 호출 이름이 되고, `description`이 자동 매칭의 기준이 됩니다. 기본이 맞아야 나머지가 동작합니다. 에이전트 프롬프트나 Git 상태는 그 다음 문제입니다.
references/block3-history-insight.md
# Block 3: history-insight로 세션 히스토리 분석
> 공식 문서: https://code.claude.com/docs/ko/memory
## EXPLAIN
### Block 2에서 여기로
Block 2에서 session-wrap 스킬을 실행했습니다. 그 실행 기록이 어딘가에 저장되어 있습니다. 이번 블록에서는 그 "저장된 기록"을 들여다보는 방법을 배웁니다. session-wrap이 만들어낸 결과뿐 아니라, 과거 모든 세션의 기록에서 패턴을 찾아주는 도구가 바로 **history-insight**입니다.
### 세션 히스토리란?
Claude Code와 대화할 때마다 기록이 남습니다. 마치 **일기장**처럼 모든 대화가 파일로 저장됩니다.
- 위치: `~/.claude/projects/` 폴더 안에 자동으로 저장됩니다
- 프로젝트별로 폴더가 나뉘어 있음
- 하나의 세션(대화) = 하나의 파일
- 파일 형식은 몰라도 됩니다. Claude가 알아서 읽어줍니다
**비유하면:**
일기장을 매일 쓴다고 생각해보세요. 한 달 뒤에 일기장을 다시 펼쳐보면 "아, 이번 달엔 이런 고민을 많이 했구나", "이런 실수를 자주 했네"라는 패턴이 보입니다. Claude Code도 마찬가지입니다. 쌓여 있는 대화 기록에서 패턴을 찾아주는 것이 바로 **history-insight** 스킬입니다.
### history-insight 스킬은 뭘 하나?
이 "일기장"을 읽어서 유용한 패턴을 찾아줍니다.
- "이 프로젝트에서 가장 많이 한 작업은?"
- "반복되는 실수 패턴이 있을까?"
- "프로젝트별로 어떤 작업을 했는지 정리해줘"
**핵심**: 과거의 자기 자신에게서 배우는 것입니다.
### 데이터 흐름
세션 파일에는 실제 대화 외에도 파일 변경 이력, 큐 작업 같은 **부속 자료**가 대량으로 포함되어 있습니다. history-insight는 불필요한 부분을 걸러내고 핵심만 추출합니다.
```
세션 대화 기록 (파일)
|
history-insight 스킬이 읽기
|
불필요한 부분 제거 (대부분이 부속 자료)
|
실제 대화만 추출
|
인사이트 분석 + 리포트
```
비유하자면, 두꺼운 일기장에서 실제로 쓴 글은 아주 일부분이고, 나머지는 날짜 도장, 날씨 기록, 영수증 같은 부속 자료인 셈입니다. **history-insight는 이 부속 자료를 다 걷어내고, 실제 대화만 모아서 분석합니다.** 그래서 아무리 기록이 많아도 빠르게 핵심만 뽑아낼 수 있습니다.
---
### 활용 사례
| 질문 | history-insight가 해주는 것 |
|------|---------------------------|
| "이번 주에 가장 많이 한 작업이 뭐였지?" | 세션별 작업 내용을 분류하고 빈도순 정리 |
| "내가 자주 하는 실수 패턴이 있을까?" | 반복되는 오류, 재시도 패턴 추출 |
| "프로젝트별로 어떤 작업을 했는지 정리해줘" | 프로젝트 폴더별 세션 분류 및 요약 |
---
## EXECUTE
### 사전 확인
Block 2에서 사용했던 **작업 세션 탭**에서 실습합니다. 탭을 닫았다면 새 터미널 탭(`Cmd + T`)을 열고, 같은 프로젝트 폴더로 이동한 뒤 `claude`를 실행하세요. 교육 세션 탭이 아닌 별도 탭에서 진행합니다.
history-insight 스킬이 설치되어 있는지 확인합니다. Claude Code에서:
```
어떤 스킬이 설치되어 있어?
```
목록에 `history-insight`가 있으면 아래 단계로 진행합니다. 없다면 강사에게 문의하세요.
### 1단계: 세션 파일 확인하기
먼저 기록이 어디에 있는지 확인합니다. Claude에게 아래와 같이 요청하세요:
```
내 Claude Code 세션 기록이 어디에 저장되어 있는지 보여줘
```
Claude가 `~/.claude/projects/` 폴더 안의 세션 파일 목록을 보여줍니다. 프로젝트별로 폴더가 나뉘어 있고, 각 폴더 안에 세션 파일들이 있는 것을 확인하세요.
### 2단계: history-insight 실행
아래 명령으로 분석을 시작합니다:
```
/history-insight
```
> 아직 세션이 많지 않다면, 분석 결과가 짧을 수 있습니다. 괜찮습니다! Day 1~3에서의 세션이라도 패턴을 찾아줄 것입니다. 캠프가 끝날 때쯤 다시 실행하면 더 풍부한 인사이트를 얻을 수 있습니다.
### 3단계: 분석 범위 선택
분석 범위를 선택합니다:
- **"현재 프로젝트만"** - 지금 작업 중인 프로젝트의 세션만 분석
- **"모든 Claude Code 세션"** - 전체 세션을 분석
> 처음이라면 "현재 프로젝트만"으로 시작하는 것을 추천합니다. 데이터가 적을수록 결과를 이해하기 쉽습니다.
### 4단계: 결과 확인
분석 결과를 읽어봅니다. 아래 항목을 확인하세요:
- 몇 개의 세션이 분석되었는지
- 어떤 인사이트가 추출되었는지
- 흥미로운 패턴이 있는지
### 5단계: 자유 질문
결과를 보고 궁금한 것을 질문합니다:
```
이 분석 결과에서 가장 흥미로운 패턴을 더 자세히 설명해줘
```
다른 질문 예시:
- "내가 가장 자주 사용하는 도구(Tool)는 뭐야?"
- "가장 긴 세션은 어떤 작업이었어?"
- "이 패턴을 바탕으로 내 워크플로우 개선 제안을 해줘"
### 문제가 생기면
| 상황 | 해결 방법 |
|------|----------|
| "세션 파일을 찾을 수 없습니다" | 아직 충분한 세션 기록이 쌓이지 않았을 수 있습니다. "모든 Claude Code 세션"으로 범위를 넓혀서 다시 시도하세요. |
| "jq가 필요합니다" | Claude에게 "jq를 설치해줘"라고 요청하세요. 자동으로 설치해줍니다. 안 되면 강사에게 문의하세요. |
| 분석 결과가 비어 있음 | Claude Code를 더 사용한 뒤 다시 시도하거나, "모든 세션"으로 범위를 넓히세요. |
### 더 알고 싶다면
history-insight 원본 스킬에는 대량의 세션 파일을 처리하는 고급 기능(배치 파이프라인, 병렬 분석)이 있습니다. 궁금하면 Claude에게 물어보세요:
```
history-insight 플러그인의 원본 SKILL.md에서 Batch Extract Pipeline 부분을 설명해줘
```
## QUIZ
```json
AskUserQuestion({
"questions": [{
"question": "Claude Code 세션 기록 파일에서 실제 대화는 전체의 몇 %일까?",
"header": "Quiz 3",
"options": [
{"label": "약 6%", "description": "94%는 부속 자료(파일 변경 기록 등)"},
{"label": "약 50%", "description": "절반이 대화, 절반이 기타"},
{"label": "약 90%", "description": "대부분이 실제 대화 내용"}
],
"multiSelect": false
}]
})
```
정답: 1번. 세션 파일의 대부분은 파일 변경 이력 같은 부속 자료다. 실제 사용자와 Claude의 대화는 약 6%만 차지한다. history-insight는 이 핵심 대화만 추출해서 분석하므로, 큰 파일도 빠르게 처리된다.
references/block4-session-analyzer.md
# Block 4: session-analyzer로 스킬 실행 검증
> 공식 문서: https://code.claude.com/docs/ko/skills
> 참고: https://code.claude.com/docs/ko/sub-agents
## EXPLAIN
### 왜 검증이 필요한가?
Block 1에서 만든 session-wrap 스킬이 "진짜로" 의도대로 동작했는지 확인해야 합니다.
비유하면 이렇습니다. 요리를 만들었으면 레시피대로 만들었는지 확인해야 합니다. 소금을 넣으라고 했는데 설탕을 넣었을 수도 있고, 3분 끓이라고 했는데 10분 끓였을 수도 있습니다. **스킬을 만드는 것과 스킬이 올바르게 동작하는 것은 다른 문제입니다.**
SKILL.md에 "이렇게 해라"라고 써놨다고 해서 Claude가 100% 그대로 실행한다는 보장이 없습니다. 그래서 검증이 필요합니다.
### session-analyzer가 하는 일
session-analyzer는 **SKILL.md(설계도)와 실제 실행 기록을 비교**하는 도구입니다. 비유하면 "감독관"입니다. 설계도를 들고 현장에 나가서, 실제로 설계도대로 지어졌는지 하나하나 체크합니다.
6단계로 분석합니다:
| 단계 | 하는 일 | 비유 |
|------|---------|------|
| 1. 세션 파일 찾기 | 로그 파일 위치 파악 | CCTV 녹화본 찾기 |
| 2. SKILL.md 파싱 | 기대 동작 추출 | 설계도 읽기 |
| 3. 세션 기록 분석 | 실제 동작 추출 | CCTV 녹화본 재생 |
| 4. 아티팩트 검증 | 파일 생성/삭제 확인 | 결과물 현장 확인 |
| 5. Expected vs Actual 비교 | 표로 정리 | 설계도 vs 현장 대조표 작성 |
| 6. 리포트 생성 | PASS/FAIL 판정 | 합격/불합격 판정 |
### 비교 테이블 예시
실제로 session-analyzer가 만들어주는 결과는 이런 형태입니다:
| 구성요소 | 기대한 것 | 실제 결과 | 판정 |
|----------|-----------|-----------|------|
| doc-updater | 병렬 실행 | 09:39에 실행 | PASS |
| duplicate-chk | Phase 1 후 실행 | Phase 1 후 실행 | PASS |
| 결과 파일 | 생성됨 | 존재 확인 | PASS |
| 요약 포맷 | Markdown 표 | 일반 텍스트 | FAIL |
PASS는 설계도대로 된 것, FAIL은 설계도와 다른 것입니다.
### 이게 왜 중요한가?
- 스킬을 만들면 **테스트가 필수**입니다. 한 번에 완벽한 스킬은 없습니다.
- session-analyzer는 이 테스트를 **자동화**해주는 도구입니다.
- 사람이 눈으로 로그를 일일이 읽는 대신, AI가 설계도와 대조해서 문제를 찾아줍니다.
- "코드 리뷰"를 AI가 대신 해주는 것이라고 생각하면 됩니다.
## EXECUTE
### 사전 확인
session-analyzer 스킬이 설치되어 있는지 확인합니다. Claude Code에서:
```
어떤 스킬이 설치되어 있어?
```
목록에 `session-analyzer`가 있으면 아래 단계로 진행합니다. 없다면 강사에게 문의하세요.
### 1단계: session-analyzer 실행
Block 2에서 사용했던 작업 세션 탭이 아직 열려 있으면 그 탭에서, 닫았다면 새 터미널 탭(`Cmd + T`)을 열고 같은 프로젝트 폴더로 이동한 뒤 `claude`를 실행합니다.
아래 명령으로 분석을 시작합니다:
```
/session-analyzer
```
또는 자연어로:
```
가장 최근에 /my-session-wrap을 실행한 세션을 분석해줘
```
> 슬래시 명령어(`/session-analyzer`)와 자연어, 둘 다 같은 결과를 냅니다. 편한 방식을 쓰면 됩니다.
> Claude가 자동으로 해당 세션을 찾아서 분석합니다. 세션 ID 같은 것을 직접 찾을 필요는 없습니다.
> **세션을 못 찾는 경우**: "세션을 찾을 수 없다"고 나오면, "현재 프로젝트의 가장 최근 세션을 분석해줘"라고 범위를 넓혀보세요.
### 2단계: 분석 결과 확인
6단계 리포트가 나오면 아래를 확인합니다:
- Expected vs Actual 비교 테이블에서 **FAIL 항목이 있는지**
- FAIL이 있다면 **어떤 부분이 문제인지** 구체적으로 확인
- 전체 판정이 PASS인지 FAIL인지
### 3단계: 문제 발견 시 수정
만약 FAIL이 있다면, Claude에게 바로 수정을 요청합니다:
```
이 FAIL 항목을 수정할 수 있도록 my-session-wrap SKILL.md를 고쳐줘
```
> 직접 Block 1로 돌아갈 필요 없이, Claude가 FAIL 내용을 보고 즉시 수정해줍니다. 수정 후 다시 `/session-analyzer`로 확인하면 됩니다.
> 모든 항목이 PASS가 아니어도 괜찮습니다. 핵심 기능(에이전트 병렬 실행, 결과 출력)이 동작하면 성공입니다.
> **Block 2에서 session-wrap을 실행하지 못한 경우**: "원본 session-wrap 플러그인의 가장 최근 실행 세션을 분석해줘"라고 요청하세요. 직접 만든 스킬 대신 원본 플러그인의 실행 기록으로 session-analyzer를 체험할 수 있습니다.
### 4단계: Day 4 종합 정리
모든 검증이 끝났다면, 오늘 배운 것을 정리합니다. Claude Code에 아래와 같이 입력하세요:
```
오늘 Day 4에서 배운 것을 정리해줘:
1. session-wrap 스킬 구조
2. 직접 만들어본 경험
3. history-insight로 분석한 것
4. session-analyzer로 검증한 것
```
> Claude가 오늘 과정 전체를 요약해줍니다. 이 요약을 나중에 다시 보면 복습이 됩니다.
## QUIZ
> Block 4는 Day 4의 마지막 블록입니다. 종합 퀴즈로 오늘 배운 것을 정리합니다.
### Quiz 4: Day 4 종합
```json
AskUserQuestion({
"questions": [{
"question": "Day 4 종합: 스킬을 만들고 -> 실행하고 -> 검증하는 전체 과정에서, 가장 중요한 원칙은?",
"header": "Quiz 4",
"options": [
{"label": "만들기 -> 실행 -> 검증의 반복 (iteration)", "description": "한 번에 완벽할 수 없으므로 반복하면서 개선"},
{"label": "처음부터 완벽한 SKILL.md 작성", "description": "설계가 완벽하면 검증이 불필요"},
{"label": "가능한 많은 에이전트 사용", "description": "에이전트가 많을수록 좋은 결과"}
],
"multiSelect": false
}]
})
```
정답: 만들기 -> 실행 -> 검증의 반복 (iteration)
피드백: "정확합니다! 스킬 개발은 한 번에 완벽할 수 없습니다. **만들기(Block 1) -> 실행(Block 2) -> 검증(Block 4)의 반복**이 핵심입니다. session-analyzer가 이 검증을 자동화해주므로, 빠르게 문제를 발견하고 수정할 수 있습니다. 이 'iteration' 사이클이 AI 네이티브 업무 방식의 핵심입니다."
---
## 마무리
여기까지 오신 것을 축하합니다! 오늘 여러분은 AI에게 "일을 시키는 구조"를 직접 설계하고 실행해봤습니다.
Day 4를 통해 배운 3가지 핵심:
1. **Multi-agent 패턴**: 여러 전문가에게 동시에 일을 시키고, 결과를 검증하는 구조
2. **스킬 만들기**: SKILL.md 하나로 나만의 자동화 워크플로우 구축
3. **검증 루프**: 만들고 -> 실행하고 -> 분석하는 반복이 품질을 만든다
> 다음 Day에서는 이 패턴을 더 확장하여 자신만의 워크플로우를 구축합니다.
references/block5-content-experience.md
# Block 5: 콘텐츠 소화 체험 — Fetch & Digest
> 공식 문서: https://code.claude.com/docs/ko/skills
## EXPLAIN
### 1. 콘텐츠 소화 파이프라인
Day 4의 마지막 블록입니다. 지금까지 session-wrap, history-insight, session-analyzer로 "내 작업을 분석하는 스킬"을 만들었습니다. 이제 **외부 콘텐츠를 가져와서 소화하는** 방법을 체험합니다.
**비유: 외국 음식 먹기**
1. **메뉴 가져오기 (Fetch)**: 영어 트윗이나 아티클을 가져온다
2. **번역하기 (Translate)**: 요약 → 인사이트 → 전체 번역 순서로 이해한다
3. **소화하기 (Digest)**: 퀴즈를 풀며 기억에 남긴다
### 2. 스킬 체이닝 (Skill Chaining)
**비유: 공장 생산라인**
```
[URL 입력] → [fetch 스킬: 원문 추출 + 번역] → [digest 스킬: 퀴즈-학습]
```
앞 스킬의 결과물을 다음 스킬이 받아서 처리합니다. 이것이 **스킬 체이닝**입니다.
### 3. fetch-tweet: 트윗 가져오기
X/Twitter URL을 받으면:
1. **FxEmbed API**로 트윗 텍스트, 작성자, 반응 수치를 추출
2. **번역 파이프라인**: 요약(3-5문장) → 인사이트(3개) → 전체 번역
```
원래 URL: https://x.com/user/status/123456
변환 URL: https://api.fxtwitter.com/user/status/123456
```
도메인만 바꾸면 트윗 데이터가 JSON으로 옵니다. 왜 요약부터? **전체 번역을 먼저 보면 핵심을 놓치기 쉽습니다.** 요약으로 핵심을 잡고, 인사이트로 의미를 파악한 뒤, 전체를 읽으면 이해도가 훨씬 높아집니다.
### 4. content-digest: Quiz-First 학습법
가져온 콘텐츠를 "소화"하는 스킬입니다.
**핵심 원칙: "요약을 먼저 보여주지 않는다"**
보통은 요약을 읽고 → 퀴즈를 풀지만, 연구에 따르면 **반대로 하는 것이 9-12% 더 효과적**입니다.
```
❌ 일반적 순서: 요약 읽기 → 퀴즈
✅ Quiz-First: 퀴즈 먼저 → 틀린 부분 확인 → 선택적으로 읽기
```
- **Pretesting Effect**: 학습 전 테스트가 기억력을 9-12% 향상 (Richland et al.)
- **Information Gap Theory**: 틀린 문제가 "궁금함"을 만들고, 궁금함이 도파민 → 기억 강화
**간단히 말해: 틀려야 배운다.**
### 5. 오늘 체험할 것
직접 스킬을 만들지 않고, 이미 설치된 스킬을 **체험**합니다:
| 체험 | 하는 일 | 시간 |
|------|---------|------|
| fetch-tweet 체험 | 실제 영어 트윗을 가져와서 번역 파이프라인 확인 | ~5분 |
| content-digest 체험 | 설치된 content-digest 스킬로 Quiz-First 학습 | ~5분 |
| compound 체험 | 오늘 배운 인사이트를 구조화된 문서로 기록 | ~5분 |
| team-assemble 소개 | 전문가 에이전트 팀 구성 개념 이해 | ~5분 |
> 스킬을 직접 만들고 싶다면, 캠프 이후 `day5-fetch-and-digest` 스킬로 심화 학습할 수 있습니다.
> **보너스 스킬**: compound는 작업 중 발견한 인사이트를 `knowledge/` 폴더에 구조화해서 저장합니다. team-assemble은 복잡한 작업을 전문가 에이전트 팀으로 나눠서 병렬 실행합니다. 둘 다 이미 설치되어 있으니 바로 체험할 수 있습니다.
---
## EXECUTE
### 체험 1: fetch-tweet으로 트윗 가져오기
좋아하는 영어 트윗 URL을 하나 찾으세요. AI, 기술, 비즈니스 관련 트윗이면 더 좋습니다.
Claude에게 이렇게 입력하세요:
```
이 트윗을 요약-인사이트-전체 번역 해줘: [여기에 실제 X/Twitter URL]
```
> **결과를 확인하세요:**
> - 요약이 핵심을 잘 잡았는지
> - 인사이트가 실제로 유용한지
> - 전체 번역이 자연스러운지
### 체험 2: content-digest로 Quiz-First 학습
방금 가져온 트윗 내용으로 퀴즈를 풀어봅니다:
```
/content-digest [방금 가져온 트윗 URL 또는 내용을 붙여넣기]
```
> content-digest 스킬이 자동으로 Quiz-First 방식을 적용합니다. 요약을 먼저 보여주지 않고 퀴즈부터 출제합니다.
> 퀴즈를 풀고 난 후의 느낌이 다릅니다:
> - 틀린 문제가 있으면 "왜 틀렸지?"라는 호기심이 생깁니다
> - 그 상태에서 내용을 다시 읽으면 기억에 더 잘 남습니다
### 체험 3: compound로 인사이트 기록
Day 4에서 가장 인상 깊었던 것을 compound 스킬로 기록해봅니다:
```
/compound
```
Claude가 인사이트를 어떤 도메인(work/learning/project/tool/personal)에 기록할지 물어볼 것입니다. 답변하면 구조화된 문서가 `knowledge/` 폴더에 생성됩니다.
> 예: "session-wrap을 만들면서 multi-agent 패턴의 핵심이 '병렬 실행 + 중복 검증'이라는 걸 알게 됐다"
### (선택) 나만의 콘텐츠 파이프라인 구상
시간이 있다면, 앞으로 어떤 콘텐츠를 자동으로 가져와서 학습할지 생각해보세요:
- 매일 아침 특정 인플루언서의 트윗을 가져와서 학습?
- YouTube 발표 영상을 자동으로 요약?
- 여러 소스를 모아서 주간 다이제스트?
```
나는 [분야]에 관심이 있어. 콘텐츠 소화 파이프라인을 어떻게 구성하면 좋을지 제안해줘.
```
### (선택) team-assemble 맛보기
여러 에이전트가 협력하는 팀을 구성해볼 수 있습니다:
```
/team-assemble 내 프로젝트의 README를 분석하고, 개선점을 제안하고, 실제로 수정해줘
```
> team-assemble은 작업을 분석 → 팀 설계 → 병렬 실행 → 검증까지 자동으로 진행합니다. session-wrap에서 배운 multi-agent 패턴이 실전에서 어떻게 쓰이는지 체감할 수 있습니다.
---
## QUIZ
```json
AskUserQuestion({
"questions": [
{
"question": "fetch-tweet에서 번역 순서가 '요약 → 인사이트 → 전체 번역'인 이유는?",
"header": "Quiz 5-1",
"options": [
{"label": "API가 그 순서로 데이터를 반환하니까", "description": "FxEmbed API의 응답 구조 때문"},
{"label": "전체 번역을 먼저 보면 핵심을 놓치기 쉬우니까", "description": "요약으로 핵심을 잡고 인사이트로 의미를 파악한 뒤 전체를 읽으면 이해도 향상"},
{"label": "Claude의 토큰 제한 때문에 단계별로 처리해야 하니까", "description": "컨텍스트 윈도우 관리를 위해"}
],
"multiSelect": false
},
{
"question": "Quiz-First 학습법에서 '요약을 먼저 보여주지 않는' 이유는?",
"header": "Quiz 5-2",
"options": [
{"label": "요약이 부정확할 수 있으니까", "description": "AI 요약의 정확도 문제"},
{"label": "틀린 문제가 호기심을 만들고, 호기심이 기억을 강화하니까", "description": "학습 전 테스트가 기억력을 9-12% 향상시킨다는 연구"},
{"label": "퀴즈로 수준을 파악해야 맞춤 요약을 줄 수 있으니까", "description": "수준별 맞춤 학습을 위한 선행 평가"}
],
"multiSelect": false
}
]
})
```
**정답 5-1: 2번.** 전체 번역부터 보면 핵심을 놓치기 쉽다. 요약으로 "이 트윗이 뭘 말하는지" 파악하고, 인사이트로 "나에게 어떤 의미인지" 정리한 뒤, 전체를 읽으면 맥락 속에서 이해도가 훨씬 높아진다.
**정답 5-2: 2번.** Pretesting Effect 연구에 따르면 학습 전 테스트가 기억력을 9-12% 향상시킨다. 퀴즈에서 틀리면 "왜 틀렸지?"라는 호기심(Information Gap)이 생기고, 이 상태에서 콘텐츠를 읽으면 기억이 더 잘 남는다.
### Day 4 마무리
4일간의 캠프를 돌아봅니다:
| Day | 배운 것 | 만든 것 |
|-----|---------|---------|
| Day 1 | Claude Code 핵심 기능 7개 | Memory, 첫 스킬, Plugin 설치 |
| Day 2 | MCP + Context Sync | MCP 연결, Context Sync 스킬 |
| Day 3 | Clarify + Plugin + GitHub | 나만의 Clarify 스킬, PRD 제출 |
| Day 4 | Wrap & Analyze + 콘텐츠 소화 | session-wrap 스킬, content-digest 체험, compound 기록, team-assemble 소개 |
> **수료가 아니라 시작입니다.** Claude Code라는 불을 다루는 신인류 커뮤니티의 일원이 되었습니다.
> 만든 스킬을 매일 사용하면서 개선해보세요. 실제 사용이 최고의 학습입니다.
SKILL.md
---
name: day4-wrap-and-analyze
description: AI Native Camp Day 4 Wrap & Analyze + 콘텐츠 소화. session-wrap 스킬을 직접 만들고, history-insight와 session-analyzer로 세션을 분석하고, 콘텐츠 소화 파이프라인을 체험한다. "4일차", "Day 4", "wrap", "세션 분석", "session wrap", "세션 래핑", "fetch", "콘텐츠" 요청에 사용.
---
# Day 4: Wrap & Analyze
이 스킬이 호출되면 아래 **STOP PROTOCOL**을 반드시 따른다.
---
## 용어 정리
이 스킬에서 사용하는 핵심 용어:
| 용어 | 설명 |
|------|------|
| **session-wrap** | 코딩 세션이 끝날 때 작업을 정리하고 문서화하는 스킬. "퇴근 전 책상 정리" |
| **multi-agent** | 여러 에이전트가 동시에 일하는 패턴. "회의에서 각 팀장에게 동시에 보고 받기" |
| **병렬(Parallel)** | 여러 작업을 동시에 처리하는 것. "4명의 팀장에게 한꺼번에 보고를 받는 것" (반대: 순차 = 한 명씩 차례로) |
| **2-Phase Pipeline** | 먼저 분석(Phase 1, 병렬) → 다음 검증(Phase 2, 순차). "전문가 의견 수집 후 팀장이 중복 체크" |
| **frontmatter** | 스킬 파일 맨 위에 `---`로 감싸서 적는 "이름표". 스킬의 이름(name)과 설명(description)을 여기에 적는다 |
| **history-insight** | 과거 세션 기록을 분석해 인사이트를 추출하는 스킬 |
| **session-analyzer** | 스킬이 의도대로 실행됐는지 검증하는 분석 도구 |
| **플러그인(Plugin)** | 외부에서 설치한 스킬 모음. 스킬이 여러 개 묶여 있는 "스킬 패키지" |
| **fetch** | 외부에서 데이터를 가져오는 것. "배달 주문처럼 URL만 주면 내용이 도착" |
| **digest** | 가져온 내용을 소화(요약·퀴즈·학습)하는 것. "읽고 끝이 아니라 씹어서 내 것으로 만들기" |
| **스킬 체이닝** | 하나의 스킬 결과를 다른 스킬의 입력으로 연결하는 것. "fetch → digest 파이프라인" |
| **Quiz-First** | 요약을 먼저 보지 않고 퀴즈부터 푸는 학습법. 9-12% 기억력 향상 효과 |
| **compound** | 작업 중 검증된 인사이트를 구조화된 문서로 기록하는 스킬. "배운 것을 노트에 정리하고 나중에 검색" |
| **team-assemble** | 복잡한 작업을 전문가 팀으로 나눠서 병렬 실행하는 스킬. "프로젝트별 TF팀 자동 구성" |
| **content-digest** | 가져온 콘텐츠를 Quiz-First 방식으로 소화하는 스킬. "읽기만 하지 말고 퀴즈로 체화" |
---
## STOP PROTOCOL — 절대 위반 금지
> 이 프로토콜은 이 스킬의 최우선 규칙이다.
> 아래 규칙을 위반하면 수업이 망가진다.
### 각 블록은 반드시 2턴에 걸쳐 진행한다
```
┌─ Phase A (첫 번째 턴) ──────────────────────────────┐
│ 1. references/에서 해당 블록 파일의 EXPLAIN 섹션을 읽는다 │
│ 2. 기능을 설명한다 │
│ 3. references/에서 해당 블록 파일의 EXECUTE 섹션을 읽는다 │
│ 4. "지금 직접 실행해보세요"라고 안내한다 │
│ 5. ⛔ 여기서 반드시 STOP. 턴을 종료한다. │
│ │
│ ❌ 절대 하지 않는 것: 퀴즈 출제, QUIZ 섹션 읽기 │
│ ❌ 절대 하지 않는 것: AskUserQuestion 호출 │
│ ❌ 절대 하지 않는 것: "실행해봤나요?" 질문 │
└──────────────────────────────────────────────────────────┘
⬇️ 사용자가 돌아와서 "했어", "완료", "다음" 등을 입력한다
┌─ Phase B (두 번째 턴) ──────────────────────────────┐
│ 1. references/에서 해당 블록 파일의 QUIZ 섹션을 읽는다 │
│ 2. AskUserQuestion으로 퀴즈를 출제한다 │
│ 3. 정답/오답 피드백을 준다 │
│ 4. 다음 블록으로 이동할지 AskUserQuestion으로 묻는다 │
│ 5. ⛔ 다음 블록을 시작하면 다시 Phase A부터. │
└──────────────────────────────────────────────────────────┘
```
### 핵심 금지 사항 (절대 위반 금지)
1. **Phase A에서 AskUserQuestion을 호출하지 않는다** — 설명 + 실행 안내 후 바로 Stop
2. **Phase A에서 퀴즈를 내지 않는다** — QUIZ 섹션은 Phase B에서만 읽는다
3. **Phase A에서 "실행해봤나요?"를 묻지 않는다** — 사용자가 먼저 말할 때까지 기다린다
4. **한 턴에 EXPLAIN + QUIZ를 동시에 하지 않는다** — 반드시 2턴으로 나눈다
### 공식 문서 URL 출력 (절대 누락 금지)
모든 블록의 Phase A 시작 시, 해당 reference 파일 상단의 `> 공식 문서:` URL을 **반드시 그대로 출력**한다.
```
📖 공식 문서: [URL]
```
- reference 파일에 URL이 여러 개 있으면 전부 출력한다
- URL을 요약하거나 생략하지 않는다
### Phase A 종료 시 필수 문구
Phase A의 마지막에는 반드시 아래 형태의 문구를 출력하고 Stop한다:
```
---
👆 위 내용을 직접 실행해보세요.
실행이 끝나면 "완료" 또는 "다음"이라고 입력해주세요.
```
이 문구 이후에 어떤 도구 호출(AskUserQuestion 포함)이나 추가 텍스트도 출력하지 않는다.
---
## 소요 시간 가이드
| Block | 주제 | 예상 시간 |
|-------|------|-----------|
| 0 | 개념 이해 | ~10분 |
| 1 | 스킬 만들기 | ~30분 |
| 2 | 실행 & 검증 | ~15분 |
| 3 | History Insight | ~10분 |
| 4 | Session Analyzer | ~15분 |
| 5 | 콘텐츠 소화 체험 + 보너스 스킬 + 마무리 | ~25분 |
| **합계** | | **~105분** |
> 참가자 속도에 따라 90~110분 소요될 수 있습니다. Block 1이 가장 시간이 오래 걸리는 핵심 블록입니다. Block 5(콘텐츠 소화)는 체험 중심이라 빠르게 진행됩니다.
---
## 핵심 전략: 원본 스킬을 해체하며 배우기
아래 방식으로 진행한다:
1. Block 0에서 session-wrap 스킬의 구조와 multi-agent 원리를 이해한다
2. Block 1에서 참가자가 session-wrap 스킬의 SKILL.md를 직접 작성한다 (단계별 안내)
3. Block 2에서 직접 만든 스킬을 실행하고 결과를 확인한다
4. Block 3에서 history-insight로 과거 세션 기록을 분석한다
5. Block 4에서 session-analyzer로 스킬 실행을 검증한다
6. Block 5에서 콘텐츠 소화 파이프라인(fetch-tweet + content-digest)을 체험한다
7. Block 5에서 content-digest로 콘텐츠 소화 파이프라인(fetch-tweet → content-digest)을 체험한다
8. Block 5 선택 실습에서 compound로 인사이트를 기록하고, team-assemble로 에이전트 팀 구성을 경험한다
> session-wrap 원본은 플러그인에 설치되어 있다. 참가자는 이를 참고하면서 자기만의 버전을 만든다.
---
## 블록 특수 규칙
- **Block 0 (개념 이해)**: Phase A에서 multi-agent 개념 설명 + session-wrap 원본 구조 분석 안내 → Stop. Phase B에서 퀴즈.
- **Block 1 (스킬 만들기)**: Phase A에서 SKILL.md를 Step-by-Step으로 작성하는 방법 안내 → 참가자가 직접 작성 → Stop. Phase B에서 작성한 스킬 구조 퀴즈. (가장 긴 블록 — 완료 후 "여기까지 잘 따라오셨습니다!" 격려)
- **Block 2 (실행 & 검증)**: Phase A에서 만든 스킬 실행 + 결과 확인 안내 → Stop. Phase B에서 실행 결과 퀴즈.
- **Block 3 (History Insight)**: Phase A에서 history-insight 스킬 소개 + 실행 안내 → Stop. Phase B에서 퀴즈.
- **Block 4 (Session Analyzer)**: Phase A에서 session-analyzer 소개 + 실행 안내 → Stop. Phase B에서 퀴즈.
- **Block 5 (콘텐츠 소화 체험)**: Phase A에서 fetch-tweet과 content-digest 개념 설명 + 실제 트윗으로 체험 안내 + compound/team-assemble 소개 → Stop. Phase B에서 종합 퀴즈 + 4일 캠프 마무리.
---
## References 파일 맵
| 블록 | 파일 | 주제 |
|------|------|------|
| Block 0 | `references/block0-concept.md` | Multi-agent 패턴 + session-wrap 개념 |
| Block 1 | `references/block1-build-session-wrap.md` | session-wrap 스킬 직접 만들기 |
| Block 2 | `references/block2-run-session-wrap.md` | 만든 스킬 실행 + 검증 |
| Block 3 | `references/block3-history-insight.md` | history-insight 실습 |
| Block 4 | `references/block4-session-analyzer.md` | session-analyzer 실습 |
| Block 5 | `references/block5-content-experience.md` | 콘텐츠 소화 체험 (fetch-tweet + content-digest + 보너스 스킬) |
> 파일 경로는 이 SKILL.md 기준 상대경로다.
> 각 reference 파일은 `## EXPLAIN`, `## EXECUTE`, `## QUIZ` 섹션으로 구성된다.
---
## 진행 규칙
- 한 번에 한 블록씩 진행한다
- "다음", "skip", 블록 번호/이름으로 이동한다
- Block 1에서 생성한 스킬 파일을 Block 2에서 실행한다
- 참가자의 프로젝트에 `.claude/skills/my-session-wrap/SKILL.md`를 생성한다
- Claude Code 관련 질문이 오면 claude-code-guide 에이전트(내장 도구)로 답변한다. 답변 후 사용자가 직접 따라할 수 있게 단계별로 안내하고, 질문할 때는 AskUserQuestion을 사용한다. 내장 에이전트 답변이 부정확하다고 판단되면, 공식 문서를 `curl`로 파일에 저장한 뒤 Read 툴로 꼼꼼히 읽고 정확한 정보로 다시 답한다 (WebFetch는 요약/손실 위험이 있으므로 사용하지 않는다)
---
## 시작
스킬 시작 시 **먼저 최신 커리큘럼을 설치**한 뒤 블록을 선택한다.
### Step 1: 최신 스킬 업데이트 (필수!)
> **Day 4부터 새로운 스킬이 대거 추가되었습니다!** 아래 명령어로 반드시 업데이트하세요.
> 업데이트하지 않으면 오늘 실습에서 사용할 스킬이 없습니다.
아래 명령어를 출력하고 Bash로 실행한다:
```bash
npx skills add ai-native-camp/camp-2 --agent claude-code --yes
```
실행 결과를 간략히 안내하고, 새로 추가된 스킬 목록을 보여준다:
| 새로 추가된 스킬 | 설명 |
|-----------------|------|
| session-wrap | 세션 종료 시 작업을 자동 정리하는 multi-agent 스킬 |
| history-insight | 과거 세션 기록을 분석해 인사이트를 추출 |
| session-analyzer | 스킬이 의도대로 실행됐는지 검증 |
| fetch-tweet | X/Twitter 트윗을 가져와서 번역·요약 |
| content-digest | 콘텐츠를 Quiz-First 방식으로 소화·학습 |
| compound | 작업 중 발견한 인사이트를 구조화된 문서로 축적 |
| team-assemble | 복잡한 작업을 전문가 에이전트 팀으로 분해·실행 |
### Step 2: 블록 선택
아래 테이블을 보여주고 AskUserQuestion으로 어디서 시작할지 물어본다.
| Block | 주제 | 내용 |
|-------|------|------|
| 0 | 개념 이해 | Multi-agent 패턴, session-wrap이란? |
| 1 | 스킬 만들기 | session-wrap SKILL.md 직접 작성 |
| 2 | 실행 & 검증 | 만든 스킬 실행 + 결과 확인 |
| 3 | History Insight | 세션 히스토리 분석 실습 |
| 4 | Session Analyzer | 세션 실행 검증 실습 |
| 5 | 콘텐츠 소화 체험 | fetch-tweet + Quiz-First 체험 + 마무리 |
```json
AskUserQuestion({
"questions": [{
"question": "Day 4: Wrap & Analyze\n\n어디서부터 시작할까요?",
"header": "시작 블록",
"options": [
{"label": "처음부터 (Block 0)", "description": "Multi-agent 패턴과 session-wrap 개념부터 차근차근"},
{"label": "스킬 만들기 (Block 1)", "description": "개념을 이미 알면 바로 스킬 작성하기"},
{"label": "실행 & 검증 (Block 2)", "description": "스킬을 이미 만들었으면 실행 + 결과 확인"},
{"label": "분석 도구 (Block 3~4)", "description": "history-insight와 session-analyzer 실습부터"},
{"label": "콘텐츠 소화 (Block 5)", "description": "fetch-tweet + content-digest + compound + team-assemble 체험"}
],
"multiSelect": false
}]
})
```
> 시작 블록 선택 후 → 해당 블록의 Phase A부터 진행한다.