Day2 Create Context Sync Skill

Day 2: 나만의 Context Sync 스킬 만들기

이 스킬이 호출되면 아래 STOP PROTOCOL을 반드시 따른다.

---

용어 정리

이 스킬에서 사용하는 핵심 용어:

---

STOP PROTOCOL — 절대 위반 금지

이 프로토콜은 이 스킬의 최우선 규칙이다.

아래 규칙을 위반하면 수업이 망가진다.

각 블록은 반드시 2턴에 걸쳐 진행한다

┌─ Phase A (첫 번째 턴) ──────────────────────────────┐
│ 1. references/에서 해당 블록 파일의 EXPLAIN 섹션을 읽는다    │
│ 2. 기능을 설명한다                                        │
│ 3. references/에서 해당 블록 파일의 EXECUTE 섹션을 읽는다    │
│ 4. "지금 직접 실행해보세요"라고 안내한다                     │
│ 5. ⛔ 여기서 반드시 STOP. 턴을 종료한다.                    │
│                                                          │
│ ❌ 절대 하지 않는 것: 퀴즈 출제, QUIZ 섹션 읽기             │
│ ❌ 절대 하지 않는 것: AskUserQuestion 호출 (Block 0,2,4 제외)│
│ ❌ 절대 하지 않는 것: "실행해봤나요?" 질문                   │
└──────────────────────────────────────────────────────────┘

  ⬇️ 사용자가 돌아와서 "했어", "완료", "다음" 등을 입력한다

┌─ Phase B (두 번째 턴) ──────────────────────────────┐
│ 1. references/에서 해당 블록 파일의 QUIZ 섹션을 읽는다       │
│ 2. AskUserQuestion으로 퀴즈를 출제한다                     │
│ 3. 정답/오답 피드백을 준다                                 │
│ 4. 다음 블록으로 이동할지 AskUserQuestion으로 묻는다         │
│ 5. ⛔ 다음 블록을 시작하면 다시 Phase A부터.                │
└──────────────────────────────────────────────────────────┘

핵심 금지 사항 (절대 위반 금지)

1. Phase A에서 AskUserQuestion을 호출하지 않는다 (Block 0, 2, 4 제외) — 이 3개 블록은 사용자 선택이 필수이므로 예외 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 포함)이나 추가 텍스트도 출력하지 않는다.

---

핵심 전략: 템플릿 먼저, 단계별 커스터마이징

아래 방식으로 진행한다:

1. Block 0에서 사용자가 도구를 선택하면, templates/context-sync.md 기반으로 스킬 파일을 즉시 생성한다 2. 이후 Block 1~5에서 생성된 스킬의 해당 부분만 수정/확장한다 3. 최종적으로 완성된 스킬을 실행하여 결과를 확인한다

템플릿에는 Slack, Notion, Gmail, Google Calendar 4가지 도구의 예시가 포함되어 있다.

사용자가 선택한 도구 조합에 맞춰 필요한 부분만 남기고, 새 도구는 같은 패턴으로 추가한다.

블록-템플릿 섹션 매핑

각 블록에서 수정하는 템플릿 영역:

---

블록 특수 규칙

• Block 0 (도구 선택 + 스킬 생성): Phase A에서 설명 + AskUserQuestion으로 도구 선택. 선택 결과로 템플릿 기반 스킬 생성 → Stop. Phase B에서 생성된 스킬 확인 퀴즈.
• Block 1 (프로젝트 탐색): Phase A에서 Explore 에이전트로 프로젝트 구조를 파악하고 결과 공유 → Stop. Phase B에서 퀴즈.
• Block 2 (도구 연결): Phase A에서 MCP vs API 선택 안내 + AskUserQuestion → Claude가 설정을 대신 수행하고 사용자는 결과를 확인 → Stop. Phase B에서 퀴즈.
• Block 3 (수집 실행 & 검증): Phase A에서 subagent 병렬 수집 설명 + 실행 → 수집 결과를 성공/실패로 구분하여 보여주기 → 실패한 소스 재시도 + 수집 데이터 품질 확인 → Stop. Phase B에서 퀴즈.
• Block 4 (Output 설정): Phase A에서 Output format 선택 안내 + AskUserQuestion → 선택에 따라 스킬 수정 → Stop. Phase B에서 퀴즈.
• Block 5 (완성 + 실행): Phase A에서 최종 스킬 구성 정리 + 실제 실행 → Stop. Phase B에서 종합 퀴즈 + 마무리.

Block 0 예외 규칙

Block 0의 Phase A는 AskUserQuestion을 사용한다. 도구 선택이 이후 모든 블록의 전제 조건이므로 반드시 사용자 입력을 받아야 한다.

Phase A 진행 순서: 1. references/block0-tool-selection.md의 EXPLAIN 섹션을 읽고 설명한다 2. AskUserQuestion으로 도구를 선택받는다 (multiSelect: true) 3. templates/context-sync.md 템플릿을 읽는다 4. 선택된 도구에 맞춰 사용자의 프로젝트에 .claude/skills/my-context-sync/SKILL.md를 생성한다 5. 생성된 파일의 전체 구조만 간략히 보여주고 Stop한다 (세부 내용은 이후 블록에서)

Block 2 예외 규칙

Block 2의 Phase A도 AskUserQuestion을 사용한다. 각 도구별로 MCP와 API 중 연결 방식을 선택해야 한다.

핵심 원칙: Claude가 설정을 대신 수행하고, 사용자는 결과를 확인한다.

MCP 선택 시: 1. references/block2-tool-connection.md의 MCP 안내를 따른다 2. scripts/mcp_servers.py를 사용하여 GitHub README.md에서 적합한 MCP 서버를 검색한다 3. 검색 결과를 보여주고, Claude가 .mcp.json에 서버를 등록한다 4. /mcp 명령으로 서버 연결 상태를 함께 확인한다

API 선택 시: 1. Claude가 직접 API 호출 코드를 작성한다 2. 사용자의 스킬 scripts/ 폴더에 저장한다

Block 4 예외 규칙

Block 4의 Phase A도 AskUserQuestion을 사용한다. Output format을 선택해야 한다.

---

References 파일 맵

파일 경로는 이 SKILL.md 기준 상대경로다.

각 reference 파일은 ## EXPLAIN, ## EXECUTE, ## QUIZ 섹션으로 구성된다.

---

Templates / Scripts 파일 맵

Gmail/Calendar 등의 수집 스크립트는 Block 2에서 Claude가 사용자의 선택에 맞춰 직접 작성한다.

---

진행 규칙

• 한 번에 한 블록씩 진행한다
• "다음", "skip", 블록 번호/이름으로 이동한다
• Block 0에서 생성한 스킬 파일을 이후 블록에서 점진적으로 수정한다
• 사용자 프로젝트의 .claude/skills/my-context-sync/ 디렉토리에 스킬을 생성한다
• Explore 에이전트와 subagent 사용이 핵심이므로 적극 활용한다
• Claude Code 관련 질문이 오면 claude-code-guide 에이전트(내장 도구)로 답변한다. 답변 후 사용자가 직접 따라할 수 있게 단계별로 안내하고, 질문할 때는 AskUserQuestion을 사용한다. 내장 에이전트 답변이 부정확하다고 판단되면, 공식 문서를 curl로 파일에 저장한 뒤 Read 툴로 꼼꼼히 읽고 정확한 정보로 다시 답한다

---

시작

스킬 시작 시 먼저 최신 커리큘럼을 설치한 뒤 블록을 선택한다.

Step 1: 최신 스킬 설치

아래 명령어를 출력하고 Bash로 실행한다:

npx skills add ai-native-camp/camp-1 --agent claude-code --yes

실행 결과를 간략히 안내한다 (예: "4개 스킬이 최신 버전으로 설치되었습니다").

Step 2: 블록 선택

아래 테이블을 보여주고 AskUserQuestion으로 어디서 시작할지 물어본다.

AskUserQuestion({
  "questions": [{
    "question": "Day 2: 나만의 Context Sync 스킬 만들기\n\n어디서부터 시작할까요?",
    "header": "시작 블록",
    "options": [
      {"label": "처음부터 (Block 0)", "description": "sync할 도구 고르기 + 스킬 골격 생성"},
      {"label": "도구 연결 (Block 2)", "description": "도구 선택은 했고, MCP/API 연결부터"},
      {"label": "수집 실행 & 검증 (Block 3)", "description": "연결 완료, 수집부터"},
      {"label": "Output 설정 (Block 4)", "description": "수집 완료, 출력 형식부터"}
    ],
    "multiSelect": false
  }]
})

시작 블록 선택 후 → 해당 블록의 Phase A부터 진행한다.

Block 0: 도구 선택 + 스킬 생성

EXPLAIN

Context Sync란?

매일 아침 출근하면 이런 일을 한다:

1. Slack 열어서 밤새 온 메시지 확인 2. Gmail 열어서 안 읽은 이메일 확인 3. 캘린더 열어서 오늘 일정 확인 4. Notion 열어서 내 태스크 확인 5. Linear 열어서 이슈 확인

5개 앱을 돌아다니며 30분. 매일 반복. 이것이 컨텍스트 스위칭이다.

Context Sync는 이 과정을 자동화한다. Claude Code가 여러 도구에서 정보를 모아서 하나의 문서로 정리해준다. 한 번 만들어두면 "싱크해줘" 한 마디로 끝난다.

평소                              Context Sync 이후
─────────────                    ──────────────────
Slack 열기                        "싱크해줘" (한 마디)
Gmail 열기                              │
Calendar 열기        ──▶          Claude가 알아서 수집
Notion 열기                             │
Linear 열기                       하나의 문서로 정리!
= 30분 소요                       = 1분 소요

Day 1에서 배운 것과의 연결

Day 1 Block 3-2에서 스킬(Skill)을 배웠다. "반복하는 업무를 한 번 저장하면 다음부터 한 줄로 실행하는 업무 레시피." 오늘은 이 스킬을 직접 만든다. 그것도 여러 도구를 연결하는 실전 스킬을.

어떤 도구를 연결해야 할까?

도구를 고르기 전에 이 질문에 답해보자:

"매일 아침 출근해서 가장 먼저 여는 앱이 무엇인가요?"

그 앱이 첫 번째 연결 대상이다. 두 번째는 "그 다음에 여는 앱"이다. 보통 2~3개면 충분하다.

직종별 추천 조합

내가 어떤 일을 하느냐에 따라 연결할 도구가 달라진다:

구체적인 예시: 마케터 민지의 하루

Before (Context Sync 없이) 1. Slack 열기 - 밤새 온 메시지 50개 스크롤 (10분) 2. Gmail 열기 - 광고 대행사 메일, 고객 문의 확인 (10분) 3. Google Analytics 열기 - 어제 캠페인 성과 확인 (5분) 4. Notion 열기 - 이번 주 콘텐츠 일정 확인 (5분) 5. 총 30분, 정작 중요한 건 "오후에 광고 소재 마감" 하나

After (Context Sync 활용) 1. "싱크해줘" 한 마디 (1분) 2. 결과:

• Slack: 디자이너가 광고 소재 시안 공유함 → 피드백 필요
• Gmail: 대행사에서 예산 승인 요청 → 오전 중 회신 필요
• Calendar: 오후 3시 캠페인 리뷰 미팅
• Notion: 블로그 포스트 마감 D-2

3. 바로 중요한 일부터 시작

연결할 수 있는 도구 목록

위 목록 외에도 원하는 도구를 추가할 수 있다. "우리 회사는 Jira를 써요"라면 Jira도 가능하다.

EXECUTE

1단계: 도구 선택

아래 도구 중에서 자신이 실제로 쓰는 도구를 고르세요. 여러 개를 동시에 선택할 수 있습니다.

AskUserQuestion({
  "questions": [{
    "question": "Context Sync에 연결할 도구를 선택하세요. 실제로 사용하는 도구만 고르면 됩니다.",
    "header": "도구 선택",
    "options": [
      {"label": "Slack", "description": "팀 채팅 메시지 수집"},
      {"label": "Gmail", "description": "이메일 수집"},
      {"label": "Google Calendar", "description": "일정 수집"},
      {"label": "Notion", "description": "태스크/문서 수집"},
      {"label": "Linear", "description": "이슈 트래커 수집"},
      {"label": "Fireflies", "description": "미팅록 수집"},
      {"label": "GitHub", "description": "커밋/PR 수집"},
      {"label": "기타", "description": "위에 없는 도구 (직접 입력)"}
    ],
    "multiSelect": true
  }]
})

2단계: 템플릿 기반 스킬 생성

사용자가 도구를 선택하면:

1. templates/context-sync.md를 읽는다 2. 사용자의 프로젝트에 .claude/skills/my-context-sync/SKILL.md를 생성한다 3. 생성 규칙:

• 선택한 도구만 "소스 정의" 섹션에 남긴다
• 선택하지 않은 도구의 소스 섹션은 삭제한다
• 템플릿에 없는 도구(Linear, Fireflies, GitHub, 기타)는 아래 커스터마이징 패턴으로 추가한다:

### 소스 N: {도구명}

| 항목 | 값 |
|------|-----|
| MCP 도구 | `{MCP 도구명 또는 "스크립트"}` |
| 수집 범위 | {범위} |

수집 방법:
{MCP 호출 방법 또는 스크립트 실행 방법}

추출할 정보:
- {항목 1}
- {항목 2}
- {항목 3}

4. "실행 흐름" 섹션의 병렬 수집 부분도 선택한 도구에 맞게 조정한다 5. 소스 번호를 1부터 다시 매긴다

3단계: 생성 결과 확인

생성된 파일의 전체 구조만 간략히 보여준다. 예시:

.claude/skills/my-context-sync/SKILL.md 생성 완료!

구조:
  - 소스 1: Slack (채널 메시지)
  - 소스 2: Notion (태스크)
  - 소스 3: Linear (이슈)
  - 실행 흐름: 3개 소스 병렬 수집 → 통합 → 저장
  - 출력: sync/YYYY-MM-DD-context-sync.md

세부 내용은 이후 블록에서 하나씩 다듬는다. 지금은 골격만 만든 것이다.

QUIZ

AskUserQuestion({
  "questions": [{
    "question": "Context Sync 스킬이 하는 일을 한 문장으로 말하면?",
    "header": "Quiz Block 0",
    "options": [
      {"label": "여러 도구에서 정보를 모아 하나의 문서로 정리한다", "description": "Slack, Gmail, Calendar 등에서 수집 → 통합"},
      {"label": "Slack 메시지만 정리한다", "description": "Slack은 여러 소스 중 하나일 뿐"},
      {"label": "Claude Code를 설치한다", "description": "설치는 Day 1에서 이미 완료"}
    ],
    "multiSelect": false
  }]
})

정답: 1번. Context Sync 스킬은 여러 도구에서 정보를 모아 하나의 문서로 정리하는 스킬이다. Day 1에서 배운 "스킬 = 업무 레시피"를 직접 만드는 것이 오늘의 핵심이다.

Block 1: 프로젝트 탐색

Phase A 시작 시 반드시 아래 형태로 출력한다:

```

📖 공식 문서: https://code.claude.com/docs/ko/sub-agents

```

EXPLAIN

Day 1 복습: Subagent

Day 1 Block 3-4에서 Subagent를 배웠다. "부하 직원처럼 독립된 공간에서 특정 작업을 전담 처리하는 것."

오늘은 그 Subagent 중에서도 Explore 에이전트를 사용한다.

Explore 에이전트란?

Explore 에이전트는 프로젝트의 폴더와 파일을 빠르게 탐색하는 전문 subagent다. 일반 subagent와의 차이는:

Claude ── "이 프로젝트 구조 파악해줘"
  │
  ▼ Task 도구 호출 (subagent_type: Explore)
┌─ Explore 에이전트 ──────────────┐
│ 읽기 전용으로 폴더/파일 탐색     │
│                                │
│ 결과:                           │
│  📁 프로젝트 루트               │
│  ├── .claude/skills/            │
│  ├── .mcp.json                 │
│  ├── .env                      │
│  └── src/                      │
└────────────────────────────────┘
  │
  ▼ 결과 전달
Claude ── "이런 구조입니다. 스킬을 수정하겠습니다"

왜 프로젝트를 탐색하는가?

Block 0에서 스킬의 골격을 만들었다. 하지만 스킬이 잘 동작하려면 프로젝트의 현재 상태를 알아야 한다:

• .claude/skills/my-context-sync/ 가 제대로 생성되었는지
• .mcp.json 이 이미 있는지 (있으면 기존 MCP 설정을 활용할 수 있다)
• .env 파일이 있는지 (환경변수가 이미 설정되어 있을 수 있다)
• 다른 스킬이 이미 존재하는지 (참고할 수 있다)

요리를 시작하기 전에 냉장고를 여는 것과 같다. 뭐가 있는지 먼저 파악해야 빠진 재료를 알 수 있다.

EXECUTE

1단계: Explore 에이전트로 프로젝트 탐색

Claude가 Explore 에이전트를 호출하여 프로젝트 구조를 파악한다.

Claude가 수행:
  Task(
    description="프로젝트 구조 탐색",
    prompt="프로젝트 루트에서 다음을 확인하라:
      1. 전체 폴더 구조 (최대 2단계)
      2. .claude/ 디렉토리 내용
      3. .mcp.json 존재 여부와 내용
      4. .env 파일 존재 여부
      5. 기존 스킬이 있다면 목록",
    subagent_type="Explore"
  )

사용자는 결과를 보기만 하면 된다. Claude가 알아서 탐색하고 정리해준다.

2단계: 탐색 결과를 바탕으로 스킬 조정

Explore 결과를 보고, Block 0에서 생성한 스킬의 내용을 조정한다:

Claude가 스킬의 frontmatter(스킬 설명 부분)와 수집 범위를 프로젝트 환경에 맞게 자동 수정한다.

QUIZ

AskUserQuestion({
  "questions": [
    {
      "question": "Explore 에이전트는 어떤 종류의 subagent인가요?",
      "header": "Quiz Block 1-1",
      "options": [
        {"label": "읽기 전용으로 파일/폴더를 탐색하는 전문 subagent", "description": "파일을 수정하지 않고 구조만 파악"},
        {"label": "파일을 자동으로 수정하는 subagent", "description": "Explore는 읽기 전용"},
        {"label": "외부 서비스에 접속하는 subagent", "description": "외부 연결은 MCP의 역할"}
      ],
      "multiSelect": false
    },
    {
      "question": "스킬을 만든 후 프로젝트를 탐색하는 이유는?",
      "header": "Quiz Block 1-2",
      "options": [
        {"label": "기존 설정(.mcp.json, .env 등)을 파악하여 스킬을 프로젝트에 맞게 조정하려고", "description": "냉장고 열어서 재료 확인하는 것과 같다"},
        {"label": "예쁜 폴더 구조를 보려고", "description": "탐색의 진짜 목적은 스킬 조정"},
        {"label": "Claude Code가 시키니까", "description": "목적이 있어서 하는 것"}
      ],
      "multiSelect": false
    }
  ]
})

정답: 둘 다 1번.

• Explore 에이전트는 읽기 전용 전문 subagent다. 파일을 수정하지 않아 안전하게 프로젝트 구조를 파악할 수 있다.
• 프로젝트 탐색은 기존 설정을 활용하고 스킬을 환경에 맞게 조정하기 위함이다. 요리 전에 냉장고를 확인하는 것과 같다.

Block 2: 도구 연결

Phase A 시작 시 반드시 아래 형태로 출력한다:

```

📖 공식 문서: https://modelcontextprotocol.io/

📖 공식 문서: https://code.claude.com/en/docs/claude-code/mcp

```

EXPLAIN

Day 1 복습: MCP

Day 1 Block 3-3에서 MCP를 배웠다. "Claude와 외부 도구를 연결하는 표준 프로토콜. Slack, Calendar 등을 플러그처럼 꽂는 것."

Block 0에서 도구를 선택하고, Block 1에서 프로젝트를 탐색했다. 이제 선택한 도구를 실제로 연결할 차례다.

도구를 연결하는 3가지 방법

도구를 Claude에 연결하는 방법은 3가지다. 가장 쉬운 것부터 소개한다:

1순위: claude.ai Connectors (클릭 몇 번이면 끝)
──────────────────────────────────────────────
웹 브라우저에서 로그인만 하면 자동으로 연결된다.
마치 스마트폰에서 "Google로 로그인" 버튼 누르는 것과 같다.

2순위: claude mcp add 명령어 (한 줄 입력)
──────────────────────────────────────────────
터미널에 명령어 한 줄을 입력하면 연결된다.
마치 와이파이 비밀번호를 한 번 입력하면 자동 접속되는 것과 같다.

3순위: API 스크립트 (Claude가 코드를 짜줌)
──────────────────────────────────────────────
위 두 가지 방법이 안 되는 도구라면, Claude가 직접 코드를 작성해서 연결한다.
사용자가 코드를 짤 필요는 없다. Claude가 대신 한다.

1순위: claude.ai Connectors

가장 쉬운 방법이다. 웹 브라우저에서 클릭 몇 번이면 끝난다.

① https://claude.ai/settings/connectors 접속
② 연결하고 싶은 서비스 선택 (Slack, Notion 등)
③ 해당 서비스에 로그인
④ "허용" 클릭
⑤ 끝! Claude Code에서 바로 사용 가능

연결이 완료되면 Claude Code에서 /mcp 명령을 입력했을 때 "claude.ai" 섹션에 자동으로 등록되어 있다:

/mcp
→ claude.ai:
→   slack: connected (tools: 11)
→   notion: connected (tools: 8)

Connectors로 연결하면 API 키도 필요 없고, 설정 파일도 건드릴 필요가 없다. 가능하면 이 방법을 먼저 시도하자.

2순위: claude mcp add 명령어

Connectors에 원하는 서비스가 없거나, HTTP MCP 서버 주소를 알고 있다면 명령어 한 줄로 연결할 수 있다.

claude mcp add --transport http slack https://api.slack.com/mcp
claude mcp add --transport http notion https://mcp.notion.com/mcp

이렇게 입력하면 Claude가 자동으로 설정 파일(.mcp.json)을 만들어준다. 직접 파일을 수정할 필요가 없다.

<details> <summary>궁금하면 확인해보세요: .mcp.json 파일이란?</summary>

MCP 서버를 등록하는 설정 파일이다. 프로젝트 루트(최상위 폴더)에 위치한다.

내 프로젝트/
├── .mcp.json          <-- MCP 서버 설정 파일 (여기!)
├── .claude/
│   └── skills/
│       └── my-context-sync/
└── ...

claude mcp add 명령어를 실행하면 이 파일이 자동으로 만들어진다. 예를 들어:

{
  "mcpServers": {
    "slack": {
      "type": "http",
      "url": "https://api.slack.com/mcp"
    },
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    }
  }
}

"어떤 서버를, 어떻게 연결할지" 적어놓는 파일이다. 하지만 대부분의 경우 Claude가 알아서 만들어주므로 직접 수정할 일은 거의 없다.

</details>

3순위: API 스크립트

MCP 서버도 없고 Connectors도 지원하지 않는 도구라면, Claude가 직접 코드를 작성해서 연결한다.

대표적인 도구:
  Gmail       → Claude가 Python 스크립트 작성
  Calendar    → Claude가 Python 스크립트 작성
  Fireflies   → Claude가 Python 스크립트 작성

사용자가 코드를 짤 필요는 전혀 없다. Claude가 코드를 짜고, 테스트까지 해준다.

환경변수 (API 키)란?

2순위, 3순위 방법을 쓸 때는 열쇠가 필요할 수 있다. 이것을 API 키 또는 토큰이라고 부른다.

예시:
  Notion   → Notion API 키
  Gmail    → Google OAuth 인증
  Linear   → Linear API 키

1순위(Connectors)를 사용하면 API 키가 필요 없다. 로그인만 하면 된다.

이 열쇠들은 보안이 중요하므로 .env 파일이나 시스템 환경변수에 저장한다. 코드에 직접 적지 않는다.

연결이 안 되면? (Plan B)

도구 연결은 인증 문제로 막히는 경우가 꽤 있다. 당황하지 말자.

Plan B: Fetch MCP만으로 먼저 진행하기
──────────────────────────────────────
Fetch MCP는 웹페이지의 내용을 가져오는 도구다.
인증이 필요 없는 공개 정보라면 이것만으로도 sync를 만들 수 있다.

설치:
  claude mcp add fetch -- npx -y @anthropic-ai/mcp-fetch@latest

이것만 연결해도 RSS 피드, 공개 API, 웹페이지 등에서 정보를 수집할 수 있다.

이 단계는 캠프 기간 중 천천히 해도 된다. 지금은 연결 가능한 소스만으로 먼저 진행하자. 완벽한 연결보다 동작하는 스킬이 더 중요하다.

EXECUTE

1단계: Connectors로 연결 시도 (1순위)

먼저 가장 쉬운 방법부터 시도한다.

AskUserQuestion({
  "questions": [{
    "question": "claude.ai Connectors로 먼저 연결해볼까요? 웹 브라우저에서 클릭 몇 번이면 됩니다.",
    "header": "Connectors 연결",
    "options": [
      {"label": "Connectors로 연결할게요", "description": "https://claude.ai/settings/connectors 에서 설정. 가장 쉬운 방법"},
      {"label": "이미 Connectors로 연결했어요", "description": "/mcp에서 claude.ai 섹션에 보이는 상태"},
      {"label": "다른 방법으로 할게요", "description": "명령어 입력 또는 API 스크립트 방식으로 진행"}
    ],
    "multiSelect": false
  }]
})

Connectors로 연결하는 경우:

Claude가 안내:

① 브라우저에서 https://claude.ai/settings/connectors 에 접속하세요
② 연결할 서비스(Slack, Notion 등)를 선택하고 로그인하세요
③ 완료되면 터미널에서 /mcp 를 입력해서 확인하세요

연결 확인:
  /mcp
  → claude.ai:
  →   slack: connected (tools: 11)

Connectors로 연결할 수 있는 도구는 이 단계에서 모두 처리한다. 나머지만 2단계, 3단계에서 다른 방법으로 연결한다.

2단계: mcp add 명령어로 연결 (2순위)

Connectors에 없는 도구 중, HTTP MCP 서버가 있는 도구를 연결한다.

Claude가 수행:

① 도구의 MCP 서버 주소 확인
   이미 알려진 주요 서비스:
     Slack:  https://api.slack.com/mcp
     Notion: https://mcp.notion.com/mcp

② 명령어 한 줄로 등록
   claude mcp add --transport http slack https://api.slack.com/mcp

③ 연결 확인
   /mcp
   → slack: connected (tools: 11)

claude mcp add 명령어를 실행하면 Claude가 알아서 .mcp.json 설정 파일을 만들어준다. 직접 파일을 편집할 필요 없다.

사용자가 직접 하는 것:

• 인증이 필요한 경우 브라우저에서 로그인
• /mcp 명령 입력하여 연결 상태 확인

3단계: API 스크립트 연결 (3순위)

MCP 서버가 없는 도구는 Claude가 직접 코드를 작성한다.

Claude가 수행:

① API 문서 조사
   해당 도구의 공식 API 문서를 조사한다.

② 수집 스크립트 작성
   Python 스크립트를 작성하여 스킬의 scripts/ 폴더에 저장한다.
   예: .claude/skills/my-context-sync/scripts/gmail_fetch.py

③ 스크립트 테스트 실행
   작성한 스크립트를 실행하여 데이터가 정상 수집되는지 확인한다.

사용자가 직접 하는 것:

• API 키 발급 (필요한 경우)
• OAuth 인증 (Google 서비스의 경우 브라우저에서 로그인)

4단계: 스킬 파일 업데이트

연결이 완료되면, Claude가 .claude/skills/my-context-sync/SKILL.md의 각 소스에 대해 "수집 방법" 부분을 실제 연결 정보로 업데이트한다.

변경 전 (Block 0에서 생성한 골격):
  수집 방법: (Block 2에서 설정 예정)

변경 후 (실제 연결 정보 반영):
  수집 방법: mcp__claude_ai_Slack__slack_read_channel 호출

QUIZ

AskUserQuestion({
  "questions": [
    {
      "question": "도구를 Claude에 연결하는 가장 쉬운 방법은?",
      "header": "Quiz Block 2-1",
      "options": [
        {"label": "claude.ai Connectors", "description": "웹 브라우저에서 클릭 몇 번이면 끝"},
        {"label": ".mcp.json 파일 직접 수정", "description": "이건 Claude가 알아서 해주는 부분"},
        {"label": "API 스크립트 작성", "description": "이건 MCP가 없는 도구에 쓰는 3순위 방법"}
      ],
      "multiSelect": false
    },
    {
      "question": "MCP 서버가 없는 도구를 연결하려면 어떻게 하나요?",
      "header": "Quiz Block 2-2",
      "options": [
        {"label": "Claude가 API 스크립트를 작성해서 연결한다", "description": "MCP가 없어도 코드로 연결 가능"},
        {"label": "연결할 수 없다", "description": "API 스크립트로 어떤 도구든 연결 가능"},
        {"label": "사용자가 직접 코드를 작성한다", "description": "Claude가 대신 작성해준다"}
      ],
      "multiSelect": false
    }
  ]
})

정답: 둘 다 1번.

• 가장 쉬운 방법은 claude.ai Connectors다. 웹 브라우저에서 로그인만 하면 자동으로 연결된다. 설정 파일도, API 키도 필요 없다.
• MCP 서버가 없는 도구는 Claude가 API 스크립트를 직접 작성하여 연결한다. 비개발자도 걱정할 필요 없다. Claude가 코드를 짜고, 테스트까지 해준다.

Block 3: 수집 실행 & 검증

Phase A 시작 시 반드시 아래 형태로 출력한다:

```

📖 공식 문서: https://docs.claude.com/en/docs/claude-code/sub-agents

```

EXPLAIN

Day 1 복습: Subagent와 Agent Teams

Day 1 Block 3-4에서 배운 Subagent를 기억하시나요?

• Subagent = 부하 직원. Claude가 다른 Claude를 불러서 독립된 공간에서 일을 시키고, 결과만 받는 것
• Agent Teams (Block 3-5) = 프로젝트 팀. 여러 Claude가 서로 소통하면서 협업하는 것

오늘은 이 Subagent를 실전에 적용합니다.

"병렬 수집"이란?

여러 도구에서 동시에 정보를 가져오는 것입니다.

카페로 비유해볼게요.

점심시간, 손님이 한꺼번에 몰린 카페를 상상해보세요.

직원 1명인 카페 (순차 수집)

• 한 명이 주문 받고 → 커피 만들고 → 디저트 준비하고 → 서빙
• 손님 3팀 처리에 30분

직원 3명인 카페 (병렬 수집)

• 한 명은 주문+결제, 한 명은 커피, 한 명은 디저트
• 각자 맡은 일만 집중 → 손님 3팀 처리에 10분

Claude도 마찬가지입니다. "싱크해줘"라고 말하면:

• 직원 A (Slack 담당): 채널 메시지 수집 중...
• 직원 B (Gmail 담당): 이메일 수집 중...
• 직원 C (Calendar 담당): 일정 수집 중...

3명이 동시에 일하고, 다 끝나면 매니저(메인 Claude)가 결과를 모아 하나의 문서로 정리합니다.

❌ 순차 수집 (직원 1명): 90초
  Slack(30초) → Gmail(30초) → Calendar(30초)

✅ 병렬 수집 (직원 3명): 30초
  Slack(30초)    ─┐
  Gmail(30초)     ├── 동시에!
  Calendar(30초)  ─┘

어떻게 동시에 하나?

Claude는 Subagent(부하 직원)를 여러 명 동시에 부릅니다. Day 1에서 배운 그 subagent입니다.

핵심은 3가지:

• 각 subagent는 하나의 도구만 담당합니다 (Slack 담당, Gmail 담당...)
• 서로의 결과를 기다리지 않고 독립적으로 수집합니다
• 모든 subagent가 끝나면, 메인 Claude가 결과를 모아서 통합합니다

<details> <summary>(참고) 기술적 구조가 궁금하다면</summary>

Claude는 Task 도구로 subagent를 여러 개 동시에 호출합니다:

┌─ 메인 Claude ─────────────────────────────────────┐
│                                                   │
│  "싱크 실행해줘" 요청 받음                          │
│                                                   │
│  ┌─ Subagent 1 ─┐  ┌─ Subagent 2 ─┐  ┌─ Subagent 3 ─┐
│  │ Slack 수집    │  │ Gmail 수집    │  │ Calendar 수집  │
│  │ 담당: 채널 3개 │  │ 담당: 이메일   │  │ 담당: 일정     │
│  └──────┬───────┘  └──────┬───────┘  └──────┬────────┘
│         │                │                 │
│         ▼                ▼                 ▼
│      결과 전달         결과 전달          결과 전달
│                                                   │
│  ──▶ 결과 모아서 통합 문서 작성                     │
└───────────────────────────────────────────────────┘

각 subagent는 독립된 실행 환경에서 작동하며, 메인 Claude는 모든 subagent의 결과를 취합합니다.

</details>

Block 0에서 만든 스킬과의 연결

Block 0에서 생성한 스킬의 "실행 흐름 → 1단계: 병렬 수집" 섹션이 바로 이 구조입니다. 스킬 파일에 이미 아래와 같은 내용이 적혀 있습니다:

수집 시작
  ├── [소스 1] Slack 채널 메시지 수집      ─┐
  ├── [소스 2] Gmail 이메일 수집            ├── 병렬 실행
  ├── [소스 3] Google Calendar 일정 수집    │
  └── [소스 4] Notion 태스크 수집           ─┘
수집 완료

이번 블록에서는 이 병렬 수집을 실제로 실행해봅니다.

EXECUTE

실행 안내

Claude에게 아래와 같이 요청하여 Block 0에서 생성한 스킬의 병렬 수집을 실행합니다:

내 context sync 스킬의 병렬 수집을 실행해줘

Claude가 하는 일:

1. 사용자의 .claude/skills/my-context-sync/SKILL.md를 읽어서 소스 목록을 확인합니다 2. 각 소스별로 subagent(Task 도구)를 동시에 호출합니다 3. 사용자의 화면에는 각 subagent의 진행 상황이 표시됩니다:

   [Slack 수집] 진행 중...
   [Gmail 수집] 진행 중...
   [Calendar 수집] 진행 중...

4. 수집이 완료되면 소스별로 결과를 정리하여 보여줍니다

수집 결과 리포트

수집이 끝나면 성공한 소스와 실패한 소스를 구분하여 보여줍니다:

수집 결과:
  Slack: 3개 채널, 47개 메시지 (성공 ✅)
  Gmail: 12개 이메일 (성공 ✅)
  Calendar: 수집 실패 ❌ (원인: 인증 토큰 만료)
  Notion: 15개 태스크 (성공 ✅)

성공: 3/4 소스
실패: 1/4 소스 (다음 블록에서 재시도합니다)

실패한 소스가 있어도 괜찮습니다! 아래 결과 검증 단계에서 실패 원인을 분석하고 재시도합니다.

수집된 데이터 미리보기

각 소스별로 수집된 내용의 요약을 확인합니다:

[Slack 요약]
  - #general: 주간 회의 시간 변경 공지
  - #project-updates: v2.0 배포일 확정
  - 총 47개 메시지 중 중요 5개 추출

[Gmail 요약]
  - 안 읽은 이메일 5개
  - 회신 필요: 2개
  - 총 12개 이메일 중 액션 필요 3개

이 결과가 아래 결과 검증 단계와 Block 4(출력 포맷)에서 활용됩니다.

결과 검증

실패 원인 분류

수집이 실패하는 이유는 크게 4가지입니다:

가장 흔한 원인은 인증/API 키 문제입니다.

데이터 품질 체크

수집에 성공했다고 끝이 아닙니다. 가져온 정보가 실제로 유용한지 확인해야 합니다.

실패한 소스가 있으면 Claude에게 재시도를 요청하고, 데이터 품질이 맞지 않으면 스킬의 "추출할 정보" 섹션을 조정합니다.

QUIZ

AskUserQuestion({
  "questions": [
    {
      "question": "\"병렬 수집\"의 가장 큰 장점은 무엇인가요?",
      "header": "Quiz 3-1",
      "options": [
        {"label": "여러 소스를 동시에 수집하여 시간을 절약한다", "description": "각 subagent가 독립적으로 동시 실행"},
        {"label": "데이터를 더 정확하게 수집한다", "description": "정확도는 병렬/순차와 무관"},
        {"label": "하나가 실패하면 전체가 멈춘다", "description": "오히려 독립 실행이라 다른 소스에 영향 없음"}
      ],
      "multiSelect": false
    },
    {
      "question": "수집이 실패한 소스는 어떻게 처리하나요?",
      "header": "Quiz 3-2",
      "options": [
        {"label": "실패 원인과 함께 리포트하고, 다음 단계에서 재시도한다", "description": "Block 4에서 실패 원인 분석 + 재시도"},
        {"label": "무시하고 넘어간다", "description": "실패한 소스도 중요한 정보일 수 있음"},
        {"label": "전체 수집을 처음부터 다시 한다", "description": "성공한 소스까지 다시 할 필요 없음"}
      ],
      "multiSelect": false
    }
  ]
})

정답: 3-1은 1번, 3-2는 1번.

Quiz 3-3 (결과 검증)

AskUserQuestion({
  "questions": [
    {
      "question": "수집이 실패하는 가장 흔한 원인은 무엇인가요?",
      "header": "Quiz 3-3",
      "options": [
        {"label": "인증/API 키 문제", "description": "키 만료, 오타, 권한 부족 등이 가장 흔함"},
        {"label": "인터넷 연결 문제", "description": "가끔 발생하지만 가장 흔하지는 않음"},
        {"label": "Claude의 버그", "description": "Claude 자체 문제보다는 외부 서비스 연결 문제가 대부분"}
      ],
      "multiSelect": false
    }
  ]
})

정답: 3-3은 1번.

Block 4: Output Format 선택

EXPLAIN

수집한 정보, 어디에 내보낼 것인가?

Block 3에서 여러 소스의 정보를 성공적으로 수집하고 검증했다. 이제 마지막 질문이 남았다:

"이 정보를 어디에, 어떤 형태로 저장하고 공유할 것인가?"

3가지 출력 옵션이 있다.

옵션 1: Markdown 파일 (기본)

수집된 정보 → 프로젝트 폴더에 .md 파일로 저장

• 가장 간단하고 안정적인 방법
• 외부 서비스 연결 없이 바로 사용 가능
• 파일이 프로젝트 안에 남으므로 나중에 다시 찾기 쉬움
• 예: sync/2026-02-15-context-sync.md

옵션 2: Slack 메시지

수집된 정보 → Slack 채널에 요약 메시지로 전송

• 팀원들과 바로 공유할 때 좋음
• 매일 아침 자동으로 보내면 "모닝 브리핑" 역할
• Slack MCP가 연결되어 있어야 사용 가능 (Block 2에서 연결했다면 바로 사용)

옵션 3: Notion 페이지

수집된 정보 → Notion 데이터베이스에 새 페이지로 생성

• 정보가 Notion에 쌓이므로 나중에 검색과 정리가 편함
• 날짜별로 자동 축적되어 기록 관리에 좋음
• Notion MCP가 연결되어 있어야 사용 가능 (Block 2에서 연결했다면 바로 사용)

여러 출력을 동시에 쓸 수도 있다

수집된 정보
  ├── Markdown 파일로 저장 (기록용)     ← 항상 포함
  ├── Slack 채널로 전송 (공유용)        ← 선택
  └── Notion 페이지 생성 (축적용)       ← 선택

Markdown은 기본으로 항상 포함하고, Slack이나 Notion을 추가하면 더 편리해진다. Block 2에서 연결한 도구 중 출력용으로 쓸 수 있는 것이 있다면 함께 활용하는 것을 추천한다.

EXECUTE

AskUserQuestion으로 출력 형식을 선택받는다:

AskUserQuestion({
  "questions": [{
    "question": "수집 결과를 어떤 형식으로 출력할까요?\n\nMarkdown 파일은 기본으로 항상 포함됩니다.\n추가로 Slack이나 Notion 출력을 선택할 수 있습니다.",
    "header": "출력 형식 선택",
    "options": [
      {"label": "Markdown 파일만", "description": "프로젝트 폴더에 .md 파일로 저장 (가장 간단)"},
      {"label": "Markdown + Slack 전송", "description": "파일 저장 + 특정 Slack 채널에 요약 발송"},
      {"label": "Markdown + Notion 페이지", "description": "파일 저장 + Notion DB에 페이지 생성"},
      {"label": "Markdown + Slack + Notion", "description": "세 곳 모두에 출력"}
    ],
    "multiSelect": false
  }]
})

선택 결과에 따라 사용자의 스킬 파일(.claude/skills/my-context-sync/SKILL.md)을 수정한다:

공통 (Markdown 파일):

• "출력 포맷" 섹션에 저장 경로를 확인/수정한다
• 기본 경로: sync/YYYY-MM-DD-context-sync.md
• 사용자가 원하는 경로가 있으면 변경한다

Slack을 선택한 경우:

• Slack MCP가 연결되어 있는지 확인한다
• 연결되어 있지 않으면 Block 2 방식으로 연결을 안내한다
• 전송할 채널명을 묻고 스킬에 반영한다
• "출력 포맷" 섹션에 Slack 전송 단계를 추가한다:

  mcp__claude_ai_Slack__slack_send_message(channel="채널명", content="요약 내용")

Notion을 선택한 경우:

• Notion MCP가 연결되어 있는지 확인한다
• 연결되어 있지 않으면 Block 2 방식으로 연결을 안내한다
• 데이터베이스 ID를 묻고 스킬에 반영한다
• "출력 포맷" 섹션에 Notion 페이지 생성 단계를 추가한다

수정이 완료되면 변경된 부분만 간략히 보여주고 Stop한다.

QUIZ

AskUserQuestion({
  "questions": [{
    "question": "3가지 출력 형식 중 가장 간단하고, 외부 서비스 연결 없이 바로 쓸 수 있는 것은?",
    "header": "Quiz 4-1",
    "options": [
      {"label": "Markdown 파일", "description": "프로젝트 폴더에 .md 파일로 저장"},
      {"label": "Slack 메시지", "description": "Slack 채널에 전송"},
      {"label": "Notion 페이지", "description": "Notion DB에 기록"}
    ],
    "multiSelect": false
  }]
})

정답: Markdown 파일 피드백: "맞습니다! Markdown 파일은 별도 설정 없이 바로 사용할 수 있어서 가장 간단합니다. 그래서 기본 출력으로 항상 포함됩니다."

AskUserQuestion({
  "questions": [{
    "question": "Slack으로 결과를 보내려면 뭐가 필요할까요?",
    "header": "Quiz 4-2",
    "options": [
      {"label": "Slack MCP 연결", "description": "Block 2에서 배운 MCP 연결"},
      {"label": "Slack 앱 설치", "description": "스마트폰에 Slack 앱 설치"},
      {"label": "별도 준비 없이 가능", "description": "Claude가 알아서 전송"}
    ],
    "multiSelect": false
  }]
})

정답: Slack MCP 연결 피드백: "정확합니다! Claude가 Slack에 메시지를 보내려면 Slack MCP라는 통로가 연결되어 있어야 합니다. Block 2에서 배운 것이 여기서 이렇게 쓰입니다."

Block 5: 최종 완성 + 실행

EXPLAIN

지금까지 만든 것 정리

Block 0부터 여기까지, 단계별로 하나의 스킬을 완성해왔다:

Block 0: 도구 선택 + 스킬 골격 생성
  → 어떤 소스에서 정보를 모을지 정하고, 스킬 파일을 만들었다

Block 1: 프로젝트 구조 파악 + 스킬 맥락 반영
  → Explore 에이전트로 프로젝트를 살펴보고, 스킬에 맥락을 반영했다

Block 2: 도구 연결 (MCP/API)
  → 외부 서비스와 Claude를 연결하는 통로를 만들었다

Block 3: 수집 실행 & 검증
  → subagent로 여러 소스에서 동시에 정보를 수집하고 품질을 검증했다

Block 4: 출력 형식 설정
  → Markdown, Slack, Notion 중 출력 방식을 선택했다

이제 할 일

1. 완성된 스킬을 처음부터 끝까지 실제로 실행해서 결과를 확인한다 2. 스킬의 트리거를 점검한다 - 어떤 말을 하면 이 스킬이 작동하는지 확인 3. 원한다면 스킬 이름을 자신만의 이름으로 변경할 수 있다

트리거란?

스킬 파일 맨 위에 있는 description과 triggers가 트리거다:

---
name: my-context-sync
description: 나의 컨텍스트 싱크. "싱크", "sync" 요청에 사용.
triggers:
  - "싱크"
  - "sync"
---

이 문구들 중 하나를 Claude에게 말하면, Claude가 알아서 이 스킬을 실행한다. 마치 "싱크해줘"라고 말하면 자동으로 수집이 시작되는 것이다.

EXECUTE

3단계로 최종 완성과 실행을 진행한다:

1단계: 최종 스킬 파일 확인

사용자의 스킬 파일(.claude/skills/my-context-sync/SKILL.md)을 읽어서 전체 구성을 한 번 더 확인한다. 주요 점검 항목:

• 소스 정의가 올바른지 (연결한 도구와 일치하는지)
• 실행 흐름이 맞는지 (병렬 수집 → 통합 → 저장 순서)
• 출력 포맷이 Block 4에서 선택한 대로 설정되어 있는지
• 트리거 문구가 적절한지

문제가 있으면 함께 수정한다.

2단계: 스킬 실행

실제로 스킬을 실행한다. 사용자에게 아래와 같이 안내한다:

이제 완성된 스킬을 실행해봅시다!
새 대화를 열고 아래처럼 입력해보세요:

  싱크해줘

또는 슬래시 명령어로:

  /my-context-sync

Claude가 직접 실행하여 결과를 보여줄 수도 있다. 사용자가 원하면 Claude가 바로 실행한다.

3단계: 결과 확인 + 마무리

실행 결과를 함께 확인한다:

• Markdown 파일이 정상적으로 생성되었는지
• Slack 전송을 선택했다면 메시지가 도착했는지
• Notion을 선택했다면 페이지가 생성되었는지
• 수집된 내용이 기대한 대로인지

문제가 있으면 함께 수정하고 다시 실행한다.

성공했다면 축하 메시지와 활용 팁을 전달한다:

축하합니다! 나만의 Context Sync 스킬이 완성되었습니다!

이제 "싱크해줘" 한마디로 흩어진 정보가 자동으로 모입니다.
Day 1에서 Claude Code를 처음 만졌는데, 벌써 나만의 자동화 스킬을 만들었습니다.

활용 팁:
  1. 매일 아침 실행하면 "모닝 브리핑"처럼 사용할 수 있습니다
  2. CLAUDE.md에 스케줄을 추가하면 매일 자동 실행도 가능합니다:
     ## 스케줄
     - context-sync: 매일 09:00 실행
  3. 소스를 추가하고 싶으면 스킬 파일에 같은 형식으로 넣으면 됩니다
  4. Day 3 이후에 이 스킬을 더 발전시킬 수 있습니다

QUIZ

Block 5은 종합 퀴즈를 출제한다. 사용자가 돌아오면 먼저 "Day 2의 모든 과정을 완료했습니다! 마지막으로 오늘 배운 것을 정리하는 퀴즈입니다." 라고 안내한 뒤 아래 퀴즈를 순서대로 출제한다.

Quiz 5-1: 자동 실행

AskUserQuestion({
  "questions": [{
    "question": "완성된 스킬을 매일 자동으로 실행하려면 어떻게 해야 할까요?",
    "header": "Quiz 5-1",
    "options": [
      {"label": "CLAUDE.md에 스케줄 추가", "description": "스케줄을 설정하면 정해진 시간에 자동 실행"},
      {"label": "매일 아침 직접 실행", "description": "수동으로 매번 입력"},
      {"label": "Slack에 알림 설정", "description": "Slack은 출력 채널이지 실행 트리거가 아님"}
    ],
    "multiSelect": false
  }]
})

정답: CLAUDE.md에 스케줄 추가 피드백: "정확합니다! CLAUDE.md에 스케줄을 적어두면 Claude가 정해진 시간에 자동으로 스킬을 실행합니다. 매일 아침 모닝 브리핑이 자동으로 만들어지는 거죠."

Quiz 5-2: Day 2 종합

AskUserQuestion({
  "questions": [{
    "question": "Day 2에서 배운 핵심 3가지를 고르세요.",
    "header": "Quiz 5-2",
    "options": [
      {"label": "MCP 연결", "description": "Claude와 외부 서비스를 연결하는 통로"},
      {"label": "subagent 병렬 수집", "description": "여러 소스에서 동시에 정보 수집"},
      {"label": "스킬 구축", "description": "나만의 자동화 스킬을 처음부터 만들기"},
      {"label": "HTML 코딩", "description": "Day 2에서 HTML은 다루지 않았음"},
      {"label": "서버 배포", "description": "Day 2에서 배포는 다루지 않았음"}
    ],
    "multiSelect": true
  }]
})

정답: MCP 연결, subagent 병렬 수집, 스킬 구축 (3개 모두 선택) 피드백: "완벽합니다! MCP로 외부 도구를 연결하고, subagent로 동시에 수집하고, 이것을 하나의 스킬로 묶어서 '한마디로 실행'되게 만들었습니다. 이 3가지가 Day 2의 핵심입니다. 내일부터는 이 스킬을 기반으로 더 발전시켜 나갑니다!"

My Context Sync

흩어진 정보를 한곳에 모아 정리하는 스킬.

Slack, Gmail, Google Calendar, Notion에서 최근 정보를 수집하고, 하나의 마크다운 문서로 통합한다.

소스 정의

<!-- ============================================ --> <!-- 아래 4개 소스를 자신의 환경에 맞게 수정하세요 --> <!-- 사용하지 않는 소스는 통째로 삭제해도 됩니다 --> <!-- 새로운 소스를 추가하려면 같은 형식으로 복사하세요 --> <!-- ============================================ -->

소스 1: Slack

수집할 채널 목록:

<!-- 자신이 주로 사용하는 채널명으로 바꾸세요 -->

channels:
  - name: "general"          # 전체 공지
  - name: "project-updates"  # 프로젝트 소식
  - name: "random"           # 자유 채널

수집 방법:

각 채널에 대해 mcp__claude_ai_Slack__slack_read_channel 호출.
채널명과 메시지 개수(limit)를 전달한다.

Connectors로 연결한 경우:
  mcp__claude_ai_Slack__slack_read_channel(channel="general", limit=50)

claude mcp add로 연결한 경우:
  mcp__slack__slack_read_channel(channel="general", limit=50)
  (도구명은 연결 방식에 따라 다를 수 있음. /mcp로 확인)

추출할 정보:

• 중요 공지사항
• 의사결정 사항 ("확정", "결정", "합의" 키워드)
• 나에게 멘션된 메시지
• 답장이 필요한 질문

소스 2: Gmail

<!-- Gmail은 MCP가 아닌 스크립트로 수집합니다 --> <!-- 이 스크립트는 Block 2에서 Claude가 자동으로 작성해줍니다 --> <!-- 스크립트 경로를 자신의 환경에 맞게 수정하세요 -->

수집 방법:

uv run python .claude/skills/my-context-sync/scripts/gmail_fetch.py --days 7

추출할 정보:

• 안 읽은 이메일 수
• 중요 발신자 이메일 요약
• 회신이 필요한 이메일
• 일정 초대 (캘린더 연동)

소스 3: Google Calendar

<!-- 이 스크립트는 Block 2에서 Claude가 자동으로 작성해줍니다 --> <!-- 캘린더 스크립트 경로를 수정하세요 -->

수집 방법:

uv run python .claude/skills/my-context-sync/scripts/calendar_fetch.py --days 7

추출할 정보:

• 오늘의 일정
• 이번 주 주요 미팅
• 준비가 필요한 미팅 (발표, 외부 미팅 등)
• 일정 충돌 여부

소스 4: Notion

<!-- Notion MCP 서버가 .mcp.json에 등록되어 있어야 합니다 --> <!-- Block 2에서 Claude가 설정을 도와줍니다 -->

databases:
  - name: "업무 태스크"
    id: "your-database-id"
  - name: "프로젝트 현황"
    id: "your-database-id"

수집 방법:

Notion MCP 서버의 도구를 사용하여 데이터베이스를 조회한다.

연결 방법 (택 1):
  - Connectors: claude.ai/settings/connectors 에서 Notion 연결 (가장 쉬움)
  - 명령어: claude mcp add --transport http notion https://mcp.notion.com/mcp

호출 예시:
  mcp__notion__query_database(database_id="your-database-id")

<!-- ⚠️ WebFetch는 인증이 필요한 Notion 페이지에서 작동하지 않습니다 --> <!-- 반드시 Notion MCP 서버 또는 API 스크립트를 사용하세요 -->

추출할 정보:

• 진행 중인 태스크
• 기한이 임박한 항목
• 최근 업데이트된 페이지

실행 흐름

이 스킬이 트리거되면 아래 순서로 실행한다.

1단계: 병렬 수집

4개 소스를 동시에 수집한다. 서로 의존성이 없으므로 병렬 실행이 가능하다.

<!-- 소스가 2개이면 2줄, 5개이면 5줄로 조정하세요 --> <!-- 소스 수에 맞춰 Task 호출도 같은 수만큼 추가/제거하세요 -->

수집 시작
  ├── [소스 1] Slack 채널 메시지 수집      ─┐
  ├── [소스 2] Gmail 이메일 수집            ├── 병렬 실행
  ├── [소스 3] Google Calendar 일정 수집    │
  └── [소스 4] Notion 태스크 수집           ─┘
수집 완료

각 소스 수집은 subagent(Task 도구)로 실행한다:

Task(description="Slack 수집", prompt="general, project-updates, random 채널에서 최근 7일 메시지를 수집하라")
Task(description="Gmail 수집", prompt="gmail_fetch.py를 실행하여 최근 7일 이메일을 수집하라")
Task(description="Calendar 수집", prompt="calendar_fetch.py를 실행하여 7일간 일정을 수집하라")
Task(description="Notion 수집", prompt="업무 태스크 DB에서 진행 중인 항목을 수집하라")

2단계: 결과 통합

수집된 정보를 하나의 문서로 합친다.

통합 규칙:

• 소스별 섹션으로 구분
• 각 섹션에서 "하이라이트" (중요 항목 3개 이내)를 선별
• 액션 아이템을 문서 하단에 모아서 정리
• 수집 실패한 소스는 "수집 실패" 표시와 함께 사유 기록

3단계: 문서 저장

결과 파일을 저장한다.

저장 위치: sync/YYYY-MM-DD-context-sync.md

<!-- 저장 위치를 원하는 경로로 바꾸세요 -->

4단계: 리포트

실행 결과를 사용자에게 보고한다.

싱크 완료!

수집 결과:
  Slack: 3개 채널, 47개 메시지
  Gmail: 12개 이메일 (안 읽음 5개)
  Calendar: 8개 일정
  Notion: 15개 태스크

하이라이트 3건:
  1. [Slack] #project-updates: 배포 일정 확정 (2/20)
  2. [Gmail] 파트너사 계약서 회신 필요 (기한: 2/18)
  3. [Calendar] 내일 10시 팀 미팅 (발표 자료 준비 필요)

액션 아이템 4건:
  - [ ] 파트너사 계약서 회신
  - [ ] 팀 미팅 발표 자료 준비
  - [ ] Slack #general 공지 확인
  - [ ] Notion 기한 초과 태스크 2건 처리

파일 저장: sync/2026-02-15-context-sync.md

출력 포맷

<!-- 출력 형식을 선택하세요. 여러 개를 동시에 사용할 수 있습니다 --> 출력 옵션: 1. Markdown 파일 (기본) -- sync/YYYY-MM-DD-context-sync.md에 저장 2. Slack 메시지 -- 지정 채널에 요약 발송 (Slack MCP 필요) 3. Notion 페이지 -- 지정 DB에 기록 (Notion MCP 필요)

저장되는 마크다운 파일의 구조:

# Context Sync - 2026-02-15

> 자동 수집 시각: 09:00

## 하이라이트

- **[Slack]** 배포 일정 2/20로 확정
- **[Gmail]** 파트너사 계약서 회신 필요 (기한 2/18)
- **[Calendar]** 내일 팀 미팅 - 발표 자료 준비

## Slack

### #general
- 주간 회의 시간 변경 공지 (화 10시 → 수 11시)

### #project-updates
- v2.0 배포일 2/20 확정
- QA 테스트 완료

## Gmail

| 발신자 | 제목 | 상태 |
|--------|------|------|
| 파트너사 | 계약서 검토 요청 | 회신 필요 |
| 팀장 | 주간 보고 | 읽음 |

## Google Calendar

### 오늘 (2/15)
- 09:00 모닝 스탠드업 (30분)
- 14:00 파트너 미팅 (1시간)

### 이번 주
- 2/17 (월) 10:00 팀 미팅
- 2/20 (수) 배포일

## Notion

### 진행 중 태스크
- [ ] 랜딩페이지 디자인 (기한: 2/18)
- [ ] API 문서 작성 (기한: 2/20)
- [x] 사용자 테스트 완료

## 액션 아이템

- [ ] 파트너사 계약서 회신 (기한: 2/18)
- [ ] 팀 미팅 발표 자료 준비 (2/17까지)
- [ ] 기한 초과 태스크 처리
- [ ] Slack 공지 확인 후 일정 반영

커스터마이징 가이드

소스 추가하기

새로운 소스를 추가하려면 "소스 정의" 섹션에 같은 형식으로 추가한다:

### 소스 5: Linear

| 항목 | 값 |
|------|-----|
| MCP 도구 | `mcp__claude_ai_Linear__list_issues` |
| 수집 범위 | 나에게 할당된 이슈 |

수집 방법:
  mcp__claude_ai_Linear__list_issues 호출.

추출할 정보:
- 진행 중인 이슈
- 이번 주 마감 이슈

API/스크립트 방식으로 소스 추가하기

MCP 서버가 없는 도구는 스크립트를 작성하여 연결한다. Block 2에서 Claude가 스크립트를 자동으로 작성해준다.

예시: Fireflies 미팅록 추가

### 소스 5: Fireflies

| 항목 | 값 |
|------|-----|
| 실행 방법 | Python 스크립트 (Fireflies GraphQL API) |
| 수집 범위 | 최근 7일 미팅록 |

수집 방법:
uv run python .claude/skills/my-context-sync/scripts/fireflies_fetch.py --days 7

추출할 정보:
- 최근 미팅 제목과 참석자
- 주요 논의 사항
- 액션 아이템

소스 제거하기

사용하지 않는 소스는 해당 "소스 N" 섹션 전체를 삭제한다. 실행 흐름의 병렬 수집 부분에서도 해당 줄을 제거한다.

수집 주기 변경하기

기본은 수동 실행이다. 자동 실행을 원하면 CLAUDE.md에 스케줄을 추가한다:

## 스케줄
- context-sync: 매일 09:00 실행

출력 위치 변경하기

"3단계: 문서 저장"의 경로를 원하는 위치로 수정한다. 예: reports/, docs/daily/ 등.