+
+
+
+
+
+
-**Best for**: Exploration, iteration, multi-turn conversations. Like talking to a waiter who can answer questions, take feedback, and adjust the order on the fly.
+**적합한 상황**: 탐색, 반복, 여러 턴 대화. 질문에 답해 주고 피드백을 받아 주문을 조정하는 점원과 대화하는 것과 비슷합니다.
-Start an interactive session:
+대화형 세션 시작:
```bash
copilot
```
-As you've seen up to this point, you'll see a prompt where you can type naturally. To get help on available commands, just type:
+사용 가능한 명령어 도움말을 보려면 다음을 입력하세요:
```
> /help
```
-**Key insight**: Interactive mode maintains context. Each message builds on previous ones, just like a real conversation.
+**핵심 인사이트**: Interactive 모드는 맥락을 유지합니다. 이전 메시지들이 쌓이며, 실제 대화처럼 이어집니다.
-#### Interactive Mode Example
+#### Interactive 모드 예시
```bash
copilot
-> Review @samples/book-app-project/utils.py and suggest improvements
+> @samples/book-app-project/utils.py 를 리뷰하고 개선점을 제안해 줘
-> Add type hints to all functions
+> 모든 함수에 타입 힌트를 추가해 줘
-> Make the error handling more robust
+> 에러 처리를 더 견고하게 만들어 줘
> /exit
```
-Notice how each prompt builds on the previous answer. You're having a conversation, not starting over each time.
+각 프롬프트가 이전 답변을 기반으로 이어지는 것을 확인할 수 있습니다. 매번 처음부터 시작하는 게 아니라 “대화”를 하는 것입니다.
---
-### Mode 2: Plan Mode
+### 모드 2: Plan 모드
-
+
-**Best for**: Complex tasks where you want to review the approach before execution. Similar to planning a route before a trip using GPS.
+**적합한 상황**: 실행 전에 접근 방식을 검토하고 싶은 복잡한 작업. 여행 전에 GPS로 경로를 계획하는 것과 비슷합니다.
-Plan mode helps you create a step-by-step plan before writing any code. Use the `/plan` command or press **Shift+Tab** to cycle into Plan Mode:
+Plan 모드는 코드를 쓰기 전에 단계별 계획을 만드는 데 도움을 줍니다. `/plan` 명령을 사용하거나, 대화형 세션 중 **Shift+Tab**으로 Plan 모드로 전환할 수 있습니다:
-> 💡 **Tip**: **Shift+Tab** cycles between modes: Interactive → Plan → Autopilot. Press it anytime during an interactive session to switch modes without typing a command.
+> 💡 **팁**: **Shift+Tab**은 모드를 순환합니다: Interactive → Plan → Autopilot. 세션 중 언제든 눌러서 모드를 바꿀 수 있습니다.
```bash
copilot
-> /plan Add a "mark as read" command to the book app
+> /plan 책 앱에 "읽음 표시" 명령을 추가해 줘
```
-**Plan mode output:** (your output may differ)
+**Plan 모드 출력 예시:** (실제 출력은 달라질 수 있음)
```
-📋 Implementation Plan
+📋 구현 계획
-Step 1: Update the command handler in book_app.py
- - Add new elif branch for "mark" command
- - Create handle_mark_as_read() function
+Step 1: book_app.py의 명령 처리기 업데이트
+ - "mark" 명령을 위한 새로운 elif 분기 추가
+ - handle_mark_as_read() 함수 생성
-Step 2: Implement the handler function
- - Prompt user for book title
- - Call collection.mark_as_read(title)
- - Display success/failure message
+Step 2: 처리기 함수 구현
+ - 사용자에게 책 제목을 입력받기
+ - collection.mark_as_read(title) 호출
+ - 성공/실패 메시지 출력
-Step 3: Update help text
- - Add "mark" to available commands list
- - Document the command usage
+Step 3: 도움말 텍스트 업데이트
+ - 가능한 명령 목록에 "mark" 추가
+ - 명령 사용법 문서화
-Step 4: Test the flow
- - Add a book
- - Mark it as read
- - Verify status changes in list output
+Step 4: 흐름 테스트
+ - 책 추가
+ - 읽음 표시
+ - 목록 출력에서 상태 변경 확인
-Proceed with implementation? [Y/n]
+구현을 진행할까요? [Y/n]
```
-**Key insight**: Plan mode lets you review and modify the approach before any code is written. Once a plan is complete, you can even tell Copilot CLI to save it to a file for later reference. For example, "Save this plan to `mark_as_read_plan.md`" would create a markdown file with the plan details.
+**핵심 인사이트**: Plan 모드는 코드가 작성되기 전에 접근 방식을 검토하고 수정할 수 있게 해줍니다. 계획을 완성한 뒤에는 파일로 저장하도록 지시할 수도 있습니다. 예를 들어, “이 계획을 `mark_as_read_plan.md`에 저장해 줘”라고 말하면 계획 내용을 담은 마크다운 파일이 생성됩니다.
-> 💡 **Want something more complex?** Try: `/plan Add search and filter capabilities to the book app`. Plan mode scales from simple features to full applications.
+> 💡 **더 복잡한 것을 원하나요?** `/plan 책 앱에 검색 및 필터 기능을 추가해 줘`를 시도해 보세요. Plan 모드는 간단한 기능부터 전체 애플리케이션 수준까지 확장됩니다.
-> 📚 **Autopilot mode**: You may have noticed Shift+Tab cycles through a third mode called **Autopilot**. In autopilot mode, Copilot works through an entire plan without waiting for your input after each step — like handing a task to a colleague and saying "let me know when you're finished." The typical workflow is plan → accept → autopilot, which means you need to be good at writing plans first. Get comfortable with Interactive and Plan modes, then see the [official docs](https://docs.github.com/copilot/concepts/agents/copilot-cli/autopilot) when you're ready.
+> 📚 **Autopilot 모드**: Shift+Tab으로 **Autopilot**이라는 세 번째 모드도 순환되는 것을 보셨을 수 있습니다. Autopilot 모드에서는 Copilot이 각 단계마다 입력을 기다리지 않고 전체 계획을 끝까지 수행합니다. 마치 동료에게 작업을 맡기고 “끝나면 알려줘”라고 말하는 것과 비슷하죠. 일반적인 흐름은 plan → 수락 → autopilot이며, 좋은 계획을 쓰는 능력이 중요합니다. Interactive와 Plan에 익숙해진 뒤 [공식 문서](https://docs.github.com/copilot/concepts/agents/copilot-cli/autopilot)를 참고해 보세요.
---
-### Mode 3: Programmatic Mode
+### 모드 3: Programmatic 모드
-
+
-**Best for**: Automation, scripts, CI/CD, single-shot commands. Like using a drive-through for a quick order without needing to talk to a waiter.
+**적합한 상황**: 자동화, 스크립트, CI/CD, 한 번에 끝나는 명령. 점원과 대화하지 않고 빠르게 주문하는 드라이브스루와 비슷합니다.
-Use the `-p` flag for one-time commands that don't need interaction:
+대화 없이 한 번만 실행할 명령에는 `-p` 플래그를 사용하세요:
```bash
-# Generate code
-copilot -p "Write a function that checks if a number is even or odd"
+# 코드 생성
+copilot -p "어떤 숫자가 짝수인지 홀수인지 확인하는 함수를 작성해 줘"
-# Get quick help
-copilot -p "How do I read a JSON file in Python?"
+# 빠른 도움말
+copilot -p "Python에서 JSON 파일을 어떻게 읽어?"
```
-**Key insight**: Programmatic mode gives you a quick answer and exits. No conversation, just input → output.
+**핵심 인사이트**: Programmatic 모드는 빠르게 답하고 종료합니다. 대화가 아니라 입력 → 출력입니다.
-
---
-## Essential Slash Commands
+## 필수 슬래시 명령어
-These commands work in interactive mode. **Start with just these six** - they cover 90% of daily use:
+이 명령들은 Interactive 모드에서 동작합니다. **이 6개만 먼저 익히세요** — 일상 사용의 90%를 커버합니다:
-| Command | What It Does | When to Use |
-|---------|--------------|-------------|
-| `/help` | Show all available commands | When you forget a command |
-| `/clear` | Clear conversation and start fresh | When switching topics |
-| `/plan` | Plan your work out before coding | For more complex features |
-| `/research` | Deep research using GitHub and web sources | When you need to investigate a topic before coding |
-| `/model` | Show or switch AI model | When you want to change the AI model |
-| `/exit` | End the session | When you're done |
+| 명령어 | 하는 일 | 언제 사용하나 |
+|--------|--------|--------------|
+| `/help` | 사용 가능한 명령어 표시 | 명령어가 기억나지 않을 때 |
+| `/clear` | 대화를 지우고 새로 시작 | 주제를 바꿀 때 |
+| `/plan` | 구현 전에 작업 계획 세우기 | 더 복잡한 기능을 다룰 때 |
+| `/research` | GitHub 및 웹 소스를 활용한 심층 조사 | 코딩 전 조사/탐색이 필요할 때 |
+| `/model` | AI 모델 표시/전환 | 다른 모델로 바꾸고 싶을 때 |
+| `/exit` | 세션 종료 | 작업이 끝났을 때 |
-That's it for getting started! As you become comfortable, you can explore additional commands.
+여기까지가 시작을 위한 전부입니다! 익숙해지면 추가 명령어들도 살펴볼 수 있습니다.
-> 📚 **Official Documentation**: [CLI command reference](https://docs.github.com/copilot/reference/cli-command-reference) for the complete list of commands and flags.
+> 📚 **공식 문서**: 전체 명령/플래그 목록은 [CLI 명령 참조](https://docs.github.com/copilot/reference/cli-command-reference)를 확인하세요.
📚 Going Further: Using Programmatic Mode in Scripts (click to expand)
+📚 더 나아가기: 스크립트에서 Programmatic 모드 사용 (클릭하여 펼치기)
-Once you're comfortable, you can use `-p` in shell scripts: +익숙해지면 셸 스크립트에서 `-p`를 사용할 수 있습니다: ```bash #!/bin/bash -# Generate commit messages automatically -COMMIT_MSG=$(copilot -p "Generate a commit message for: $(git diff --staged)") +# 커밋 메시지 자동 생성 +COMMIT_MSG=$(copilot -p "다음 변경사항에 대한 커밋 메시지를 만들어 줘: $(git diff --staged)") git commit -m "$COMMIT_MSG" -# Review a file -copilot --allow-all -p "Review @myfile.py for issues" +# 파일 리뷰 +copilot --allow-all -p "@myfile.py 를 리뷰해서 문제를 찾아 줘" ``` -> ⚠️ **About `--allow-all`**: This flag skips all permission prompts, letting Copilot CLI read files, run commands, and access URLs without asking first. This is necessary for programmatic mode (`-p`) since there's no interactive session to approve actions. Only use `--allow-all` with prompts you've written yourself and in directories you trust. Never use it with untrusted input or in sensitive directories. + +> ⚠️ **`--allow-all`에 대하여**: 이 플래그는 권한 요청 프롬프트를 모두 건너 뛰고, Copilot CLI가 파일을 읽고/명령을 실행하고/URL에 접근하도록 허용합니다. Programmatic 모드(`-p`)는 대화형 세션이 아니므로 승인할 기회가 없어서 필요한 경우가 있습니다. 반드시 본인이 작성한 프롬프트에만 사용하고, 신뢰할 수 있는 디렉터리에서만 사용하세요. 신뢰할 수 없는 입력이나 민감한 디렉터리에는 절대 사용하지 마세요.
-` | Add a directory to allowed list |
-| `/list-dirs` | Show all allowed directories |
-| `/cwd`, `/cd [directory]` | View or change working directory |
+| 명령어 | 하는 일 |
+|--------|--------|
+| `/allow-all` | 이 세션의 모든 권한 요청 자동 승인 |
+| `/add-dir <디렉터리>` | 허용 목록에 디렉터리 추가 |
+| `/list-dirs` | 허용된 디렉터리 목록 표시 |
+| `/cwd`, `/cd [디렉터리]` | 현재 작업 디렉터리 보기/변경 |
-> ⚠️ **Use with caution**: `/allow-all` skips confirmation prompts. Great for trusted projects, but be careful with untrusted code.
+> ⚠️ **주의**: `/allow-all`은 확인 프롬프트를 건너뜁니다. 신뢰할 수 있는 프로젝트에는 유용하지만, 신뢰할 수 없는 코드에는 주의하세요.
-### Session
+### 세션
-| Command | What It Does |
-|---------|--------------|
-| `/resume` | Switch to a different session (optionally specify session ID) |
-| `/rename` | Rename the current session |
-| `/context` | Show context window token usage and visualization |
-| `/usage` | Display session usage metrics and statistics |
-| `/session` | Show session info and workspace summary |
-| `/compact` | Summarize conversation to reduce context usage |
-| `/share` | Export session as markdown file or GitHub gist |
+| 명령어 | 하는 일 |
+|--------|--------|
+| `/resume` | 다른 세션으로 전환(선택적으로 세션 ID 지정) |
+| `/rename` | 현재 세션 이름 변경 |
+| `/context` | 컨텍스트 윈도우 토큰 사용량 및 시각화 표시 |
+| `/usage` | 세션 사용량 메트릭/통계 표시 |
+| `/session` | 세션 정보 및 워크스페이스 요약 표시 |
+| `/compact` | 대화를 요약하여 컨텍스트 사용량 줄이기 |
+| `/share` | 세션을 마크다운 파일 또는 GitHub gist로 내보내기 |
-### Help and Feedback
+### 도움말 및 피드백
-| Command | What It Does |
-|---------|--------------|
-| `/help` | Show all available commands |
-| `/changelog` | Display changelog for CLI versions |
-| `/feedback` | Submit feedback to GitHub |
-| `/theme` | View or set terminal theme |
+| 명령어 | 하는 일 |
+|--------|--------|
+| `/help` | 사용 가능한 명령어 표시 |
+| `/changelog` | CLI 버전 변경 로그 표시 |
+| `/feedback` | GitHub에 피드백 제출 |
+| `/theme` | 터미널 테마 보기/설정 |
-### Quick Shell Commands
+### 빠른 셸 명령어
-Run shell commands directly without AI by prefixing with `!`:
+AI 없이 셸 명령을 직접 실행하려면 앞에 `!`를 붙이세요:
```bash
copilot
> !git status
-# Runs git status directly, bypassing the AI
+# git status를 직접 실행(= AI 우회)
> !python -m pytest tests/
-# Runs pytest directly
+# pytest 실행
```
-### Switching Models
+### 모델 전환
-Copilot CLI supports multiple AI models from OpenAI, Anthropic, Google, and others. The models available to you depend on your subscription level and region. Use `/model` to see your options and switch between them:
+Copilot CLI는 OpenAI, Anthropic, Google 등 다양한 제공자의 여러 AI 모델을 지원합니다. 사용 가능한 모델은 구독 수준과 지역에 따라 달라집니다. `/model`로 옵션을 확인하고 전환하세요:
```bash
copilot
> /model
-# Shows available models and lets you pick one. Select Sonnet 4.5.
+# 사용 가능한 모델을 표시하고 선택하게 합니다. Sonnet 4.5를 선택하세요.
```
-> 💡 **Tip**: Some models cost more "premium requests" than others. Models marked **1x** (like Claude Sonnet 4.5) are a great default. They're capable and efficient. Higher-multiplier models use your premium request quota faster, so save those for when you really need them.
+> 💡 **팁**: 어떤 모델은 다른 모델보다 “프리미엄 요청”을 더 많이 소모합니다. **1x**로 표시된 모델(예: Claude Sonnet 4.5)은 유능하면서 효율적이라 기본값으로 좋습니다. 더 높은 배율의 모델은 프리미엄 요청 할당량을 더 빨리 소모하니, 정말 필요할 때만 사용하세요.
---
-# Practice
+# 실습
-📚 Additional Commands (click to expand)
+📚 추가 명령어 (클릭하여 펼치기)
-> 💡 The essential commands above cover a lot of what you'll do on a daily use. This reference is here for when you're ready to explore more. +> 💡 위의 필수 명령어만으로도 일상 작업의 많은 부분을 처리할 수 있습니다. 이 섹션은 더 많은 기능을 탐색할 준비가 되었을 때 참고하세요. -### Agent Environment +### 에이전트 환경 -| Command | What It Does | -|---------|--------------| -| `/init` | Initialize Copilot instructions for your repository | -| `/agent` | Browse and select from available agents | -| `/skills` | Manage skills for enhanced capabilities | -| `/mcp` | Manage MCP server configuration | +| 명령어 | 하는 일 | +|--------|--------| +| `/init` | 저장소에 Copilot 지침 초기화 | +| `/agent` | 사용 가능한 에이전트 탐색 및 선택 | +| `/skills` | 향상된 기능을 위한 스킬 관리 | +| `/mcp` | MCP 서버 설정 관리 | -> 💡 Skills are covered in detail in [Chapter 05](../05-skills/README.md). MCP servers are covered in [Chapter 06](../06-mcp-servers/README.md). +> 💡 스킬은 [챕터 05](../05-skills/README.md)에서 자세히 다룹니다. MCP 서버는 [챕터 06](../06-mcp-servers/README.md)에서 다룹니다. -### Models and Subagents +### 모델과 서브에이전트 -| Command | What It Does | -|---------|--------------| -| `/model` | Show or switch AI model | -| `/delegate` | Hand off task to Copilot coding agent on GitHub (agent in the cloud) | -| `/fleet` | Split a complex task into parallel subtasks for faster completion | -| `/tasks` | View background subagents and detached shell sessions | +| 명령어 | 하는 일 | +|--------|--------| +| `/model` | AI 모델 표시/전환 | +| `/delegate` | GitHub의 Copilot coding agent(클라우드 에이전트)에게 작업 위임 | +| `/fleet` | 복잡한 작업을 병렬 하위 작업으로 분할 | +| `/tasks` | 백그라운드 서브에이전트 및 분리된 셸 세션 보기 | -### Code +### 코드 -| Command | What It Does | -|---------|--------------| -| `/diff` | Review the changes made in the current directory | -| `/pr` | Operate on pull requests for the current branch | -| `/review` | Run the code-review agent to analyze changes | -| `/research` | Run deep research investigation using GitHub and web sources | -| `/terminal-setup` | Enable multiline input support (shift+enter and ctrl+enter) | +| 명령어 | 하는 일 | +|--------|--------| +| `/diff` | 현재 디렉터리에서 변경사항 확인 | +| `/pr` | 현재 브랜치의 PR 조작 | +| `/review` | 코드 리뷰 에이전트 실행 | +| `/research` | GitHub/웹 기반 심층 조사 실행 | +| `/terminal-setup` | 멀티라인 입력 지원 활성화(shift+enter, ctrl+enter) | -### Permissions +### 권한 -| Command | What It Does | -|---------|--------------| -| `/allow-all` | Auto-approve all permission prompts for this session | -| `/add-dir
+
-Time to put what you've learned into action.
+배운 내용을 직접 적용해 볼 시간입니다.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 해보기
-### Interactive Exploration
+### 대화형 탐색
-Start Copilot and use follow-up prompts to iteratively improve the book app:
+Copilot을 시작하고 후속 프롬프트를 사용해 책 앱을 반복적으로 개선해 보세요:
```bash
copilot
-> Review @samples/book-app-project/book_app.py - what could be improved?
+> @samples/book-app-project/book_app.py 를 리뷰해 줘 - 뭐가 개선될까?
-> Refactor the if/elif chain into a more maintainable structure
+> if/elif 체인을 더 유지보수하기 좋은 구조로 리팩터링해 줘
-> Add type hints to all the handler functions
+> 모든 핸들러 함수에 타입 힌트를 추가해 줘
> /exit
```
-### Plan a Feature
+### 기능 계획 세우기
-Use `/plan` to have Copilot CLI map out an implementation before writing any code:
+`/plan`을 사용해 코드를 작성하기 전에 구현을 단계별로 설계하게 할 수 있습니다:
```bash
copilot
-> /plan Add a search feature to the book app that can find books by title or author
+> /plan 제목 또는 저자 기준으로 책을 찾을 수 있는 검색 기능을 책 앱에 추가해 줘
-# Review the plan
-# Approve or modify
-# Watch it implement step by step
+# 계획을 검토
+# 승인 또는 수정
+# 단계별로 구현되는 과정을 확인
```
-### Automate with Programmatic Mode
+### Programmatic 모드로 자동화하기
-The `-p` flag lets you run Copilot CLI directly from your terminal without entering interactive mode. Copy and paste the following script into your terminal (not inside Copilot) from the repository root to review all Python files in the book app.
+`-p` 플래그를 쓰면 대화형 모드에 들어가지 않고 터미널에서 Copilot CLI를 바로 실행할 수 있습니다. 아래 스크립트를 저장소 루트에서 터미널(= Copilot 내부가 아님)에 복사해 붙여넣으면, 책 앱의 모든 Python 파일을 리뷰할 수 있습니다.
```bash
-# Review all Python files in the book app
+# 책 앱의 모든 Python 파일 리뷰
for file in samples/book-app-project/*.py; do
echo "Reviewing $file..."
- copilot --allow-all -p "Quick code quality review of @$file - critical issues only"
+ copilot --allow-all -p "@$file 에 대한 빠른 코드 품질 리뷰 - 치명적인 이슈만"
done
```
**PowerShell (Windows):**
```powershell
-# Review all Python files in the book app
+# 책 앱의 모든 Python 파일 리뷰
Get-ChildItem samples/book-app-project/*.py | ForEach-Object {
$relativePath = "samples/book-app-project/$($_.Name)";
Write-Host "Reviewing $relativePath...";
- copilot --allow-all -p "Quick code quality review of @$relativePath - critical issues only"
+ copilot --allow-all -p "@$relativePath 에 대한 빠른 코드 품질 리뷰 - 치명적인 이슈만"
}
```
---
-After completing the demos, try these variations:
+데모를 완료한 뒤에는 다음 변형도 시도해 보세요:
-1. **Interactive Challenge**: Start `copilot` and explore the book app. Ask about `@samples/book-app-project/books.py` and request improvements 3 times in a row.
+1. **Interactive 챌린지**: `copilot`을 시작하고 책 앱을 탐색해 보세요. `@samples/book-app-project/books.py`에 대해 질문하고, 개선 요청을 연속으로 3번 해 보세요.
-2. **Plan Mode Challenge**: Run `/plan Add rating and review features to the book app`. Read the plan carefully. Does it make sense?
+2. **Plan 모드 챌린지**: `/plan 책 앱에 평점 및 리뷰 기능을 추가해 줘`를 실행하세요. 계획을 꼼꼼히 읽어보세요. 말이 되나요?
-3. **Programmatic Challenge**: Run `copilot --allow-all -p "List all functions in @samples/book-app-project/book_app.py and describe what each does"`. Did it work on the first try?
+3. **Programmatic 챌린지**: `copilot --allow-all -p "@samples/book-app-project/book_app.py 의 모든 함수를 나열하고 각각 무엇을 하는지 설명해 줘"`를 실행하세요. 한 번에 잘 되었나요?
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: Improve the Book App Utilities
+### 메인 과제: 책 앱 유틸리티 개선
-The hands-on examples focused on reviewing and refactoring `book_app.py`. Now practice the same skills on a different file, `utils.py`:
+실습 예시는 주로 `book_app.py`를 리뷰하고 리팩터링하는 데 초점을 맞췄습니다. 이제 같은 스킬을 다른 파일 `utils.py`에 적용해 봅시다:
-1. Start an interactive session: `copilot`
-2. Ask Copilot CLI to summarize the file: `@samples/book-app-project/utils.py What does each function in this file do?`
-3. Ask it to add input validation: "Add validation to `get_user_choice()` so it handles empty input and non-numeric entries"
-4. Ask it to improve error handling: "What happens if `get_book_details()` receives an empty string for the title? Add guards for that."
-5. Ask for a docstring: "Add a comprehensive docstring to `get_book_details()` with parameter descriptions and return values"
-6. Observe how context carries between prompts. Each improvement builds on the last
-7. Exit with `/exit`
+1. 대화형 세션 시작: `copilot`
+2. Copilot CLI에게 파일 요약을 요청: `@samples/book-app-project/utils.py 이 파일의 각 함수가 무엇을 하는지 알려줘`
+3. 입력 검증 추가 요청: "`get_user_choice()`가 빈 입력과 숫자가 아닌 입력도 처리하도록 검증을 추가해 줘"
+4. 에러 처리 개선 요청: "`get_book_details()`가 제목으로 빈 문자열을 받으면 어떻게 될까? 가드(검사)를 추가해 줘"
+5. docstring 요청: "`get_book_details()`에 매개변수 설명과 반환값이 포함된 포괄적인 docstring을 추가해 줘"
+6. 맥락이 어떻게 이어지는지 관찰하세요. 각 개선 요청은 이전 요청을 바탕으로 합니다.
+7. `/exit`로 종료
-**Success criteria**: You should have an improved `utils.py` with input validation, error handling, and a docstring, all built through a multi-turn conversation.
+**성공 기준**: 입력 검증, 에러 처리, docstring이 추가된 개선된 `utils.py`를 얻는 것입니다. 이 모든 과정이 여러 턴의 대화로 이루어져야 합니다.
-
-### Bonus Challenge: Compare the Modes
+### 보너스 과제: 모드 비교
-The examples used `/plan` for a search feature and `-p` for batch reviews. Now try all three modes on a single new task: adding a `list_by_year()` method to the `BookCollection` class:
+예시에서는 검색 기능에 `/plan`을 사용했고, 배치 리뷰에는 `-p`를 사용했습니다. 이제 하나의 새로운 작업에 대해 세 가지 모드를 모두 써 보세요: `BookCollection` 클래스에 `list_by_year()` 메서드를 추가하기
-1. **Interactive**: `copilot` → ask it to design and build the method step by step
-2. **Plan**: `/plan Add a list_by_year(start, end) method to BookCollection that filters books by publication year range`
-3. **Programmatic**: `copilot --allow-all -p "@samples/book-app-project/books.py Add a list_by_year(start, end) method that returns books published between start and end year inclusive"`
+1. **Interactive**: `copilot` → 단계별로 메서드를 설계하고 구현해 달라고 요청
+2. **Plan**: `/plan BookCollection에 list_by_year(start, end) 메서드를 추가해서 출판 연도 범위로 책을 필터링해 줘`
+3. **Programmatic**: `copilot --allow-all -p "@samples/book-app-project/books.py 에 list_by_year(start, end) 메서드를 추가해서 start~end(포함) 사이에 출판된 책을 반환하게 해 줘"`
-**Reflection**: Which mode felt most natural? When would you use each?
+**회고**: 어떤 모드가 가장 자연스러웠나요? 각각 언제 사용하겠나요?
---
💡 Hints (click to expand)
+💡 힌트(클릭하여 펼치기)
-**Sample prompts to try:** +**시도해 볼 샘플 프롬프트:** ```bash -> @samples/book-app-project/utils.py What does each function in this file do? -> Add validation to get_user_choice() so it handles empty input and non-numeric entries -> What happens if get_book_details() receives an empty string for the title? Add guards for that. -> Add a comprehensive docstring to get_book_details() with parameter descriptions and return values +> @samples/book-app-project/utils.py 이 파일의 각 함수가 무엇을 하는지 알려줘 +> get_user_choice()가 빈 입력과 숫자가 아닌 입력도 처리하도록 검증을 추가해 줘 +> get_book_details()가 제목으로 빈 문자열을 받으면 어떻게 될까? 가드(검사)를 추가해 줘 +> get_book_details()에 매개변수 설명과 반환값이 포함된 포괄적인 docstring을 추가해 줘 ``` -**Common issues:** -- If Copilot CLI asks clarifying questions, just answer them naturally -- The context carries forward, so each prompt builds on the previous -- Use `/clear` if you want to start over +**자주 발생하는 문제:** +- Copilot CLI가 추가 질문을 하면 자연스럽게 답하면 됩니다 +- 맥락이 계속 이어지므로, 각 프롬프트는 이전 응답을 기반으로 합니다 +- 새로 시작하고 싶으면 `/clear`를 사용하세요
-
---
-# Summary
+# 요약
-## 🔑 Key Takeaways
+## 🔑 핵심 정리
-1. **Interactive mode** is for exploration and iteration - context carries forward. It's like having a conversation with someone who remembers what you've said up to that point.
-2. **Plan mode** is normally for more involved tasks. Review before implementation.
-3. **Programmatic mode** is for automation. No interaction needed.
-4. **Four essential commands** (`/help`, `/clear`, `/plan`, `/exit`) cover most daily use.
+1. **Interactive 모드**는 탐색과 반복에 적합하며 맥락이 이어집니다. 지금까지 말한 내용을 기억하는 상대와 대화하는 것과 같습니다.
+2. **Plan 모드**는 보통 더 복잡한 작업에 사용합니다. 구현 전에 계획을 검토하세요.
+3. **Programmatic 모드**는 자동화에 적합합니다. 대화가 필요 없습니다.
+4. **네 가지 필수 명령** (`/help`, `/clear`, `/plan`, `/exit`)만으로도 대부분의 일상 사용을 커버합니다.
-> 📋 **Quick Reference**: See the [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for a complete list of commands and shortcuts.
+> 📋 **빠른 참조**: 전체 명령어와 단축키는 [GitHub Copilot CLI 명령 참조](https://docs.github.com/en/copilot/reference/cli-command-reference)를 확인하세요.
---
-## ➡️ What's Next
+## ➡️ 다음은?
-Now that you understand the three modes, let's learn how to give Copilot CLI context about your code.
+이제 세 가지 모드를 이해했으니, Copilot CLI에 코드 맥락을 제공하는 방법을 배워봅시다.
-In **[Chapter 02: Context and Conversations](../02-context-conversations/README.md)**, you'll learn:
+**[챕터 02: 컨텍스트와 대화](../02-context-conversations/README.md)** 에서는 다음을 배웁니다:
-- The `@` syntax for referencing files and directories
-- Session management with `--resume` and `--continue`
-- How context management makes Copilot CLI truly powerful
+- 파일/디렉터리를 참조하는 `@` 문법
+- `--resume`, `--continue`로 세션 관리
+- 컨텍스트 관리가 Copilot CLI를 얼마나 강력하게 만드는지
---
-**[← Back to Course Home](../README.md)** | **[Continue to Chapter 02 →](../02-context-conversations/README.md)**
+**[← 코스 홈으로](../README.md)** | **[챕터 02로 계속 →](../02-context-conversations/README.md)"
\ No newline at end of file
diff --git a/02-context-conversations/README.md b/02-context-conversations/README.md
index 8aa50233..0b622e44 100644
--- a/02-context-conversations/README.md
+++ b/02-context-conversations/README.md
@@ -1,678 +1,675 @@
-
+
-> **What if AI could see your entire codebase, not just one file at a time?**
+> **만약 AI가 한 번에 파일 하나가 아니라, 코드베이스 전체를 볼 수 있다면 어떨까요?**
-In this chapter, you'll unlock the real power of GitHub Copilot CLI: context. You'll learn to use the `@` syntax to reference files and directories, giving Copilot CLI deep understanding of your codebase. You'll discover how to maintain conversations across sessions, resume work days later exactly where you left off, and see how cross-file analysis catches bugs that single-file reviews miss entirely.
+이 장에서는 GitHub Copilot CLI의 진짜 힘인 **컨텍스트(context)** 를 열어봅니다. `@` 문법을 사용해 파일과 디렉터리를 참조함으로써 Copilot CLI가 코드베이스를 더 깊이 이해하도록 만드는 방법을 배우게 됩니다. 또한 세션을 넘나들며 대화를 이어가고, 며칠 뒤에도 중단한 지점에서 정확히 다시 시작하는 방법을 익힙니다. 마지막으로 여러 파일을 함께 분석할 때, 단일 파일 리뷰로는 절대 잡히지 않는 버그를 어떻게 찾아내는지도 확인합니다.
-## 🎯 Learning Objectives
+## 🎯 학습 목표
-By the end of this chapter, you'll be able to:
+이 장을 마치면 다음을 할 수 있습니다:
-- Use the `@` syntax to reference files, directories, and images
-- Resume previous sessions with `--resume` and `--continue`
-- Understand how [context windows](../GLOSSARY.md#context-window) work
-- Write effective multi-turn conversations
-- Manage directory permissions for multi-project workflows
+- `@` 문법으로 파일, 디렉터리, 이미지 참조하기
+- `--resume`, `--continue`로 이전 세션 이어서 작업하기
+- [컨텍스트 윈도우](../GLOSSARY.md#context-window)가 어떻게 동작하는지 이해하기
+- 여러 턴(multi-turn) 대화를 효과적으로 작성하기
+- 여러 프로젝트를 다루는 워크플로에서 디렉터리 권한 관리하기
-> ⏱️ **Estimated Time**: ~50 minutes (20 min reading + 30 min hands-on)
+> ⏱️ **예상 소요 시간**: 약 50분 (읽기 20분 + 실습 30분)
---
-## 🧩 Real-World Analogy: Working with a Colleague
+## 🧩 현실 비유: 동료와 함께 일하기
-🔧 Common Mistakes & Troubleshooting (click to expand)
+🔧 자주 하는 실수 & 문제 해결 (클릭하여 펼치기)
-### Common Mistakes +### 자주 하는 실수 -| Mistake | What Happens | Fix | -|---------|--------------|-----| -| Typing `exit` instead of `/exit` | Copilot CLI treats "exit" as a prompt, not a command | Slash commands always start with `/` | -| Using `-p` for multi-turn conversations | Each `-p` call is isolated with no memory of previous calls | Use interactive mode (`copilot`) for conversations that build on context | -| Forgetting quotes around prompts with `$` or `!` | Shell interprets special characters before Copilot CLI sees them | Wrap prompts in quotes: `copilot -p "What does $HOME mean?"` | +| 실수 | 어떤 일이 발생하나 | 해결 | +|------|------------------|------| +| `exit`를 `/exit` 대신 입력 | Copilot CLI는 `exit`를 명령이 아닌 프롬프트로 처리 | 슬래시 명령은 항상 `/`로 시작합니다 | +| 여러 턴 대화를 `-p`로 시도 | `-p` 호출은 매번 독립적이라 이전 맥락이 없음 | 맥락이 쌓이는 대화는 Interactive 모드(`copilot`) 사용 | +| `$`나 `!`가 포함된 프롬프트에 따옴표를 빼먹음 | 셸이 특수문자를 Copilot CLI보다 먼저 해석 | 프롬프트를 따옴표로 감싸기: `copilot -p "$HOME 이 뭐야?"` | -### Troubleshooting +### 문제 해결 -**"Model not available"** - Your subscription may not include all models. Use `/model` to see what's available. +**"Model not available"** - 구독에 따라 일부 모델은 제공되지 않을 수 있습니다. `/model`로 사용 가능 모델을 확인하세요. -**"Context too long"** - Your conversation has used the full context window. Use `/clear` to reset, or start a new session. +**"Context too long"** - 대화가 컨텍스트 윈도우를 초과했습니다. `/clear`로 초기화하거나 새 세션을 시작하세요. -**"Rate limit exceeded"** - Wait a few minutes and try again. Consider using programmatic mode for batch operations with delays. +**"Rate limit exceeded"** - 몇 분 기다린 뒤 다시 시도하세요. 배치 작업은 프로그램형 모드를 사용하되, 지연을 넣는 것을 고려하세요.
+
-*Just like your colleagues, Copilot CLI isn't a mind reader. Providing more information helps humans and Copilot alike provide targeted support!*
+*동료와 마찬가지로 Copilot CLI도 마음을 읽지 못합니다. 더 많은 정보를 제공하면 사람도 Copilot도 더 정확하고 목적에 맞는 도움을 줄 수 있어요!*
-Imagine explaining a bug to a colleague:
+동료에게 버그를 설명한다고 상상해보세요:
-> **Without context**: "The book app doesn't work."
+> **컨텍스트 없이**: "책 앱이 안 돼요."
-> **With context**: "Look at `books.py`, especially the `find_book_by_title` function. It's not doing case-insensitive matching."
+> **컨텍스트와 함께**: "`books.py`를 봐 주세요. 특히 `find_book_by_title` 함수가 대소문자 구분 없이(case-insensitive) 매칭을 하지 못하고 있어요."
-To provide context to Copilot CLI use *the `@` syntax* to point Copilot CLI at specific files.
+Copilot CLI에 컨텍스트를 제공하려면 *`@` 문법*을 사용해 Copilot CLI가 특정 파일을 보도록 지정하면 됩니다.
---
-# Essential: Basic Context
+# 필수: 기본 컨텍스트
-
+
-This section covers everything you need to work effectively with context. Master these basics first.
+이 섹션은 컨텍스트를 효과적으로 다루기 위해 꼭 필요한 내용을 다룹니다. 먼저 이 기본기를 확실히 익혀보세요.
---
-## The @ Syntax
+## @ 문법
-The `@` symbol references files and directories in your prompts. It's how you tell Copilot CLI "look at this file."
+프롬프트에서 `@` 기호는 파일과 디렉터리를 참조합니다. Copilot CLI에게 "이 파일을 봐"라고 지시하는 방법입니다.
-> 💡 **Note**: All examples in this course use the `samples/` folder included in this repository, so you can try every command directly.
+> 💡 **참고**: 이 과정의 모든 예시는 이 저장소에 포함된 `samples/` 폴더를 사용합니다. 그래서 모든 명령을 그대로 따라 해볼 수 있어요.
-### Try It Now (No Setup Required)
+### 지금 바로 해보기 (설정 불필요)
-You can try this with any file on your computer:
+내 컴퓨터에 있는 어떤 파일로도 테스트할 수 있습니다:
```bash
copilot
-# Point at any file you have
-> Explain what @package.json does
-> Summarize @README.md
-> What's in @.gitignore and why?
+# 가지고 있는 아무 파일이나 지정해보기
+> @package.json이 하는 일을 설명해줘
+> @README.md를 요약해줘
+> @.gitignore에는 뭐가 있고 왜 필요해?
```
-> 💡 **Don't have a project handy?** Create a quick test file:
+> 💡 **프로젝트가 없나요?** 빠르게 테스트 파일을 만들어보세요:
> ```bash
> echo "def greet(name): return 'Hello ' + name" > test.py
> copilot
-> > What does @test.py do?
+> > @test.py가 하는 일이 뭐야?
> ```
-### Basic @ Patterns
+### 기본 @ 패턴
-| Pattern | What It Does | Example Use |
+| 패턴 | 의미 | 사용 예 |
|---------|--------------|-------------|
-| `@file.py` | Reference a single file | `Review @samples/book-app-project/books.py` |
-| `@folder/` | Reference all files in a directory | `Review @samples/book-app-project/` |
-| `@file1.py @file2.py` | Reference multiple files | `Compare @samples/book-app-project/book_app.py @samples/book-app-project/books.py` |
+| `@file.py` | 단일 파일 참조 | `Review @samples/book-app-project/books.py` |
+| `@folder/` | 디렉터리 내 모든 파일 참조 | `Review @samples/book-app-project/` |
+| `@file1.py @file2.py` | 여러 파일을 함께 참조 | `Compare @samples/book-app-project/book_app.py @samples/book-app-project/books.py` |
-### Reference a Single File
+### 단일 파일 참조하기
```bash
copilot
-> Explain what @samples/book-app-project/utils.py does
+> @samples/book-app-project/utils.py가 하는 일을 설명해줘
```
---
-
---
-### Reference Multiple Files
+### 여러 파일 참조하기
```bash
copilot
-> Compare @samples/book-app-project/book_app.py and @samples/book-app-project/books.py for consistency
+> @samples/book-app-project/book_app.py와 @samples/book-app-project/books.py를 일관성 관점에서 비교해줘
```
-### Reference an Entire Directory
+### 디렉터리 전체 참조하기
```bash
copilot
-> Review all files in @samples/book-app-project/ for error handling
+> @samples/book-app-project/ 안의 모든 파일을 검토해서 에러 처리가 어떤지 봐줘
```
---
-## Cross-File Intelligence
+## 파일 간 인텔리전스(Cross-File Intelligence)
-This is where context becomes a superpower. Single-file analysis is useful. Cross-file analysis is transformative.
+여기서부터 컨텍스트가 ‘초능력’이 됩니다. 단일 파일 분석은 유용하지만, 여러 파일을 함께 보는 분석은 완전히 다른 차원의 도움을 줍니다.
-🎬 See it in action!
+🎬 실제 동작 보기!
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 환경에 따라 달라질 수 있습니다. 모델, 도구, 응답은 화면에 보이는 것과 다를 수 있어요.*
+
-### Demo: Find Bugs That Span Multiple Files
+### 데모: 여러 파일에 걸친 버그 찾기
```bash
copilot
> @samples/book-app-project/book_app.py @samples/book-app-project/books.py
>
-> How do these files work together? What's the data flow?
+> 이 파일들은 어떻게 함께 동작해? 데이터 흐름은 어떻게 돼?
```
-> 💡 **Advanced Option**: For security-focused cross-file analysis, try the Python security examples:
+> 💡 **고급 옵션**: 보안 관점의 파일 간 분석을 하고 싶다면, Python 보안 예시를 시도해보세요:
> ```bash
> > @samples/buggy-code/python/user_service.py @samples/buggy-code/python/payment_processor.py
-> > Find security vulnerabilities that span BOTH files
+> > 두 파일 모두에 걸친 보안 취약점을 찾아줘
> ```
---
-
---
-**What Copilot CLI discovers**:
+**Copilot CLI가 찾아내는 것들**:
```
-Cross-Module Analysis
-=====================
+모듈 간 분석
+=============
-1. DATA FLOW PATTERN
- book_app.py creates BookCollection instance and calls methods
- books.py defines BookCollection class and manages data persistence
+1. 데이터 흐름 패턴
+ book_app.py는 BookCollection 인스턴스를 만들고 메서드를 호출
+ books.py는 BookCollection 클래스를 정의하고 데이터 저장을 관리
- Flow: book_app.py (UI) → books.py (business logic) → data.json (storage)
+ 흐름: book_app.py (UI) → books.py (비즈니스 로직) → data.json (저장소)
-2. DUPLICATE DISPLAY FUNCTIONS
- book_app.py:9-21 show_books() function
- utils.py:28-36 print_books() function
+2. 중복된 출력 함수
+ book_app.py:9-21 show_books() 함수
+ utils.py:28-36 print_books() 함수
- Impact: Two nearly identical functions doing the same thing. If you update
- one (like changing the format), you must remember to update the other.
+ 영향: 거의 동일한 두 함수가 같은 일을 함. 한쪽을 업데이트하면
+ 다른 쪽도 잊지 않고 업데이트해야 함.
-3. INCONSISTENT ERROR HANDLING
- book_app.py handles ValueError from year conversion
- books.py silently returns None/False on errors
+3. 일관되지 않은 에러 처리
+ book_app.py는 연도 변환에서 ValueError를 처리
+ books.py는 에러 시 조용히 None/False를 반환
- Pattern: No unified approach to error handling across modules
+ 패턴: 모듈 간 에러 처리 방식이 통일되어 있지 않음
```
-**Why this matters**: A single-file review would miss the bigger picture. Only cross-file analysis reveals:
-- **Duplicate code** that should be consolidated
-- **Data flow patterns** showing how components interact
-- **Architectural issues** that affect maintainability
+**왜 중요할까요?** 단일 파일 리뷰로는 큰 그림을 놓치기 쉽습니다. 파일 간 분석을 해야만 다음을 발견할 수 있어요:
+- **중복 코드**(통합이 필요)
+- 컴포넌트가 어떻게 상호작용하는지 보여주는 **데이터 흐름 패턴**
+- 유지보수성에 영향을 주는 **아키텍처 이슈**
---
-### Demo: Understand a Codebase in 60 Seconds
+### 데모: 60초 만에 코드베이스 이해하기
-🎬 See it in action!
+🎬 실제 동작 보기!
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 환경에 따라 달라질 수 있습니다. 모델, 도구, 응답은 화면에 보이는 것과 다를 수 있어요.*
+
-New to a project? Learn about it quickly using Copilot CLI.
+새 프로젝트에 합류했나요? Copilot CLI로 빠르게 파악할 수 있습니다.
```bash
copilot
> @samples/book-app-project/
>
-> In one paragraph, what does this app do and what are its biggest quality issues?
+> 한 문단으로 이 앱이 뭘 하는지, 가장 큰 품질 이슈가 뭔지 말해줘
```
-**What you get**:
+**얻을 수 있는 결과**:
```
-This is a CLI book collection manager that lets users add, list, remove, and
-search books stored in a JSON file. The biggest quality issues are:
+이것은 JSON 파일에 저장된 책을 추가/목록/삭제/검색할 수 있는 CLI 책 컬렉션 관리자입니다.
+가장 큰 품질 이슈는 다음과 같습니다:
-1. Duplicate display logic - show_books() and print_books() do the same thing
-2. Inconsistent error handling - some errors raise exceptions, others return False
-3. No input validation - year can be 0, empty strings accepted for title/author
-4. Missing tests - no test coverage for critical functions like find_book_by_title
+1. 출력 로직 중복 - show_books()와 print_books()가 같은 일을 함
+2. 일관성 없는 에러 처리 - 어떤 에러는 예외를 던지고, 어떤 것은 False를 반환
+3. 입력 검증 부족 - year가 0일 수 있고, title/author에 빈 문자열도 허용
+4. 테스트 부재 - find_book_by_title 같은 핵심 함수에 대한 테스트 커버리지 없음
-Priority fix: Consolidate duplicate display functions and add input validation.
+우선순위: 중복 출력 함수를 통합하고 입력 검증을 추가하기
```
-
-**Result**: What takes an hour of code reading compressed into 10 seconds. You know exactly where to focus.
+**결과**: 1시간 걸릴 코드 읽기가 10초로 압축됩니다. 어디에 집중해야 할지 바로 알 수 있어요.
---
-## Practical Examples
+## 실전 예시
-### Example 1: Code Review with Context
+### 예시 1: 컨텍스트 기반 코드 리뷰
```bash
copilot
-> @samples/book-app-project/books.py Review this file for potential bugs
+> @samples/book-app-project/books.py 이 파일에서 잠재적인 버그를 리뷰해줘
-# Copilot CLI now has the full file content and can give specific feedback:
-# "Line 49: Case-sensitive comparison may miss books..."
-# "Line 29: JSON decode errors are caught but data corruption isn't logged..."
+# 이제 Copilot CLI는 전체 파일 내용을 알고, 구체적인 피드백을 줄 수 있습니다:
+# "49번째 줄: 대소문자 구분 비교 때문에 책을 놓칠 수 있음..."
+# "29번째 줄: JSON 디코드 에러를 잡지만 데이터 손상은 로그에 남지 않음..."
-> What about @samples/book-app-project/book_app.py?
+> @samples/book-app-project/book_app.py는 어때?
-# Now reviewing book_app.py, but still aware of books.py context
+# 이제 book_app.py도 리뷰하지만, 여전히 books.py의 컨텍스트를 알고 있음
```
-### Example 2: Understanding a Codebase
+### 예시 2: 코드베이스 이해하기
```bash
copilot
-> @samples/book-app-project/books.py What does this module do?
+> @samples/book-app-project/books.py 이 모듈은 무슨 역할이야?
-# Copilot CLI reads books.py and understands the BookCollection class
+# Copilot CLI가 books.py를 읽고 BookCollection 클래스를 이해함
-> @samples/book-app-project/ Give me an overview of the code structure
+> @samples/book-app-project/ 코드 구조를 한 번에 개요로 설명해줘
-# Copilot CLI scans the directory and summarizes
+# Copilot CLI가 디렉터리를 스캔하고 요약함
-> How does the app save and load books?
+> 앱은 책을 어떻게 저장하고 로드해?
-# Copilot CLI can trace through the code it's already seen
+# Copilot CLI는 이미 본 코드를 바탕으로 흐름을 추적할 수 있음
```
-
-### Example 3: Multi-File Refactoring
+### 예시 3: 여러 파일 리팩터링
```bash
copilot
> @samples/book-app-project/book_app.py @samples/book-app-project/utils.py
-> I see duplicate display functions: show_books() and print_books(). Help me consolidate these.
+> show_books()와 print_books()가 중복으로 보이는데, 통합하도록 도와줘.
-# Copilot CLI sees both files and can suggest how to merge the duplicate code
+# Copilot CLI는 두 파일을 모두 보고, 중복 코드를 합치는 방법을 제안할 수 있음
```
---
-## Session Management
+## 세션 관리
-Sessions are automatically saved as you work. You can resume previous sessions to continue where you left off.
+작업하는 동안 세션은 자동으로 저장됩니다. 이전 세션을 다시 열어서 중단한 지점부터 계속 작업할 수 있어요.
-### Sessions Auto-Save
+### 세션 자동 저장
-Every conversation is automatically saved. Just exit normally:
+모든 대화는 자동으로 저장됩니다. 정상적으로 종료하기만 하면 됩니다:
```bash
copilot
-> @samples/book-app-project/ Let's improve error handling across all modules
+> @samples/book-app-project/ 모든 모듈에서 에러 처리를 개선해보자
-[... do some work ...]
+[... 작업 ...]
> /exit
```
-### Resume the Most Recent Session
+### 가장 최근 세션 이어서 하기
```bash
-# Continue where you left off
+# 중단한 지점에서 계속
copilot --continue
```
-### Resume a Specific Session
+### 특정 세션 이어서 하기
```bash
-# Pick from a list of sessions interactively
+# 세션 목록에서 대화형으로 선택
copilot --resume
-# Or resume a specific session by ID
+# 또는 ID로 특정 세션 재개
copilot --resume abc123
```
-> 💡 **How do I find a session ID?** You don't need to memorize them. Running `copilot --resume` without an ID shows an interactive list of your previous sessions, their names, IDs, and when they were last active. Just pick the one you want.
+> 💡 **세션 ID는 어떻게 찾나요?** 외울 필요 없습니다. `copilot --resume`를 ID 없이 실행하면 이전 세션 목록(이름, ID, 마지막 활동 시각)이 대화형으로 표시됩니다. 거기서 원하는 것을 고르면 됩니다.
>
-> **What about multiple terminals?** Each terminal window is its own session with its own context. If you have Copilot CLI open in three terminals, that's three separate sessions. Running `--resume` from any terminal lets you browse all of them. The `--continue` flag grabs whichever session was closed most recently, no matter which terminal it was in.
+> **터미널이 여러 개라면?** 터미널 창마다 세션이 별도로 존재하며 각각의 컨텍스트를 가집니다. Copilot CLI를 세 개 터미널에서 켜두면 세 개의 세션이 생기는 셈입니다. 어떤 터미널에서든 `--resume`로 전체 목록을 탐색할 수 있고, `--continue`는 어떤 터미널에서든 *가장 마지막에 닫힌* 세션을 이어줍니다.
>
-> **Can I switch sessions without restarting?** Yes. Use the `/resume` slash command from inside an active session:
+> **재시작 없이 세션을 바꿀 수 있나요?** 네. 활성 세션 안에서 `/resume` 슬래시 명령을 사용하세요:
> ```
> > /resume
-> # Shows a list of sessions to switch to
+> # 전환할 세션 목록 표시
> ```
-### Organize Your Sessions
+### 세션 정리하기
-Give sessions meaningful names so you can find them later:
+나중에 찾기 쉽게 세션에 의미 있는 이름을 붙여보세요:
```bash
copilot
> /rename book-app-review
-# Session renamed for easier identification
+# 세션 이름이 바뀌어 찾기 쉬워짐
```
-### Check and Manage Context
+### 컨텍스트 확인 및 관리
-As you add files and conversation, Copilot CLI's [context window](../GLOSSARY.md#context-window) fills up. Two commands help you stay in control:
+파일과 대화가 쌓이면 Copilot CLI의 [컨텍스트 윈도우](../GLOSSARY.md#context-window)가 점점 채워집니다. 두 가지 명령이 제어에 도움이 됩니다:
```bash
copilot
> /context
-Context usage: 45,000 / 128,000 tokens (35%)
+컨텍스트 사용량: 45,000 / 128,000 토큰 (35%)
> /clear
-# Wipes context and starts fresh. Use when switching topics
+# 컨텍스트를 지우고 새로 시작. 주제가 바뀔 때 유용
```
-> 💡 **When to use `/clear`**: If you've been reviewing `books.py` and want to switch to discussing `utils.py`, run `/clear` first. Otherwise stale context from the old topic may confuse responses.
+> 💡 **`/clear`를 언제 쓰나요?** 예를 들어 `books.py`를 리뷰하다가 `utils.py` 이야기로 넘어가고 싶다면 `/clear`를 먼저 실행하세요. 이전 주제의 컨텍스트가 남아 있으면 응답이 헷갈릴 수 있습니다.
---
-### Pick Up Where You Left Off
+### 중단한 지점에서 다시 시작하기
-🎬 See a multi-turn conversation in action!
+🎬 여러 턴 대화 예시 보기!
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 환경에 따라 달라질 수 있습니다. 모델, 도구, 응답은 화면에 보이는 것과 다를 수 있어요.*
+
-*Sessions auto-save when you exit. Resume days later with full context: files, issues, and progress all remembered.*
+*세션은 종료 시 자동 저장됩니다. 며칠 뒤에도 파일/이슈/진행 상황까지 포함해 완전한 컨텍스트로 재개할 수 있어요.*
-Imagine this workflow across multiple days:
+여러 날에 걸친 워크플로를 상상해보세요:
```bash
-# Monday: Start book app review
+# 월요일: 책 앱 리뷰 시작
copilot
> /rename book-app-review
> @samples/book-app-project/books.py
-> Review and number all code quality issues
+> 코드 품질 이슈를 전부 찾아 번호를 매겨줘
-Quality Issues Found:
-1. Duplicate display functions (book_app.py & utils.py) - MEDIUM
-2. No input validation for empty strings - MEDIUM
-3. Year can be 0 or negative - LOW
-4. No type hints on all functions - LOW
-5. Missing error logging - LOW
+발견된 품질 이슈:
+1. 출력 함수 중복 (book_app.py & utils.py) - 중간
+2. 빈 문자열 입력에 대한 검증 없음 - 중간
+3. year가 0 또는 음수일 수 있음 - 낮음
+4. 모든 함수에 타입 힌트가 없음 - 낮음
+5. 에러 로깅 누락 - 낮음
-> Fix issue #1 (duplicate functions)
-# Work on the fix...
+> 이슈 #1(중복 함수)을 고쳐줘
+# 수정 작업...
> /exit
```
-
```bash
-# Wednesday: Resume exactly where you left off
+# 수요일: 중단한 지점에서 그대로 재개
copilot --continue
-> What issues remain unfixed from our book app review?
+> 책 앱 리뷰에서 아직 해결되지 않은 이슈가 뭐였지?
-Remaining issues from our book-app-review session:
-2. No input validation for empty strings - MEDIUM
-3. Year can be 0 or negative - LOW
-4. No type hints on all functions - LOW
-5. Missing error logging - LOW
+book-app-review 세션에서 남은 이슈:
+2. 빈 문자열 입력에 대한 검증 없음 - 중간
+3. year가 0 또는 음수일 수 있음 - 낮음
+4. 모든 함수에 타입 힌트가 없음 - 낮음
+5. 에러 로깅 누락 - 낮음
-Issue #1 (duplicate functions) was fixed on Monday.
+이슈 #1(중복 함수)은 월요일에 해결됨.
-> Let's tackle issue #2 next
+> 그럼 이슈 #2를 하자
```
-**What makes this powerful**: Days later, Copilot CLI remembers:
-- The exact file you were working on
-- The numbered list of issues
-- Which ones you've already addressed
-- The context of your conversation
+**이게 강력한 이유**: 며칠 뒤에도 Copilot CLI는 다음을 기억합니다:
+- 작업 중이던 정확한 파일
+- 번호 매긴 이슈 목록
+- 이미 해결한 항목
+- 대화의 흐름과 배경
-No re-explaining. No re-reading files. Just continue working.
+다시 설명할 필요도, 다시 읽을 필요도 없이 바로 이어서 작업할 수 있습니다.
---
-**🎉 You now know the essentials!** The `@` syntax, session management (`--continue`/`--resume`/`/rename`), and context commands (`/context`/`/clear`) are enough to be highly productive. Everything below is optional. Return to it when you're ready.
+**🎉 이제 필수는 끝났습니다!** `@` 문법, 세션 관리(`--continue`/`--resume`/`/rename`), 컨텍스트 명령(`/context`/`/clear`)만으로도 생산성을 크게 높일 수 있어요. 아래 내용은 선택 사항입니다. 필요할 때 다시 돌아와도 됩니다.
---
-# Optional: Going Deeper
+# 선택: 더 깊게 알아보기
-
+
-These topics build on the essentials above. **Pick what interests you, or skip ahead to [Practice](#practice).**
+아래 주제들은 위의 필수 내용을 바탕으로 확장합니다. **관심 있는 것만 골라 보거나, [Practice](#practice)로 바로 넘어가도 됩니다.**
-| I want to learn about... | Jump to |
+| 이런 걸 배우고 싶어요... | 이동 |
|---|---|
-| Wildcard patterns and advanced session commands | [Additional @ Patterns & Session Commands](#additional-patterns) |
-| Building on context across multiple prompts | [Context-Aware Conversations](#context-aware-conversations) |
-| Token limits and `/compact` | [Understanding Context Windows](#understanding-context-windows) |
-| How to pick the right files to reference | [Choosing What to Reference](#choosing-what-to-reference) |
-| Analyzing screenshots and mockups | [Working with Images](#working-with-images) |
+| 와일드카드 패턴과 고급 세션 명령 | [추가 @ 패턴 & 세션 명령](#additional-patterns) |
+| 여러 프롬프트에 걸쳐 컨텍스트를 쌓아가는 대화 | [컨텍스트 인지 대화](#context-aware-conversations) |
+| 토큰 제한과 `/compact` | [컨텍스트 윈도우 이해하기](#understanding-context-windows) |
+| 어떤 파일을 참조할지 고르는 방법 | [무엇을 참조할지 선택하기](#choosing-what-to-reference) |
+| 스크린샷/목업 분석 | [이미지 다루기](#working-with-images) |
-
Additional @ Patterns & Session Commands
+추가 @ 패턴 & 세션 명령
-### Additional @ Patterns +### 추가 @ 패턴 -For power users, Copilot CLI supports wildcard patterns and image references: +파워 유저를 위해 Copilot CLI는 와일드카드 패턴과 이미지 참조도 지원합니다: -| Pattern | What It Does | +| 패턴 | 의미 | |---------|--------------| -| `@folder/*.py` | All .py files in folder | -| `@**/test_*.py` | Recursive wildcard: find all test files anywhere | -| `@image.png` | Image file for UI review | +| `@folder/*.py` | 폴더 내 모든 .py 파일 | +| `@**/test_*.py` | 재귀 와일드카드: 어디에 있든 test 파일 찾기 | +| `@image.png` | UI 리뷰용 이미지 파일 | ```bash copilot -> Find all TODO comments in @samples/book-app-project/**/*.py +> @samples/book-app-project/**/*.py 에서 TODO 주석을 전부 찾아줘 ``` -### View Session Info +### 세션 정보 보기 ```bash copilot > /session -# Shows current session details and workspace summary +# 현재 세션 상세와 워크스페이스 요약 표시 > /usage -# Shows session metrics and statistics +# 세션 지표와 통계 표시 ``` -### Share Your Session +### 세션 공유하기 ```bash copilot > /share file ./my-session.md -# Exports session as a markdown file +# 세션을 마크다운 파일로 내보내기 > /share gist -# Creates a GitHub gist with the session +# 세션을 GitHub Gist로 생성 ```
-
Context-Aware Conversations
+컨텍스트 인지 대화
-### Context-Aware Conversations +### 컨텍스트 인지 대화 -The magic happens when you have multi-turn conversations that build on each other. +진짜 마법은 여러 턴에 걸쳐 대화를 이어가며, 이전 내용을 바탕으로 점점 더 발전시키는 데서 일어납니다. -#### Example: Progressive Enhancement +#### 예시: 점진적 개선(Progressive Enhancement) ```bash copilot -> @samples/book-app-project/books.py Review the BookCollection class +> @samples/book-app-project/books.py BookCollection 클래스를 리뷰해줘 -Copilot CLI: "The class looks functional, but I notice: -1. Missing type hints on some methods -2. No validation for empty title/author -3. Could benefit from better error handling" +Copilot CLI: "클래스는 동작하는 것 같지만 다음이 보여요: +1. 일부 메서드에 타입 힌트 누락 +2. 빈 title/author에 대한 검증 없음 +3. 더 나은 에러 처리가 있으면 좋겠음" -> Add type hints to all methods +> 모든 메서드에 타입 힌트를 추가해줘 -Copilot CLI: "Here's the class with complete type hints..." -[Shows typed version] +Copilot CLI: "완전한 타입 힌트를 적용한 버전은 다음과 같아요..." +[타입 추가 버전 표시] -> Now improve error handling +> 이제 에러 처리를 개선해줘 -Copilot CLI: "Building on the typed version, here's improved error handling..." -[Adds validation and proper exceptions] +Copilot CLI: "타입이 적용된 버전을 바탕으로, 개선된 에러 처리를 이렇게 적용할 수 있어요..." +[검증 및 적절한 예외 추가] -> Generate tests for this final version +> 최종 버전에 대한 테스트를 생성해줘 -Copilot CLI: "Based on the class with types and error handling..." -[Generates comprehensive tests] +Copilot CLI: "타입과 에러 처리가 적용된 클래스를 기준으로..." +[포괄적인 테스트 생성] ``` -Notice how each prompt builds on the previous work. This is the power of context. +각 프롬프트가 이전 작업 위에 쌓이는 것을 확인할 수 있습니다. 이것이 컨텍스트의 힘입니다.
-
+
-*The context window is like a desk: it can only hold so much at once. Files, conversation history, and system prompts all take space.*
+*컨텍스트 윈도우는 책상과 비슷합니다. 한 번에 올려둘 수 있는 공간은 제한적이며, 파일/대화 히스토리/시스템 프롬프트가 모두 공간을 차지합니다.*
-#### What Happens at the Limit
+#### 한계에 도달하면 무슨 일이 일어나나요?
```bash
copilot
> /context
-Context usage: 45,000 / 128,000 tokens (35%)
+컨텍스트 사용량: 45,000 / 128,000 토큰 (35%)
-# As you add more files and conversation, this grows
+# 파일과 대화가 늘어나면 이 수치는 계속 증가
> @large-codebase/
-Context usage: 120,000 / 128,000 tokens (94%)
+컨텍스트 사용량: 120,000 / 128,000 토큰 (94%)
-# Warning: Approaching context limit
+# 경고: 컨텍스트 한계에 근접
> @another-large-file.py
-Context limit reached. Older context will be summarized.
+컨텍스트 한계 도달. 오래된 컨텍스트는 요약됩니다.
```
-#### The `/compact` Command
+#### `/compact` 명령
-When your context is getting full but you don't want to lose the conversation, `/compact` summarizes your history to free up tokens:
+컨텍스트가 가득 차 가는데 대화 흐름은 유지하고 싶다면, `/compact`가 히스토리를 요약해 토큰을 확보해줍니다:
```bash
copilot
> /compact
-# Summarizes conversation history, freeing up context space
-# Your key findings and decisions are preserved
+# 대화 히스토리를 요약해 컨텍스트 공간을 확보
+# 핵심 발견과 결정은 유지됨
```
-#### Context Efficiency Tips
+#### 컨텍스트 효율 팁
-| Situation | Action | Why |
+| 상황 | 행동 | 이유 |
|-----------|--------|-----|
-| Starting new topic | `/clear` | Removes irrelevant context |
-| Long conversation | `/compact` | Summarizes history, frees tokens |
-| Need specific file | `@file.py` not `@folder/` | Loads only what you need |
-| Hitting limits | Start new session | Fresh 128K context |
-| Multiple topics | Use `/rename` per topic | Easy to resume right session |
+| 새 주제 시작 | `/clear` | 관련 없는 컨텍스트 제거 |
+| 대화가 너무 길어짐 | `/compact` | 히스토리를 요약해 토큰 확보 |
+| 특정 파일만 필요 | `@folder/`보다 `@file.py` | 필요한 것만 불러와 컨텍스트 절약 |
+| 한계에 자주 도달 | 새 세션 시작 | 새로운 128K 컨텍스트 |
+| 주제가 여러 개 | 주제별로 `/rename` | 올바른 세션을 쉽게 재개 |
-#### Best Practices for Large Codebases
+#### 대규모 코드베이스 베스트 프랙티스
-1. **Be specific**: `@samples/book-app-project/books.py` instead of `@samples/book-app-project/`
-2. **Clear between topics**: Use `/clear` when switching focus
-3. **Use `/compact`**: Summarize conversation to free up context
-4. **Use multiple sessions**: One session per feature or topic
+1. **구체적으로 지정**: `@samples/book-app-project/` 대신 `@samples/book-app-project/books.py`
+2. **주제 전환 시 초기화**: 포커스가 바뀌면 `/clear`
+3. **`/compact` 활용**: 대화를 요약해 토큰 확보
+4. **세션 분리**: 기능/주제별로 세션을 나눠 사용
Understanding Context Windows
+컨텍스트 윈도우 이해하기
-### Understanding Context Windows +### 컨텍스트 윈도우 이해하기 -You already know `/context` and `/clear` from the essentials. Here's the deeper picture of how context windows work. +필수 파트에서 `/context`, `/clear`를 이미 보았습니다. 여기서는 컨텍스트 윈도우가 어떻게 동작하는지 더 깊게 살펴봅니다. -Every AI has a "context window," which is the amount of text it can consider at once. +모든 AI에는 한 번에 고려할 수 있는 텍스트의 양인 "컨텍스트 윈도우"가 있습니다. -
+
-*The context window is like a desk: it can only hold so much at once. Files, conversation history, and system prompts all take space.*
+*컨텍스트 윈도우는 책상과 비슷합니다. 한 번에 올려둘 수 있는 공간은 제한적이며, 파일/대화 히스토리/시스템 프롬프트가 모두 공간을 차지합니다.*
-#### What Happens at the Limit
+#### 한계에 도달하면 무슨 일이 일어나나요?
```bash
copilot
> /context
-Context usage: 45,000 / 128,000 tokens (35%)
+컨텍스트 사용량: 45,000 / 128,000 토큰 (35%)
-# As you add more files and conversation, this grows
+# 파일과 대화가 늘어나면 이 수치는 계속 증가
> @large-codebase/
-Context usage: 120,000 / 128,000 tokens (94%)
+컨텍스트 사용량: 120,000 / 128,000 토큰 (94%)
-# Warning: Approaching context limit
+# 경고: 컨텍스트 한계에 근접
> @another-large-file.py
-Context limit reached. Older context will be summarized.
+컨텍스트 한계 도달. 오래된 컨텍스트는 요약됩니다.
```
-#### The `/compact` Command
+#### `/compact` 명령
-When your context is getting full but you don't want to lose the conversation, `/compact` summarizes your history to free up tokens:
+컨텍스트가 가득 차 가는데 대화 흐름은 유지하고 싶다면, `/compact`가 히스토리를 요약해 토큰을 확보해줍니다:
```bash
copilot
> /compact
-# Summarizes conversation history, freeing up context space
-# Your key findings and decisions are preserved
+# 대화 히스토리를 요약해 컨텍스트 공간을 확보
+# 핵심 발견과 결정은 유지됨
```
-#### Context Efficiency Tips
+#### 컨텍스트 효율 팁
-| Situation | Action | Why |
+| 상황 | 행동 | 이유 |
|-----------|--------|-----|
-| Starting new topic | `/clear` | Removes irrelevant context |
-| Long conversation | `/compact` | Summarizes history, frees tokens |
-| Need specific file | `@file.py` not `@folder/` | Loads only what you need |
-| Hitting limits | Start new session | Fresh 128K context |
-| Multiple topics | Use `/rename` per topic | Easy to resume right session |
+| 새 주제 시작 | `/clear` | 관련 없는 컨텍스트 제거 |
+| 대화가 너무 길어짐 | `/compact` | 히스토리를 요약해 토큰 확보 |
+| 특정 파일만 필요 | `@folder/`보다 `@file.py` | 필요한 것만 불러와 컨텍스트 절약 |
+| 한계에 자주 도달 | 새 세션 시작 | 새로운 128K 컨텍스트 |
+| 주제가 여러 개 | 주제별로 `/rename` | 올바른 세션을 쉽게 재개 |
-#### Best Practices for Large Codebases
+#### 대규모 코드베이스 베스트 프랙티스
-1. **Be specific**: `@samples/book-app-project/books.py` instead of `@samples/book-app-project/`
-2. **Clear between topics**: Use `/clear` when switching focus
-3. **Use `/compact`**: Summarize conversation to free up context
-4. **Use multiple sessions**: One session per feature or topic
+1. **구체적으로 지정**: `@samples/book-app-project/` 대신 `@samples/book-app-project/books.py`
+2. **주제 전환 시 초기화**: 포커스가 바뀌면 `/clear`
+3. **`/compact` 활용**: 대화를 요약해 토큰 확보
+4. **세션 분리**: 기능/주제별로 세션을 나눠 사용
-
Choosing What to Reference
+무엇을 참조할지 선택하기
-### Choosing What to Reference +### 무엇을 참조할지 선택하기 -Not all files are equal when it comes to context. Here's how to choose wisely: +컨텍스트 관점에서 모든 파일이 똑같은 가치를 갖는 건 아닙니다. 효율적으로 선택하는 법을 알아봅시다. -#### File Size Considerations +#### 파일 크기 고려 -| File Size | Approximate [Tokens](../GLOSSARY.md#token) | Strategy | +| 파일 크기 | 대략적인 [토큰](../GLOSSARY.md#token) | 전략 | |-----------|-------------------|----------| -| Small (<100 lines) | ~500-1,500 tokens | Reference freely | -| Medium (100-500 lines) | ~1,500-7,500 tokens | Reference specific files | -| Large (500+ lines) | 7,500+ tokens | Be selective, use specific files | -| Very Large (1000+ lines) | 15,000+ tokens | Consider splitting or targeting sections | +| 작음 (<100줄) | 약 500~1,500 토큰 | 자유롭게 참조 | +| 중간 (100~500줄) | 약 1,500~7,500 토큰 | 특정 파일 위주로 참조 | +| 큼 (500+줄) | 7,500+ 토큰 | 선택적으로, 구체적으로 | +| 매우 큼 (1000+줄) | 15,000+ 토큰 | 분리하거나 필요한 부분만 지정 고려 | -**Concrete examples:** -- The book app's 4 Python files combined ≈ 2,000-3,000 tokens -- A typical Python module (200 lines) ≈ 3,000 tokens -- A Flask API file (400 lines) ≈ 6,000 tokens -- Your package.json ≈ 200-500 tokens -- A short prompt + response ≈ 500-1,500 tokens +**구체적 예시:** +- 책 앱의 Python 파일 4개 합계 ≈ 2,000~3,000 토큰 +- 일반적인 Python 모듈(200줄) ≈ 3,000 토큰 +- Flask API 파일(400줄) ≈ 6,000 토큰 +- package.json ≈ 200~500 토큰 +- 짧은 프롬프트 + 응답 ≈ 500~1,500 토큰 -> 💡 **Quick estimate for code:** Multiply lines of code by ~15 to get approximate tokens. Keep in mind this is only an estimate. +> 💡 **코드 토큰 빠른 추정:** 코드 줄 수 × 약 15 ≈ 토큰. (대략적인 추정치입니다.) -#### What to Include vs. Exclude +#### 포함할 것 vs 제외할 것 -**High value** (include these): -- Entry points (`book_app.py`, `main.py`, `app.py`) -- The specific files you're asking about -- Files directly imported by your target file -- Configuration files (`requirements.txt`, `pyproject.toml`) -- Data models or dataclasses +**가치가 큰 것(포함 추천):** +- 엔트리 포인트 (`book_app.py`, `main.py`, `app.py`) +- 지금 질문하는 대상 파일 +- 대상 파일이 직접 import하는 파일 +- 설정 파일 (`requirements.txt`, `pyproject.toml`) +- 데이터 모델/데이터클래스 -**Lower value** (consider excluding): -- Generated files (compiled output, bundled assets) -- Node modules or vendor directories -- Large data files or fixtures -- Files unrelated to your question +**가치가 낮은 것(제외 고려):** +- 생성된 파일(컴파일 산출물, 번들된 에셋) +- node_modules나 vendor 디렉터리 +- 큰 데이터 파일/픽스처 +- 질문과 무관한 파일 -#### The Specificity Spectrum +#### 구체성 스펙트럼 ``` -Less specific ────────────────────────► More specific +덜 구체적 ────────────────────────► 더 구체적 @samples/book-app-project/ @samples/book-app-project/books.py:47-52 │ │ - └─ Scans everything └─ Just what you need - (uses more context) (preserves context) + └─ 전부 스캔(컨텍스트 더 많이 사용) └─ 필요한 부분만(컨텍스트 절약) ``` -**When to go broad** (`@samples/book-app-project/`): -- Initial codebase exploration -- Finding patterns across many files -- Architecture reviews +**넓게 가야 할 때** (`@samples/book-app-project/`): +- 코드베이스 초반 탐색 +- 여러 파일에 걸친 패턴 찾기 +- 아키텍처 리뷰 -**When to go specific** (`@samples/book-app-project/books.py`): -- Debugging a particular issue -- Code review of a specific file -- Asking about a single function +**좁게 가야 할 때** (`@samples/book-app-project/books.py`): +- 특정 이슈 디버깅 +- 특정 파일 코드 리뷰 +- 특정 함수 질문 -#### Practical Example: Staged Context Loading +#### 실전 예시: 단계적으로 컨텍스트 로딩하기 ```bash copilot -# Step 1: Start with structure -> @package.json What frameworks does this project use? +# 1단계: 구조부터 파악 +> @package.json 이 프로젝트는 어떤 프레임워크를 써? -# Step 2: Narrow based on answer -> @samples/book-app-project/ Show me the project structure +# 2단계: 답변을 바탕으로 범위를 좁힘 +> @samples/book-app-project/ 프로젝트 구조를 보여줘 -# Step 3: Focus on what matters -> @samples/book-app-project/books.py Review the BookCollection class +# 3단계: 핵심에 집중 +> @samples/book-app-project/books.py BookCollection 클래스를 리뷰해줘 -# Step 4: Add related files only as needed -> @samples/book-app-project/book_app.py @samples/book-app-project/books.py How does the CLI use the BookCollection? +# 4단계: 필요할 때만 관련 파일 추가 +> @samples/book-app-project/book_app.py @samples/book-app-project/books.py CLI가 BookCollection을 어떻게 쓰는지 설명해줘 ``` -This staged approach keeps context focused and efficient. +이렇게 단계적으로 접근하면 컨텍스트를 더 집중적이고 효율적으로 사용할 수 있습니다.
-
@@ -680,194 +677,194 @@ copilot
# Practice
-Working with Images
+이미지 다루기
-### Working with Images +### 이미지 다루기 -You can include images in your conversations using the `@` syntax, or simply **paste from your clipboard** (Cmd+V / Ctrl+V). Copilot CLI can analyze screenshots, mockups, and diagrams to help with UI debugging, design implementation, and error analysis. +`@` 문법으로 이미지를 대화에 포함할 수 있고, 클립보드에서 그대로 붙여넣기(Cmd+V / Ctrl+V)도 가능합니다. Copilot CLI는 스크린샷/목업/다이어그램을 분석해 UI 디버깅, 디자인 구현, 에러 분석에 도움을 줄 수 있습니다. ```bash copilot -> @images/screenshot.png What is happening in this image? +> @images/screenshot.png 이 이미지에서 무슨 일이 벌어지고 있어? -> @images/mockup.png Write the HTML and CSS to match this design. Place it in a new file called index.html and put the CSS in styles.css. +> @images/mockup.png 이 디자인과 동일하게 보이도록 HTML/CSS를 작성해줘. index.html에 HTML을 두고, styles.css에 CSS를 넣어줘. ``` -> 📖 **Learn more**: See [Additional Context Features](../appendices/additional-context.md#working-with-images) for supported formats, practical use cases, and tips for combining images with code. +> 📖 **더 알아보기**: 지원 형식, 실전 활용, 이미지와 코드를 함께 쓰는 팁은 [추가 컨텍스트 기능](../appendices/additional-context.md#working-with-images)에서 확인하세요.
+
-Time to apply your context and session management skills.
+이제 컨텍스트와 세션 관리 스킬을 직접 적용해 봅시다.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 해보기
-### Full Project Review
+### 전체 프로젝트 리뷰
-The course includes sample files you can review directly. Start copilot and run the prompt shown next:
+이 과정에는 바로 리뷰할 수 있는 샘플 파일이 포함되어 있습니다. copilot을 시작한 뒤, 다음 프롬프트를 실행해보세요:
```bash
copilot
-> @samples/book-app-project/ Give me a code quality review of this project
+> @samples/book-app-project/ 이 프로젝트의 코드 품질 리뷰를 해줘
-# Copilot CLI will identify issues like:
-# - Duplicate display functions
-# - Missing input validation
-# - Inconsistent error handling
+# Copilot CLI는 다음 같은 이슈를 찾아낼 수 있습니다:
+# - 출력 함수 중복
+# - 입력 검증 부족
+# - 일관성 없는 에러 처리
```
-> 💡 **Want to try with your own files?** Create a small Python project (`mkdir -p my-project/src`), add some .py files, then use `@my-project/src/` to review them. You can ask copilot to create sample code for you if you'd like!
+> 💡 **내 파일로 해보고 싶나요?** 작은 Python 프로젝트를 만들어보세요(`mkdir -p my-project/src`). .py 파일을 몇 개 추가한 뒤 `@my-project/src/`를 리뷰해보면 됩니다. 원한다면 copilot에게 샘플 코드를 생성해달라고 요청할 수도 있어요!
-### Session Workflow
+### 세션 워크플로
```bash
copilot
> /rename book-app-review
-> @samples/book-app-project/books.py Let's add input validation for empty titles
+> @samples/book-app-project/books.py 빈 제목 입력에 대한 검증을 추가해보자
-[Copilot CLI suggests validation approach]
+[Copilot CLI가 검증 접근 방식을 제안]
-> Implement that fix
-> Now consolidate the duplicate display functions in @samples/book-app-project/
+> 그 수정사항을 구현해줘
+> 이제 @samples/book-app-project/에서 중복 출력 함수를 통합하자
> /exit
-# Later - resume where you left off
+# 나중에 - 중단한 지점에서 재개
copilot --continue
-> Generate tests for the changes we made
+> 우리가 만든 변경사항에 대한 테스트를 생성해줘
```
---
-After completing the demos, try these variations:
+데모를 끝냈다면, 아래 변형도 시도해보세요:
-1. **Cross-File Challenge**: Analyze how book_app.py and books.py work together:
+1. **파일 간 챌린지**: book_app.py와 books.py가 함께 어떻게 동작하는지 분석:
```bash
copilot
> @samples/book-app-project/book_app.py @samples/book-app-project/books.py
- > What's the relationship between these files? Are there any code smells?
+ > 이 파일들의 관계는 뭐야? 코드 스멜이 있을까?
```
-2. **Session Challenge**: Start a session, name it with `/rename my-first-session`, work on something, exit with `/exit`, then run `copilot --continue`. Does it remember what you were doing?
+2. **세션 챌린지**: 세션을 시작하고 `/rename my-first-session`으로 이름을 붙인 뒤, 뭔가 작업하고 `/exit`로 나가세요. 그 다음 `copilot --continue`를 실행해보세요. 정말로 하던 일을 기억하고 있나요?
-3. **Context Challenge**: Run `/context` mid-session. How many tokens are you using? Try `/compact` and check again. (See [Understanding Context Windows](#understanding-context-windows) in Going Deeper for more on `/compact`.)
+3. **컨텍스트 챌린지**: 세션 도중 `/context`를 실행해 토큰 사용량을 확인하세요. 그리고 `/compact`를 실행한 뒤 다시 확인해보세요. (자세한 내용은 Going Deeper의 [컨텍스트 윈도우 이해하기](#understanding-context-windows)를 참고하세요.)
-**Self-Check**: You understand context when you can explain why `@folder/` is more powerful than opening each file individually.
+**셀프 체크**: `@folder/`가 왜 파일을 하나씩 여는 것보다 더 강력한지 설명할 수 있다면, 컨텍스트를 이해한 것입니다.
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: Trace the Data Flow
+### 메인 챌린지: 데이터 흐름 추적하기
-The hands-on examples focused on code quality reviews and input validation. Now practice the same context skills on a different task, tracing how data moves through the app:
+실습 예시는 코드 품질 리뷰와 입력 검증에 집중했습니다. 이번에는 같은 컨텍스트 스킬을 다른 작업에 적용해, 앱에서 데이터가 어떻게 이동하는지 추적해보세요:
-1. Start an interactive session: `copilot`
-2. Reference `books.py` and `book_app.py` together:
- `@samples/book-app-project/books.py @samples/book-app-project/book_app.py Trace how a book goes from user input to being saved in data.json. What functions are involved at each step?`
-3. Bring in the data file for additional context:
- `@samples/book-app-project/data.json What happens if this JSON file is missing or corrupted? Which functions would fail?`
-4. Ask for a cross-file improvement:
- `@samples/book-app-project/books.py @samples/book-app-project/utils.py Suggest a consistent error-handling strategy that works across both files.`
-5. Rename the session: `/rename data-flow-analysis`
-6. Exit with `/exit`, then resume with `copilot --continue` and ask a follow-up question about the data flow
+1. 대화형 세션 시작: `copilot`
+2. `books.py`와 `book_app.py`를 함께 참조:
+ `@samples/book-app-project/books.py @samples/book-app-project/book_app.py 사용자 입력으로 들어온 책 정보가 data.json에 저장되기까지의 흐름을 추적해줘. 각 단계에서 어떤 함수가 관여해?`
+3. 데이터 파일도 컨텍스트로 추가:
+ `@samples/book-app-project/data.json 이 JSON 파일이 없거나 손상되면 어떻게 돼? 어떤 함수가 실패할까?`
+4. 파일 간 개선 제안 요청:
+ `@samples/book-app-project/books.py @samples/book-app-project/utils.py 두 파일에서 모두 통용되는 일관된 에러 처리 전략을 제안해줘.`
+5. 세션 이름 지정: `/rename data-flow-analysis`
+6. `/exit`로 종료한 뒤, `copilot --continue`로 재개하고 데이터 흐름에 대한 후속 질문을 해보세요
-**Success criteria**: You can trace data across multiple files, resume a named session, and get cross-file suggestions.
+**성공 기준**: 여러 파일에 걸쳐 데이터를 추적하고, 이름 붙인 세션을 재개하며, 파일 간 제안을 받을 수 있어야 합니다.
-` - Name your session for easy resuming
+**유용한 명령:**
+- `@file.py` - 단일 파일 참조
+- `@folder/` - 폴더 내 모든 파일 참조(끝에 `/` 포함)
+- `/context` - 컨텍스트 사용량 확인
+- `/rename ` - 세션 이름 지정
-### Bonus Challenge: Context Limits
+### 보너스 챌린지: 컨텍스트 한계
-1. Reference all the book app files at once with `@samples/book-app-project/`
-2. Ask several detailed questions about different files (`books.py`, `utils.py`, `book_app.py`, `data.json`)
-3. Run `/context` to see usage. How quickly does it fill up?
-4. Practice using `/compact` to reclaim space, then continue the conversation
-5. Try being more specific with file references (e.g., `@samples/book-app-project/books.py` instead of the whole folder) and see how it affects context usage
+1. `@samples/book-app-project/`로 책 앱 파일을 한 번에 모두 참조
+2. 여러 파일( `books.py`, `utils.py`, `book_app.py`, `data.json`)에 대해 자세한 질문을 여러 개 하기
+3. `/context`로 사용량을 확인. 얼마나 빨리 차는지 보기
+4. `/compact`로 공간을 확보하고 계속 대화하기
+5. 더 구체적인 참조(예: 전체 폴더 대신 `@samples/book-app-project/books.py`)로 바꿔 사용량 차이를 확인하기
---
💡 Hints (click to expand)
+💡 힌트 (클릭해서 펼치기)
-**Getting started:** +**시작하기:** ```bash cd /path/to/copilot-cli-for-beginners copilot -> @samples/book-app-project/books.py @samples/book-app-project/book_app.py Trace how a book goes from user input to being saved in data.json. -> @samples/book-app-project/data.json What happens if this file is missing or corrupted? +> @samples/book-app-project/books.py @samples/book-app-project/book_app.py 사용자 입력으로 들어온 책 정보가 data.json에 저장되기까지의 흐름을 추적해줘. +> @samples/book-app-project/data.json 이 파일이 없거나 손상되면 어떻게 돼? > /rename data-flow-analysis > /exit ``` -Then resume with: `copilot --continue` +그 다음 재개: `copilot --continue` -**Useful commands:** -- `@file.py` - Reference a single file -- `@folder/` - Reference all files in a folder (note the trailing `/`) -- `/context` - Check how much context you're using -- `/rename
-
---
-# Summary
+# 요약
-## 🔑 Key Takeaways
+## 🔑 핵심 정리
-1. **`@` syntax** gives Copilot CLI context about files, directories, and images
-2. **Multi-turn conversations** build on each other as context accumulates
-3. **Sessions auto-save**: use `--continue` or `--resume` to pick up where you left off
-4. **Context windows** have limits: manage them with `/context`, `/clear`, and `/compact`
-5. **Permission flags** (`--add-dir`, `--allow-all`) control multi-directory access. Use them wisely!
-6. **Image references** (`@screenshot.png`) help debug UI issues visually
+1. **`@` 문법**은 Copilot CLI에게 파일/디렉터리/이미지 컨텍스트를 제공합니다.
+2. **여러 턴 대화**는 컨텍스트가 누적되며 점점 더 발전합니다.
+3. **세션 자동 저장**: `--continue` 또는 `--resume`으로 이어서 작업할 수 있습니다.
+4. **컨텍스트 윈도우에는 한계가 있음**: `/context`, `/clear`, `/compact`로 관리하세요.
+5. **권한 플래그**(`--add-dir`, `--allow-all`)로 여러 디렉터리 접근을 제어합니다. 신중하게 사용하세요.
+6. **이미지 참조**(`@screenshot.png`)로 UI 이슈를 시각적으로 디버깅할 수 있습니다.
-> 📚 **Official Documentation**: [Use Copilot CLI](https://docs.github.com/copilot/how-tos/copilot-cli/use-copilot-cli) for the complete reference on context, sessions, and working with files.
+> 📚 **공식 문서**: 컨텍스트/세션/파일 작업에 대한 전체 레퍼런스는 [Copilot CLI 사용하기](https://docs.github.com/copilot/how-tos/copilot-cli/use-copilot-cli)를 참고하세요.
-> 📋 **Quick Reference**: See the [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for a complete list of commands and shortcuts.
+> 📋 **퀵 레퍼런스**: 명령 및 단축키 목록은 [GitHub Copilot CLI 명령 레퍼런스](https://docs.github.com/en/copilot/reference/cli-command-reference)를 참고하세요.
---
-## ➡️ What's Next
+## ➡️ 다음은?
-Now that you can give Copilot CLI context, let's put it to work on real development tasks. The context techniques you just learned (file references, cross-file analysis, and session management) are the foundation for the powerful workflows in the next chapter.
+이제 Copilot CLI에 컨텍스트를 제공하는 방법을 알게 되었으니, 실제 개발 작업에 적용해봅시다. 방금 배운 컨텍스트 테크닉(파일 참조, 파일 간 분석, 세션 관리)은 다음 장에서 다루는 강력한 워크플로의 기반이 됩니다.
-In **[Chapter 03: Development Workflows](../03-development-workflows/README.md)**, you'll learn:
+**[챕터 03: 개발 워크플로](../03-development-workflows/README.md)** 에서는 다음을 배웁니다:
-- Code review workflows
-- Refactoring patterns
-- Debugging assistance
-- Test generation
-- Git integration
+- 코드 리뷰 워크플로
+- 리팩터링 패턴
+- 디버깅 지원
+- 테스트 생성
+- Git 통합
---
-**[← Back to Chapter 01](../01-setup-and-first-steps/README.md)** | **[Continue to Chapter 03 →](../03-development-workflows/README.md)**
+**[← 챕터 01로 돌아가기](../01-setup-and-first-steps/README.md)** | **[챕터 03으로 계속 →](../03-development-workflows/README.md)**
\ No newline at end of file
diff --git a/03-development-workflows/README.md b/03-development-workflows/README.md
index 1fadca54..8f14e18d 100644
--- a/03-development-workflows/README.md
+++ b/03-development-workflows/README.md
@@ -1,181 +1,180 @@
-
+
-> **What if the AI could find bugs you didn't even know to ask about?**
+> **AI가 당신이 질문조차 하지 못했던 버그까지 찾아줄 수 있다면 어떨까요?**
-In this chapter, GitHub Copilot CLI becomes your daily driver. You'll use it inside the workflows you already rely on every day: testing, refactoring, debugging, and Git.
+이 챕터에서는 GitHub Copilot CLI가 여러분의 ‘일상 주력 도구(daily driver)’가 됩니다. 여러분이 매일 의존하는 워크플로—테스트, 리팩터링, 디버깅, 그리고 Git—안에서 Copilot CLI를 활용하게 됩니다.
-## 🎯 Learning Objectives
+## 🎯 학습 목표
-By the end of this chapter, you'll be able to:
+이 챕터를 마치면 다음을 할 수 있습니다:
-- Run comprehensive code reviews with Copilot CLI
-- Refactor legacy code safely
-- Debug issues with AI assistance
-- Generate tests automatically
-- Integrate Copilot CLI with your git workflow
+- Copilot CLI로 포괄적인 코드 리뷰 수행하기
+- 레거시 코드를 안전하게 리팩터링하기
+- AI의 도움으로 이슈를 디버깅하기
+- 테스트를 자동으로 생성하기
+- Copilot CLI를 git 워크플로에 통합하기
-> ⏱️ **Estimated Time**: ~60 minutes (15 min reading + 45 min hands-on)
+> ⏱️ **예상 소요 시간**: 약 60분 (읽기 15분 + 실습 45분)
---
-## 🧩 Real-World Analogy: A Carpenter's Workflow
+## 🧩 현실 비유: 목수의 워크플로
-A carpenter doesn't just know how to use tools, they have *workflows* for different jobs:
+목수는 단지 도구를 다루는 법만 아는 것이 아니라, 작업 종류에 따라 서로 다른 *워크플로*를 가지고 있습니다.
-🔧 Common Mistakes & Troubleshooting (click to expand)
+🔧 자주 하는 실수 & 트러블슈팅 (클릭해서 펼치기)
-### Common Mistakes +### 자주 하는 실수 -| Mistake | What Happens | Fix | +| 실수 | 결과 | 해결 | |---------|--------------|-----| -| Forgetting `@` before filenames | Copilot CLI treats "books.py" as plain text | Use `@samples/book-app-project/books.py` to reference files | -| Expecting sessions to persist automatically | Starting `copilot` fresh loses all previous context | Use `--continue` (last session) or `--resume` (pick a session) | -| Referencing files outside current directory | "Permission denied" or "File not found" errors | Use `/add-dir /path/to/directory` to grant access | -| Not using `/clear` when switching topics | Old context confuses responses about the new topic | Run `/clear` before starting a different task | +| 파일명 앞에 `@`를 뺴먹음 | Copilot CLI가 "books.py"를 일반 텍스트로 취급 | `@samples/book-app-project/books.py`처럼 `@`를 붙이기 | +| 세션이 자동으로 이어질 거라 기대함 | 새로 `copilot`을 시작하면 이전 컨텍스트가 사라짐 | `--continue`(최근) 또는 `--resume`(선택) 사용 | +| 현재 디렉터리 밖의 파일 참조 | "Permission denied" 또는 "File not found" | `/add-dir /path/to/directory`로 접근 허용 | +| 주제 전환 시 `/clear`를 안 씀 | 이전 컨텍스트가 새 주제의 답변을 혼란스럽게 함 | 다른 작업으로 넘어가기 전에 `/clear` 실행 | -### Troubleshooting +### 트러블슈팅 -**"File not found" errors** - Make sure you're in the correct directory: +**"File not found" 에러** - 올바른 디렉터리에 있는지 확인하세요: ```bash -pwd # Check current directory -ls # List files +pwd # 현재 디렉터리 확인 +ls # 파일 목록 확인 -# Then start copilot and use relative paths +# 그 다음 copilot을 시작하고 상대 경로 사용 copilot -> Review @samples/book-app-project/books.py +> @samples/book-app-project/books.py를 리뷰해줘 ``` -**"Permission denied"** - Add the directory to your allowed list: +**"Permission denied"** - 디렉터리를 허용 목록에 추가하세요: ```bash copilot --add-dir /path/to/directory -# Or in a session: +# 또는 세션 안에서: > /add-dir /path/to/directory ``` -**Context fills up too quickly**: -- Be more specific with file references -- Use `/clear` between different topics -- Split work across multiple sessions +**컨텍스트가 너무 빨리 차요**: +- 파일 참조를 더 구체적으로 하기 +- 주제 전환 시 `/clear` 사용 +- 작업을 여러 세션으로 분리
+
-Similarly, developers have workflows for different tasks. GitHub Copilot CLI enhances each of these workflows, making you more efficient and effective in your daily coding tasks.
+마찬가지로 개발자도 작업마다 다른 워크플로를 가지고 있습니다. GitHub Copilot CLI는 이러한 각 워크플로를 강화하여, 일상적인 코딩 작업에서 더 효율적이고 더 효과적으로 만들어 줍니다.
---
-# The Five Workflows
+# 다섯 가지 워크플로
-
+
-Each workflow below is self-contained. Pick the ones that match your current needs, or work through them all.
+아래의 각 워크플로는 독립적으로 구성되어 있습니다. 현재 필요에 맞는 것을 선택하거나, 모두 차례대로 진행해도 좋습니다.
---
-## Choose Your Own Adventure
+## 나만의 진행 방식(Choose Your Own Adventure)
-This chapter covers five workflows that developers typically use. **However, you don't need to read them all at once!** Each workflow is self-contained in a collapsible section below. Pick the ones that match what you need and that fits best with your current project. You can always come back and explore the others later.
+이 챕터는 개발자가 보통 사용하는 다섯 가지 워크플로를 다룹니다. **하지만 한 번에 전부 읽을 필요는 없습니다!** 각 워크플로는 아래에서 접었다 펼 수 있는 섹션으로 독립 구성되어 있습니다. 지금 하고 있는 프로젝트에 가장 잘 맞는 것을 골라 진행해 보세요. 나머지는 언제든 다시 돌아와 살펴볼 수 있습니다.
-
+
-| I want to... | Jump to |
+| 나는 …하고 싶다 | 바로가기 |
|---|---|
-| Review code before merging | [Workflow 1: Code Review](#workflow-1-code-review) |
-| Clean up messy or legacy code | [Workflow 2: Refactoring](#workflow-2-refactoring) |
-| Track down and fix a bug | [Workflow 3: Debugging](#workflow-3-debugging) |
-| Generate tests for my code | [Workflow 4: Test Generation](#workflow-4-test-generation) |
-| Write better commits and PRs | [Workflow 5: Git Integration](#workflow-5-git-integration) |
-| Research before coding | [Quick Tip: Research Before You Plan or Code](#quick-tip-research-before-you-plan-or-code) |
-| See a full bug-fix workflow end to end | [Putting It All Together](#putting-it-all-together-bug-fix-workflow) |
+| 머지 전에 코드를 리뷰하고 싶다 | [워크플로 1: 코드 리뷰](#workflow-1-code-review) |
+| 지저분하거나 레거시 코드를 정리하고 싶다 | [워크플로 2: 리팩터링](#workflow-2-refactoring) |
+| 버그를 추적해서 고치고 싶다 | [워크플로 3: 디버깅](#workflow-3-debugging) |
+| 내 코드의 테스트를 생성하고 싶다 | [워크플로 4: 테스트 생성](#workflow-4-test-generation) |
+| 더 나은 커밋/PR을 작성하고 싶다 | [워크플로 5: Git 통합](#workflow-5-git-integration) |
+| 코딩 전에 조사(리서치)를 하고 싶다 | [빠른 팁: 계획/코딩 전에 리서치하기](#quick-tip-research-before-you-plan-or-code) |
+| 버그 수정 워크플로를 처음부터 끝까지 보고 싶다 | [한 번에 엮어 보기](#putting-it-all-together-bug-fix-workflow) |
-**Select a workflow below to expand it** and see how GitHub Copilot CLI can enhance your development process in that area.
+아래에서 **원하는 워크플로를 선택해 펼친 뒤**, GitHub Copilot CLI가 해당 영역의 개발 프로세스를 어떻게 개선하는지 확인해 보세요.
---
-
+
-### Basic Review
+### 기본 리뷰
-This example uses the `@` symbol to reference a file, giving Copilot CLI direct access to its contents for review.
+이 예시는 `@` 기호로 파일을 참조하여, Copilot CLI가 리뷰를 위해 해당 파일의 내용을 직접 읽을 수 있게 합니다.
```bash
copilot
-> Review @samples/book-app-project/book_app.py for code quality
+> @samples/book-app-project/book_app.py 를 코드 품질 관점에서 리뷰해줘
```
---
@@ -183,91 +182,91 @@ copilot
Workflow 1: Code Review - Review files, use the /review agent, create severity checklists
+워크플로 1: 코드 리뷰 - 파일 리뷰, /review 에이전트 사용, 심각도 체크리스트 만들기
-
+
-### Basic Review
+### 기본 리뷰
-This example uses the `@` symbol to reference a file, giving Copilot CLI direct access to its contents for review.
+이 예시는 `@` 기호로 파일을 참조하여, Copilot CLI가 리뷰를 위해 해당 파일의 내용을 직접 읽을 수 있게 합니다.
```bash
copilot
-> Review @samples/book-app-project/book_app.py for code quality
+> @samples/book-app-project/book_app.py 를 코드 품질 관점에서 리뷰해줘
```
---
-
---
-### Input Validation Review
+### 입력값 검증(Input Validation) 리뷰
-Ask Copilot CLI to focus its review on a specific concern (here, input validation) by listing the categories you care about in the prompt.
+프롬프트에 관심 있는 카테고리를 나열하면, Copilot CLI가 특정 우려사항(여기서는 입력값 검증)에 집중해서 리뷰하도록 유도할 수 있습니다.
```text
copilot
-> Review @samples/book-app-project/utils.py for input validation issues. Check for: missing validation, error handling gaps, and edge cases
+> @samples/book-app-project/utils.py 를 입력값 검증 관점에서 리뷰해줘. 다음을 확인해줘: 누락된 검증, 에러 처리 공백, 엣지 케이스
```
+### 여러 파일을 아우르는 프로젝트 리뷰
-### Cross-File Project Review
-
-Reference an entire directory with `@` to let Copilot CLI scan every file in the project at once.
+디렉터리 전체를 `@`로 참조하면 Copilot CLI가 프로젝트 내 모든 파일을 한 번에 스캔할 수 있습니다.
```bash
copilot
-> @samples/book-app-project/ Review this entire project. Create a markdown checklist of issues found, categorized by severity
+> @samples/book-app-project/ 이 프로젝트 전체를 리뷰해줘. 발견한 이슈를 심각도별로 분류해서 마크다운 체크리스트로 만들어줘
```
-### Interactive Code Review
+### 대화형(Interactive) 코드 리뷰
-Use a multi-turn conversation to drill deeper. Start with a broad review, then ask follow-up questions without restarting.
+멀티턴 대화를 통해 더 깊게 파고들 수 있습니다. 넓게 리뷰한 뒤, 세션을 다시 시작하지 않고 후속 질문을 이어가세요.
```bash
copilot
-> @samples/book-app-project/book_app.py Review this file for:
-> - Input validation
-> - Error handling
-> - Code style and best practices
+> @samples/book-app-project/book_app.py 이 파일을 다음 관점에서 리뷰해줘:
+> - 입력값 검증
+> - 에러 처리
+> - 코드 스타일 및 베스트 프랙티스
-# Copilot CLI provides detailed review
+# Copilot CLI가 상세 리뷰를 제공
-> The user input handling - are there any edge cases I'm missing?
+> 사용자 입력 처리에서 놓치고 있는 엣지 케이스가 있을까?
-# Copilot CLI shows potential issues with empty strings, special characters
+# Copilot CLI가 빈 문자열, 특수문자 등의 잠재 이슈를 보여줌
-> Create a checklist of all issues found, prioritized by severity
+> 발견한 모든 이슈를 심각도 우선순위로 정리한 체크리스트로 만들어줘
-# Copilot CLI generates prioritized action items
+# Copilot CLI가 우선순위 기반 액션 아이템을 생성
```
-### Review Checklist Template
+### 리뷰 체크리스트 템플릿
-Ask Copilot CLI to structure its output in a specific format (here, a severity-categorized markdown checklist you can paste into an issue).
+출력을 특정 형식으로 구조화해 달라고 요청하면(여기서는 이슈에 붙여 넣기 좋은 ‘심각도별 마크다운 체크리스트’), Copilot CLI가 그에 맞춰 정리해 줍니다.
```bash
copilot
-> Review @samples/book-app-project/ and create a markdown checklist of issues found, categorized by:
-> - Critical (data loss risks, crashes)
-> - High (bugs, incorrect behavior)
-> - Medium (performance, maintainability)
-> - Low (style, minor improvements)
+> @samples/book-app-project/ 를 리뷰하고, 발견한 이슈를 아래 기준으로 분류한 마크다운 체크리스트를 만들어줘:
+> - Critical (데이터 손실 위험, 크래시)
+> - High (버그, 잘못된 동작)
+> - Medium (성능, 유지보수성)
+> - Low (스타일, 소소한 개선)
```
-### Understanding Git Changes (Important for /review)
+### Git 변경 사항 이해하기 (/review 사용 시 중요)
-Before using the `/review` command, you need to understand two types of changes in git:
+`/review` 명령을 사용하기 전에, git에서 두 가지 변경 상태를 이해해야 합니다.
-| Change Type | What It Means | How to See |
+| 변경 유형 | 의미 | 확인 방법 |
|-------------|---------------|------------|
-| **Staged changes** | Files you've marked for the next commit with `git add` | `git diff --staged` |
-| **Unstaged changes** | Files you've modified but haven't added yet | `git diff` |
+| **스테이징된 변경 사항(Staged changes)** | `git add`로 다음 커밋에 포함시키기로 표시한 파일 | `git diff --staged` |
+| **스테이징되지 않은 변경 사항(Unstaged changes)** | 수정했지만 아직 add하지 않은 파일 | `git diff` |
```bash
-# Quick reference
-git status # Shows both staged and unstaged
-git add file.py # Stage a file for commit
-git diff # Shows unstaged changes
-git diff --staged # Shows staged changes
+# 빠른 참고
+git status # 스테이징/미스테이징 모두 표시
+git add file.py # 파일을 스테이징
+git diff # 스테이징되지 않은 변경 사항
+git diff --staged # 스테이징된 변경 사항
```
-### Using the /review Command
+### /review 명령 사용하기
-The `/review` command invokes the built-in **code-review agent**, which is optimized for analyzing staged and unstaged changes with high signal-to-noise output. Use a slash command to trigger a specialized built-in agent instead of writing a free-form prompt.
+`/review` 명령은 내장된 **코드 리뷰 에이전트**를 호출합니다. 이 에이전트는 스테이징/미스테이징 변경 사항을 높은 신호 대비 낮은 잡음(signal-to-noise)으로 분석하도록 최적화되어 있습니다. 자유 형식 프롬프트를 길게 쓰는 대신, 슬래시 명령으로 특화된 내장 에이전트를 트리거해 보세요.
```bash
copilot
> /review
-# Invokes the code-review agent on staged/unstaged changes
-# Provides focused, actionable feedback
+# 스테이징/미스테이징 변경 사항에 대해 코드 리뷰 에이전트를 실행
+# 집중적이고 실행 가능한 피드백 제공
-> /review Check for security issues in authentication
-# Run review with specific focus area
+> /review 인증(authentication)에서 보안 이슈가 있는지 확인해줘
+# 특정 초점 영역을 지정해 리뷰 실행
```
-> 💡 **Tip**: The code-review agent works best when you have pending changes. Stage your files with `git add` for more focused reviews.
+> 💡 **팁**: 코드 리뷰 에이전트는 ‘대기 중인 변경 사항’이 있을 때 가장 잘 동작합니다. `git add`로 파일을 스테이징하면 더 집중된 리뷰를 받을 수 있습니다.
🎬 See it in action!
+🎬 실제 동작 보기
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 달라질 수 있습니다. 사용 중인 모델, 도구, 응답은 여기 표시된 것과 다를 수 있습니다.*
-
+
-### Simple Refactoring
+### 간단한 리팩터링
-> **Try this first:** `@samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.`
+> **먼저 이렇게 해보세요:** `@samples/book-app-project/book_app.py 명령 처리 로직이 if/elif 체인으로 되어 있어. 딕셔너리 디스패치 패턴을 사용하도록 리팩터링해줘.`
-Start with straightforward improvements. Try these on the book app. Each prompt uses an `@` file reference paired with a specific refactoring instruction so Copilot CLI knows exactly what to change.
+가볍고 직관적인 개선부터 시작하세요. 다음 프롬프트들은 book app에 적용해 볼 수 있습니다. 각 프롬프트는 `@` 파일 참조와 구체적인 리팩터링 지시를 함께 제공해, Copilot CLI가 무엇을 바꿔야 하는지 정확히 이해하게 합니다.
```bash
copilot
-> @samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.
+> @samples/book-app-project/book_app.py 명령 처리 로직이 if/elif 체인으로 되어 있어. 딕셔너리 디스패치 패턴을 사용하도록 리팩터링해줘.
-> @samples/book-app-project/utils.py Add type hints to all functions
+> @samples/book-app-project/utils.py 모든 함수에 타입 힌트를 추가해줘
-> @samples/book-app-project/book_app.py Extract the book display logic into utils.py for better separation of concerns
+> @samples/book-app-project/book_app.py 책 표시(display) 로직을 utils.py로 추출해서 관심사를 더 잘 분리해줘
```
-> 💡 **New to refactoring?** Start with simple requests like adding type hints or improving variable names before tackling complex transformations.
+> 💡 **리팩터링이 처음이라면?** 타입 힌트 추가나 변수명 개선처럼 단순한 요청부터 시작한 뒤, 더 복잡한 변환으로 확장해 보세요.
---
@@ -276,140 +275,140 @@ copilot
Workflow 2: Refactoring - Restructure code, separate concerns, improve error handling
+워크플로 2: 리팩터링 - 코드 재구성, 관심사 분리, 에러 처리 개선
-
+
-### Simple Refactoring
+### 간단한 리팩터링
-> **Try this first:** `@samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.`
+> **먼저 이렇게 해보세요:** `@samples/book-app-project/book_app.py 명령 처리 로직이 if/elif 체인으로 되어 있어. 딕셔너리 디스패치 패턴을 사용하도록 리팩터링해줘.`
-Start with straightforward improvements. Try these on the book app. Each prompt uses an `@` file reference paired with a specific refactoring instruction so Copilot CLI knows exactly what to change.
+가볍고 직관적인 개선부터 시작하세요. 다음 프롬프트들은 book app에 적용해 볼 수 있습니다. 각 프롬프트는 `@` 파일 참조와 구체적인 리팩터링 지시를 함께 제공해, Copilot CLI가 무엇을 바꿔야 하는지 정확히 이해하게 합니다.
```bash
copilot
-> @samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.
+> @samples/book-app-project/book_app.py 명령 처리 로직이 if/elif 체인으로 되어 있어. 딕셔너리 디스패치 패턴을 사용하도록 리팩터링해줘.
-> @samples/book-app-project/utils.py Add type hints to all functions
+> @samples/book-app-project/utils.py 모든 함수에 타입 힌트를 추가해줘
-> @samples/book-app-project/book_app.py Extract the book display logic into utils.py for better separation of concerns
+> @samples/book-app-project/book_app.py 책 표시(display) 로직을 utils.py로 추출해서 관심사를 더 잘 분리해줘
```
-> 💡 **New to refactoring?** Start with simple requests like adding type hints or improving variable names before tackling complex transformations.
+> 💡 **리팩터링이 처음이라면?** 타입 힌트 추가나 변수명 개선처럼 단순한 요청부터 시작한 뒤, 더 복잡한 변환으로 확장해 보세요.
---
-
---
-### Separate Concerns
+### 관심사 분리(Separate Concerns)
-Reference multiple files with `@` in a single prompt so Copilot CLI can move code between them as part of the refactor.
+한 프롬프트에서 `@`로 여러 파일을 함께 참조하면, Copilot CLI가 리팩터 과정에서 파일 간 코드 이동까지 제안/수행할 수 있습니다.
```bash
copilot
> @samples/book-app-project/utils.py @samples/book-app-project/book_app.py
-> The utils.py file has print statements mixed with logic. Refactor to separate display functions from data processing.
+> utils.py 파일에 print문과 로직이 섞여 있어. 출력(display) 함수와 데이터 처리 로직을 분리하도록 리팩터링해줘.
```
-### Improve Error Handling
+### 에러 처리 개선
-Provide two related files and describe the cross-cutting concern so Copilot CLI can suggest a consistent fix across both.
+서로 관련된 파일 2개를 제공하고, 가로지르는 관심사(여기서는 에러 처리)를 설명하면 Copilot CLI가 두 파일에 걸쳐 일관된 수정 방향을 제안할 수 있습니다.
```bash
copilot
> @samples/book-app-project/utils.py @samples/book-app-project/books.py
-> These files have inconsistent error handling. Suggest a unified approach using custom exceptions.
+> 이 파일들의 에러 처리가 일관되지 않아. 커스텀 예외(custom exceptions)를 사용해서 통일된 접근을 제안해줘.
```
-### Add Documentation
+### 문서(Documentation) 추가
-Use a detailed bullet list to specify exactly what each docstring should contain.
+각 docstring에 무엇을 포함해야 하는지 구체적인 불릿 리스트로 지정하면 Copilot CLI가 그에 맞춰 문서를 작성해 줍니다.
```bash
copilot
-> @samples/book-app-project/books.py Add comprehensive docstrings to all methods:
-> - Include parameter types and descriptions
-> - Document return values
-> - Note any exceptions raised
-> - Add usage examples
+> @samples/book-app-project/books.py 모든 메서드에 대해 포괄적인 docstring을 추가해줘:
+> - 파라미터 타입과 설명 포함
+> - 반환값 문서화
+> - 발생 가능한 예외 명시
+> - 사용 예시 추가
```
-### Safe Refactoring with Tests
+### 테스트와 함께 안전하게 리팩터링하기
-Chain two related requests in a multi-turn conversation. First generate tests, then refactor with those tests as a safety net.
+멀티턴 대화에서 두 요청을 연결해 보세요. 먼저 현재 동작을 테스트로 고정한 뒤, 그 테스트를 안전망으로 삼아 리팩터링하면 됩니다.
```bash
copilot
-> @samples/book-app-project/books.py Before refactoring, generate tests for current behavior
+> @samples/book-app-project/books.py 리팩터링 전에, 현재 동작을 기준으로 테스트를 먼저 생성해줘
-# Get tests first
+# 먼저 테스트를 확보
-> Now refactor the BookCollection class to use a context manager for file operations
+> 이제 BookCollection 클래스를 리팩터링해서 파일 작업(file operations)에 컨텍스트 매니저(context manager)를 사용하도록 바꿔줘
-# Refactor with confidence - tests verify behavior is preserved
+# 테스트가 동작 보존을 검증하므로 더 안심하고 리팩터링 가능
```
🎬 See it in action!
+🎬 실제 동작 보기
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 달라질 수 있습니다. 사용 중인 모델, 도구, 응답은 여기 표시된 것과 다를 수 있습니다.*
-
+
-### Simple Debugging
+### 간단한 디버깅
-> **Try this first:** `@samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.`
+> **먼저 이렇게 해보세요:** `@samples/book-app-buggy/books_buggy.py 사용자들이 \"The Hobbit\"을 검색하면 데이터에 있는데도 결과가 없다고 해. 왜 그런지 디버깅해줘.`
-Start by describing what's wrong. Here are common debugging patterns you can try with the buggy book app. Each prompt pairs an `@` file reference with a clear symptom description so Copilot CLI can locate and diagnose the bug.
+무엇이 잘못되었는지 증상을 설명하는 것부터 시작하세요. 아래는 buggy book app에서 시도해 볼 수 있는 대표적인 디버깅 패턴들입니다. 각 프롬프트는 `@` 파일 참조와 명확한 증상을 함께 제공해, Copilot CLI가 버그의 위치를 찾고 진단할 수 있게 합니다.
```bash
copilot
-# Pattern: "Expected X but got Y"
-> @samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.
+# 패턴: "X가 나와야 하는데 Y가 나와요"
+> @samples/book-app-buggy/books_buggy.py 사용자들이 "The Hobbit"을 검색하면 데이터에 있는데도 결과가 없다고 해. 왜 그런지 디버깅해줘.
-# Pattern: "Unexpected behavior"
-> @samples/book-app-buggy/book_app_buggy.py When I remove a book that doesn't exist, the app says it was removed. Help me find why.
+# 패턴: "예상치 못한 동작"
+> @samples/book-app-buggy/book_app_buggy.py 존재하지 않는 책을 삭제하려고 하면, 앱이 삭제됐다고 말해. 왜 그런지 찾아줘.
-# Pattern: "Wrong results"
-> @samples/book-app-buggy/books_buggy.py When I mark one book as read, ALL books get marked. What's the bug?
+# 패턴: "결과가 틀려요"
+> @samples/book-app-buggy/books_buggy.py 책 한 권만 읽음 처리했는데, 모든 책이 읽음 처리돼. 버그가 뭐야?
```
-> 💡 **Debugging tip**: Describe the *symptom* (what you see) and the *expectation* (what should happen). Copilot CLI figures out the rest.
+> 💡 **디버깅 팁**: *증상*(무엇이 보이는지)과 *기대*(원래 어떻게 되어야 하는지)를 함께 설명하세요. Copilot CLI가 나머지를 파악합니다.
---
@@ -418,57 +417,57 @@ copilot
Workflow 3: Debugging - Track down bugs, security audits, trace issues across files
+워크플로 3: 디버깅 - 버그 추적, 보안 점검, 여러 파일에 걸친 이슈 추적
-
+
-### Simple Debugging
+### 간단한 디버깅
-> **Try this first:** `@samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.`
+> **먼저 이렇게 해보세요:** `@samples/book-app-buggy/books_buggy.py 사용자들이 \"The Hobbit\"을 검색하면 데이터에 있는데도 결과가 없다고 해. 왜 그런지 디버깅해줘.`
-Start by describing what's wrong. Here are common debugging patterns you can try with the buggy book app. Each prompt pairs an `@` file reference with a clear symptom description so Copilot CLI can locate and diagnose the bug.
+무엇이 잘못되었는지 증상을 설명하는 것부터 시작하세요. 아래는 buggy book app에서 시도해 볼 수 있는 대표적인 디버깅 패턴들입니다. 각 프롬프트는 `@` 파일 참조와 명확한 증상을 함께 제공해, Copilot CLI가 버그의 위치를 찾고 진단할 수 있게 합니다.
```bash
copilot
-# Pattern: "Expected X but got Y"
-> @samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.
+# 패턴: "X가 나와야 하는데 Y가 나와요"
+> @samples/book-app-buggy/books_buggy.py 사용자들이 "The Hobbit"을 검색하면 데이터에 있는데도 결과가 없다고 해. 왜 그런지 디버깅해줘.
-# Pattern: "Unexpected behavior"
-> @samples/book-app-buggy/book_app_buggy.py When I remove a book that doesn't exist, the app says it was removed. Help me find why.
+# 패턴: "예상치 못한 동작"
+> @samples/book-app-buggy/book_app_buggy.py 존재하지 않는 책을 삭제하려고 하면, 앱이 삭제됐다고 말해. 왜 그런지 찾아줘.
-# Pattern: "Wrong results"
-> @samples/book-app-buggy/books_buggy.py When I mark one book as read, ALL books get marked. What's the bug?
+# 패턴: "결과가 틀려요"
+> @samples/book-app-buggy/books_buggy.py 책 한 권만 읽음 처리했는데, 모든 책이 읽음 처리돼. 버그가 뭐야?
```
-> 💡 **Debugging tip**: Describe the *symptom* (what you see) and the *expectation* (what should happen). Copilot CLI figures out the rest.
+> 💡 **디버깅 팁**: *증상*(무엇이 보이는지)과 *기대*(원래 어떻게 되어야 하는지)를 함께 설명하세요. Copilot CLI가 나머지를 파악합니다.
---
-
---
-### The "Bug Detective" - AI Finds RELATED Bugs
+### "버그 탐정" - AI가 ‘관련된’ 버그까지 찾는다
-This is where context-aware debugging shines. Try this scenario with the buggy book app. Provide the whole file via `@` and describe only the user-reported symptom. Copilot CLI will trace the root cause and may spot additional bugs nearby.
+여기서 맥락 기반 디버깅의 강점이 드러납니다. buggy book app에서 이 시나리오를 시도해 보세요. `@`로 파일 전체를 제공하고, 사용자 제보 증상만 설명하면 Copilot CLI가 근본 원인을 추적하며 주변의 다른 버그까지 발견할 수 있습니다.
```bash
copilot
> @samples/book-app-buggy/books_buggy.py
>
-> Users report: "Finding books by author name doesn't work for partial names"
-> Debug why this happens
+> 사용자 제보: "저자 이름으로 책을 찾을 때, 부분 문자열로는 동작하지 않는다"
+> 왜 이런지 디버깅해줘
```
-**What Copilot CLI does**:
+**Copilot CLI가 하는 일**:
```
-Root Cause: Line 80 uses exact match (==) instead of partial match (in).
+근본 원인: 80번째 줄에서 부분 매칭(in) 대신 정확한 일치(==)를 사용하고 있습니다.
-Line 80: return [b for b in self.books if b.author == author]
+80번째 줄: return [b for b in self.books if b.author == author]
-The find_by_author function requires an exact match. Searching for "Tolkien"
-won't find books by "J.R.R. Tolkien".
+find_by_author 함수는 정확히 일치해야만 검색됩니다. "Tolkien"으로 검색하면
+"J.R.R. Tolkien"의 책은 찾지 못합니다.
-Fix: Change to case-insensitive partial match:
+수정: 대소문자 무시 + 부분 매칭으로 변경:
return [b for b in self.books if author.lower() in b.author.lower()]
```
-**Why this matters**: Copilot CLI reads the whole file, understands the context of your bug report, and gives you a specific fix with a clear explanation.
+**이게 중요한 이유**: Copilot CLI는 파일 전체를 읽고, 버그 리포트의 맥락을 이해하여, 구체적인 수정안과 명확한 설명을 제공합니다.
-> 💡 **Bonus**: Because Copilot CLI analyzes the entire file, it often discovers *other* issues you didn't ask about. For example, while fixing the author search, Copilot CLI might also notice the case-sensitivity bug in `find_book_by_title`!
+> 💡 **보너스**: Copilot CLI가 파일 전체를 분석하기 때문에, 여러분이 묻지 않은 *다른* 문제도 종종 발견합니다. 예를 들어 저자 검색을 고치면서 `find_book_by_title`의 대소문자 민감도 버그를 같이 지적할 수도 있습니다!
-### Real-World Security Sidebar
+### 현실 세계 보안 사이드바
-While debugging your own code is important, understanding security vulnerabilities in production applications is critical. Try this example: Point Copilot CLI at an unfamiliar file and ask it to audit for security issues.
+내 코드를 디버깅하는 것도 중요하지만, 운영 환경의 애플리케이션에서 보안 취약점을 이해하는 일은 더 중요합니다. 다음 예시처럼, 익숙하지 않은 파일을 Copilot CLI에 주고 보안 이슈를 점검해 달라고 요청해 보세요.
```bash
copilot
-> @samples/buggy-code/python/user_service.py Find all security vulnerabilities in this Python user service
+> @samples/buggy-code/python/user_service.py 이 Python 사용자 서비스에서 모든 보안 취약점을 찾아줘
```
-This file demonstrates real-world security patterns you'll encounter in production apps.
+이 파일은 실제 프로덕션 앱에서 마주치게 될 현실적인 보안 패턴을 보여줍니다.
-> 💡 **Common security terms you'll encounter:**
-> - **SQL Injection**: When user input is put directly into a database query, allowing attackers to run malicious commands
-> - **Parameterized queries**: The safe alternative - placeholders (`?`) separate user data from SQL commands
-> - **Race condition**: When two operations happen at the same time and interfere with each other
-> - **XSS (Cross-Site Scripting)**: When attackers inject malicious scripts into web pages
+> 💡 **자주 접하게 될 보안 용어:**
+> - **SQL 인젝션(SQL Injection)**: 사용자 입력을 그대로 쿼리에 넣어 공격자가 악성 명령을 실행할 수 있게 되는 문제
+> - **파라미터화 쿼리(Parameterized queries)**: 안전한 대안. 플레이스홀더(`?`)로 데이터와 SQL 명령을 분리
+> - **레이스 컨디션(Race condition)**: 두 작업이 동시에 일어나 서로 간섭하는 문제
+> - **XSS(Cross-Site Scripting)**: 공격자가 웹 페이지에 악성 스크립트를 주입하는 문제
---
-### Understanding an Error
+### 에러 이해하기
-Paste a stack trace directly into your prompt along with an `@` file reference so Copilot CLI can map the error to the source code.
+스택 트레이스를 프롬프트에 그대로 붙여 넣고, `@` 파일 참조까지 함께 제공하면 Copilot CLI가 에러를 소스 코드에 매핑해 설명해 줍니다.
```bash
copilot
-> I'm getting this error:
+> 이런 에러가 나요:
> AttributeError: 'NoneType' object has no attribute 'title'
> at show_books (book_app.py:19)
>
-> @samples/book-app-project/book_app.py Explain why and how to fix it
+> @samples/book-app-project/book_app.py 왜 발생하는지와 어떻게 고칠지 설명해줘
```
-### Debugging with Test Case
+### 테스트 케이스와 함께 디버깅하기
-Describe the exact input and observed output to give Copilot CLI a concrete, reproducible test case to reason about.
+정확한 입력과 관찰된 출력을 설명하면, Copilot CLI가 재현 가능한 구체적 사례를 바탕으로 추론할 수 있습니다.
```bash
copilot
-> @samples/book-app-buggy/books_buggy.py The remove_book function has a bug. When I try to remove "Dune",
-> it also removes "Dune Messiah". Debug this: explain the root cause and provide a fix.
+> @samples/book-app-buggy/books_buggy.py remove_book 함수에 버그가 있어. "Dune"을 삭제하려고 하면,
+> "Dune Messiah"까지 같이 삭제돼. 원인을 설명하고 수정안을 제시해줘.
```
-### Trace an Issue Through Code
+### 코드 전체에서 이슈 추적하기
-Reference multiple files and ask Copilot CLI to follow the data flow across them to locate where the issue originates.
+여러 파일을 함께 참조하고, Copilot CLI에게 데이터 흐름을 따라가며 어디서 문제가 시작되는지 추적하도록 요청할 수 있습니다.
```bash
copilot
-> Users report that the book list numbering starts at 0 instead of 1.
+> 사용자들이 책 목록 번호가 1부터가 아니라 0부터 시작한다고 해.
> @samples/book-app-buggy/book_app_buggy.py @samples/book-app-buggy/books_buggy.py
-> Trace through the list display flow and identify where the issue occurs
+> 목록 표시 흐름을 따라가며 어디서 문제가 생기는지 찾아줘
```
-### Understanding Data Issues
+### 데이터 이슈 이해하기
-Include a data file alongside the code that reads it so Copilot CLI understands the full picture when suggesting error-handling improvements.
+코드와 함께 데이터를 제공하면, Copilot CLI가 전체 맥락을 이해한 상태에서 에러 처리 개선을 제안할 수 있습니다.
```bash
copilot
> @samples/book-app-project/data.json @samples/book-app-project/books.py
-> Sometimes the JSON file gets corrupted and the app crashes. How should we handle this gracefully?
+> 가끔 JSON 파일이 깨져서 앱이 크래시가 나. 이런 경우 우아하게 처리하려면 어떻게 해야 해?
```
🎬 See it in action!
+🎬 실제 동작 보기
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 달라질 수 있습니다. 사용 중인 모델, 도구, 응답은 여기 표시된 것과 다를 수 있습니다.*
-
+
-> **Try this first:** `@samples/book-app-project/books.py Generate pytest tests for all functions including edge cases`
+> **먼저 이렇게 해보세요:** `@samples/book-app-project/books.py 모든 함수를 대상으로 엣지 케이스를 포함한 pytest 테스트를 생성해줘`
-### The "Test Explosion" - 2 Tests vs 15+ Tests
+### "테스트 폭발" - 2개 테스트 vs 15개+ 테스트
-Manually writing tests, developers typically create 2-3 basic tests:
-- Test valid input
-- Test invalid input
-- Test an edge case
+수동으로 테스트를 작성할 때, 개발자는 보통 2~3개의 기본 테스트를 만듭니다:
+- 유효한 입력 테스트
+- 유효하지 않은 입력 테스트
+- 엣지 케이스 테스트
-Watch what happens when you ask Copilot CLI to generate comprehensive tests! This prompt uses a structured bullet list with an `@` file reference to guide Copilot CLI toward thorough test coverage:
+Copilot CLI에 포괄적인 테스트 생성을 요청하면 어떤 일이 벌어지는지 확인해 보세요! 아래 프롬프트는 `@` 파일 참조와 구조화된 불릿 리스트를 함께 사용하여, Copilot CLI가 더 철저한 테스트 커버리지로 안내되도록 합니다.
```bash
copilot
-> @samples/book-app-project/books.py Generate comprehensive pytest tests. Include tests for:
-> - Adding books
-> - Removing books
-> - Finding by title
-> - Finding by author
-> - Marking as read
-> - Edge cases with empty data
+> @samples/book-app-project/books.py 포괄적인 pytest 테스트를 생성해줘. 다음을 포함해줘:
+> - 책 추가
+> - 책 삭제
+> - 제목으로 찾기
+> - 저자로 찾기
+> - 읽음 표시
+> - 데이터가 비어 있을 때의 엣지 케이스
```
---
@@ -571,29 +570,29 @@ copilot
Workflow 4: Test Generation - Generate comprehensive tests and edge cases automatically
+워크플로 4: 테스트 생성 - 엣지 케이스까지 포함한 포괄적인 테스트 자동 생성
-
+
-> **Try this first:** `@samples/book-app-project/books.py Generate pytest tests for all functions including edge cases`
+> **먼저 이렇게 해보세요:** `@samples/book-app-project/books.py 모든 함수를 대상으로 엣지 케이스를 포함한 pytest 테스트를 생성해줘`
-### The "Test Explosion" - 2 Tests vs 15+ Tests
+### "테스트 폭발" - 2개 테스트 vs 15개+ 테스트
-Manually writing tests, developers typically create 2-3 basic tests:
-- Test valid input
-- Test invalid input
-- Test an edge case
+수동으로 테스트를 작성할 때, 개발자는 보통 2~3개의 기본 테스트를 만듭니다:
+- 유효한 입력 테스트
+- 유효하지 않은 입력 테스트
+- 엣지 케이스 테스트
-Watch what happens when you ask Copilot CLI to generate comprehensive tests! This prompt uses a structured bullet list with an `@` file reference to guide Copilot CLI toward thorough test coverage:
+Copilot CLI에 포괄적인 테스트 생성을 요청하면 어떤 일이 벌어지는지 확인해 보세요! 아래 프롬프트는 `@` 파일 참조와 구조화된 불릿 리스트를 함께 사용하여, Copilot CLI가 더 철저한 테스트 커버리지로 안내되도록 합니다.
```bash
copilot
-> @samples/book-app-project/books.py Generate comprehensive pytest tests. Include tests for:
-> - Adding books
-> - Removing books
-> - Finding by title
-> - Finding by author
-> - Marking as read
-> - Edge cases with empty data
+> @samples/book-app-project/books.py 포괄적인 pytest 테스트를 생성해줘. 다음을 포함해줘:
+> - 책 추가
+> - 책 삭제
+> - 제목으로 찾기
+> - 저자로 찾기
+> - 읽음 표시
+> - 데이터가 비어 있을 때의 엣지 케이스
```
---
-
---
-**What you get**: 15+ comprehensive tests including:
+**얻게 되는 것**: 다음을 포함한 15개+ 포괄적 테스트
```python
class TestBookCollection:
- # Happy path
+ # 해피 패스
def test_add_book_creates_new_book(self):
...
def test_list_books_returns_all_books(self):
...
- # Find operations
+ # 찾기(Find) 관련
def test_find_book_by_title_case_insensitive(self):
...
def test_find_book_by_title_returns_none_when_not_found(self):
@@ -478,7 +477,7 @@ class TestBookCollection:
def test_find_by_author_case_insensitive(self):
...
- # Edge cases
+ # 엣지 케이스
def test_add_book_with_empty_title(self):
...
def test_remove_nonexistent_book(self):
@@ -486,7 +485,7 @@ class TestBookCollection:
def test_mark_as_read_nonexistent_book(self):
...
- # Data persistence
+ # 데이터 영속성
def test_save_books_persists_to_json(self):
...
def test_load_books_handles_missing_file(self):
@@ -494,75 +493,75 @@ class TestBookCollection:
def test_load_books_handles_corrupted_json(self):
...
- # Special characters
+ # 특수 문자
def test_add_book_with_unicode_characters(self):
...
def test_find_by_author_with_special_characters(self):
...
```
-**Result**: In 30 seconds, you get edge case tests that would take an hour to think through and write.
+**결과**: 30초 만에, 떠올리기만 해도 1시간은 걸릴 엣지 케이스 테스트를 얻을 수 있습니다.
---
-### Unit Tests
+### 유닛 테스트(Unit Tests)
-Target a single function and enumerate the input categories you want tested so Copilot CLI generates focused, thorough unit tests.
+단일 함수를 대상으로, 어떤 입력 카테고리를 테스트하고 싶은지 나열하면 Copilot CLI가 더 집중적이고 철저한 유닛 테스트를 생성합니다.
```bash
copilot
-> @samples/book-app-project/utils.py Generate comprehensive pytest tests for get_book_details covering:
-> - Valid input
-> - Empty strings
-> - Invalid year formats
-> - Very long titles
-> - Special characters in author names
+> @samples/book-app-project/utils.py get_book_details에 대한 포괄적인 pytest 테스트를 생성해줘. 다음을 커버해줘:
+> - 유효한 입력
+> - 빈 문자열
+> - 잘못된 연도 형식
+> - 매우 긴 제목
+> - 저자 이름에 포함된 특수 문자
```
-### Running Tests
+### 테스트 실행하기
-Ask Copilot CLI a plain-English question about your toolchain. It can generate the right shell command for you.
+툴체인에 대한 자연어 질문을 던지면, Copilot CLI가 적절한 셸 명령을 생성해 줍니다.
```bash
copilot
-> How do I run the tests? Show me the pytest command.
+> 테스트를 어떻게 실행해? pytest 명령을 알려줘.
-# Copilot CLI responds:
+# Copilot CLI 응답 예시:
# cd samples/book-app-project && python -m pytest tests/
-# Or for verbose output: python -m pytest tests/ -v
-# To see print statements: python -m pytest tests/ -s
+# 또는 자세히 보기: python -m pytest tests/ -v
+# print 출력 보기: python -m pytest tests/ -s
```
-### Test for Specific Scenarios
+### 특정 시나리오용 테스트
-List advanced or tricky scenarios you want covered so Copilot CLI goes beyond the happy path.
+고급/까다로운 시나리오를 나열하면 Copilot CLI가 해피 패스를 넘어서는 테스트를 생성합니다.
```bash
copilot
-> @samples/book-app-project/books.py Generate tests for these scenarios:
-> - Adding duplicate books (same title and author)
-> - Removing a book by partial title match
-> - Finding books when collection is empty
-> - File permission errors during save
-> - Concurrent access to the book collection
+> @samples/book-app-project/books.py 다음 시나리오에 대한 테스트를 생성해줘:
+> - 중복 책 추가(같은 제목+같은 저자)
+> - 제목 부분 일치로 책 삭제
+> - 컬렉션이 비어 있을 때 책 찾기
+> - 저장 중 파일 권한 에러
+> - 책 컬렉션에 대한 동시 접근
```
-### Add Tests to Existing File
+### 기존 파일에 테스트 추가하기
-Ask for *additional* tests for a single function so Copilot CLI generates new cases that complement what you already have.
+하나의 함수에 대해 *추가* 테스트를 요청하면, Copilot CLI가 기존에 없던 케이스를 보완하는 테스트를 생성합니다.
```bash
copilot
> @samples/book-app-project/books.py
-> Generate additional tests for the find_by_author function with edge cases:
-> - Author name with hyphens (e.g., "Jean-Paul Sartre")
-> - Author with multiple first names
-> - Empty string as author
-> - Author name with accented characters
+> find_by_author 함수에 대해 다음 엣지 케이스를 포함한 추가 테스트를 만들어줘:
+> - 하이픈이 있는 저자명(예: "Jean-Paul Sartre")
+> - 이름이 여러 개인 저자
+> - 빈 문자열 저자
+> - 악센트가 있는 저자명
```
🎬 See it in action!
+🎬 실제 동작 보기
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 달라질 수 있습니다. 사용 중인 모델, 도구, 응답은 여기 표시된 것과 다를 수 있습니다.*
-
+
-> 💡 **This workflow assumes basic git familiarity** (staging, committing, branches). If git is new to you, try the other four workflows first.
+> 💡 **이 워크플로는 기본적인 git 이해를 전제로 합니다**(스테이징, 커밋, 브랜치). git이 낯설다면, 다른 네 가지 워크플로부터 먼저 시도해 보세요.
-### Generate Commit Messages
+### 커밋 메시지 생성
-> **Try this first:** `copilot -p "Generate a conventional commit message for: $(git diff --staged)"` — stage some changes, then run this to see Copilot CLI write your commit message.
+> **먼저 이렇게 해보세요:** `copilot -p "Generate a conventional commit message for: $(git diff --staged)"` — 변경 사항을 스테이징한 다음 실행하면 Copilot CLI가 커밋 메시지를 작성해 줍니다.
-This example uses the `-p` inline prompt flag with shell command substitution to pipe `git diff` output directly into Copilot CLI for a one-shot commit message. The `$(...)` syntax runs the command inside the parentheses and inserts its output into the outer command.
+이 예시는 `-p` 인라인 프롬프트 플래그와 셸 명령 치환을 이용해 `git diff` 출력을 Copilot CLI로 파이프하여, 한 번에 커밋 메시지를 생성하는 방법을 보여줍니다. `$(...)` 문법은 괄호 안의 명령을 실행하고 그 출력을 바깥 명령에 삽입합니다.
```bash
-# See what changed
+# 무엇이 바뀌었는지 확인
git diff --staged
-# Generate commit message using [Conventional Commit](../GLOSSARY.md#conventional-commit) format
-# (structured messages like "feat(books): add search" or "fix(data): handle empty input")
+# [Conventional Commit](../GLOSSARY.md#conventional-commit) 형식으로 커밋 메시지 생성
+# ("feat(books): add search" 또는 "fix(data): handle empty input" 같은 구조화된 메시지)
copilot -p "Generate a conventional commit message for: $(git diff --staged)"
-# Output: "feat(books): add partial author name search
-#
+# 출력 예시: "feat(books): add partial author name search
+#
# - Update find_by_author to support partial matches
# - Add case-insensitive comparison
# - Improve user experience when searching authors"
@@ -602,44 +601,44 @@ copilot -p "Generate a conventional commit message for: $(git diff --staged)"
---
---
-## Quick Tip: Research Before You Plan or Code
+## 빠른 팁: 계획하거나 코딩하기 전에 리서치하기
-When you need to investigate a library, understand best practices, or explore an unfamiliar topic, use `/research` to run a deep research investigation before writing any code:
+라이브러리를 조사하거나, 베스트 프랙티스를 이해하거나, 익숙하지 않은 주제를 탐색해야 할 때는 `/research`로 코드를 작성하기 전에 ‘딥 리서치’ 조사를 실행할 수 있습니다.
```bash
copilot
-> /research What are the best Python libraries for validating user input in CLI apps?
+> /research CLI 앱에서 사용자 입력 검증을 위한 최고의 Python 라이브러리는 뭐야?
```
-Copilot searches GitHub repositories and web sources, then returns a summary with references. This is useful when you're about to start a new feature and want to make informed decisions first. You can share the results using `/share`.
+Copilot은 GitHub 저장소와 웹 소스를 검색한 뒤, 참고 링크와 함께 요약을 제공합니다. 새로운 기능을 시작하기 전에 더 나은 결정을 내리기 위해 유용하며, `/share`로 결과를 공유할 수도 있습니다.
-> 💡 **Tip**: `/research` works well *before* `/plan`. Research the approach, then plan the implementation.
+> 💡 **팁**: `/research`는 `/plan` *이전*에 특히 잘 맞습니다. 먼저 접근 방식을 조사하고, 그 다음 구현 계획을 세우세요.
---
-## Putting It All Together: Bug Fix Workflow
+## 한 번에 엮어 보기: 버그 수정 워크플로
-Here's a complete workflow for fixing a reported bug:
+다음은 제보된 버그를 수정하는 전체 워크플로의 예시입니다:
```bash
-# 1. Understand the bug report
+# 1. 버그 리포트 이해
copilot
-> Users report: 'Finding books by author name doesn't work for partial names'
-> @samples/book-app-project/books.py Analyze and identify the likely cause
+> 사용자 제보: '저자 이름으로 책을 찾을 때, 부분 문자열로는 동작하지 않는다'
+> @samples/book-app-project/books.py 분석해서 유력한 원인을 찾아줘
-# 2. Debug the issue (continuing in same session)
-> Based on the analysis, show me the find_by_author function and explain the issue
+# 2. 이슈 디버깅(같은 세션에서 계속)
+> 분석을 바탕으로 find_by_author 함수를 보여주고, 무엇이 문제인지 설명해줘
-> Fix the find_by_author function to handle partial name matches
+> find_by_author 함수가 부분 이름 매칭을 처리하도록 수정해줘
-# 3. Generate tests for the fix
-> @samples/book-app-project/books.py Generate pytest tests specifically for:
-> - Full author name match
-> - Partial author name match
-> - Case-insensitive matching
-> - Author name not found
+# 3. 수정에 대한 테스트 생성
+> @samples/book-app-project/books.py 다음을 대상으로 pytest 테스트를 생성해줘:
+> - 저자 전체 이름 매칭
+> - 저자 부분 이름 매칭
+> - 대소문자 무시 매칭
+> - 저자 이름을 찾지 못했을 때
-# 4. Generate commit message
+# 4. 커밋 메시지 생성
copilot -p "Generate commit message for: $(git diff --staged)"
-# Output: "fix(books): support partial author name search"
+# 출력 예시: "fix(books): support partial author name search"
```
-### Bug Fix Workflow Summary
+### 버그 수정 워크플로 요약
-| Step | Action | Copilot Command |
+| 단계 | 작업 | Copilot 명령 |
|------|--------|-----------------|
-| 1 | Understand the bug | `> [describe bug] @relevant-file.py Analyze the likely cause` |
-| 2 | Get detailed analysis | `> Show me the function and explain the issue` |
-| 3 | Implement the fix | `> Fix the [specific issue]` |
-| 4 | Generate tests | `> Generate tests for [specific scenarios]` |
-| 5 | Commit | `copilot -p "Generate commit message for: $(git diff --staged)"` |
+| 1 | 버그 이해 | `> [버그 설명] @relevant-file.py 유력한 원인을 분석해줘` |
+| 2 | 상세 분석 | `> 함수를 보여주고 문제를 설명해줘` |
+| 3 | 수정 구현 | `> [구체적인 문제]를 수정해줘` |
+| 4 | 테스트 생성 | `> [특정 시나리오]에 대한 테스트를 생성해줘` |
+| 5 | 커밋 | `copilot -p "Generate commit message for: $(git diff --staged)"` |
---
-# Practice
+# 실습(Practice)
-Workflow 5: Git Integration - Commit messages, PR descriptions, /pr, /delegate, and /diff
+워크플로 5: Git 통합 - 커밋 메시지, PR 설명, /pr, /delegate, /diff
-
+
-> 💡 **This workflow assumes basic git familiarity** (staging, committing, branches). If git is new to you, try the other four workflows first.
+> 💡 **이 워크플로는 기본적인 git 이해를 전제로 합니다**(스테이징, 커밋, 브랜치). git이 낯설다면, 다른 네 가지 워크플로부터 먼저 시도해 보세요.
-### Generate Commit Messages
+### 커밋 메시지 생성
-> **Try this first:** `copilot -p "Generate a conventional commit message for: $(git diff --staged)"` — stage some changes, then run this to see Copilot CLI write your commit message.
+> **먼저 이렇게 해보세요:** `copilot -p "Generate a conventional commit message for: $(git diff --staged)"` — 변경 사항을 스테이징한 다음 실행하면 Copilot CLI가 커밋 메시지를 작성해 줍니다.
-This example uses the `-p` inline prompt flag with shell command substitution to pipe `git diff` output directly into Copilot CLI for a one-shot commit message. The `$(...)` syntax runs the command inside the parentheses and inserts its output into the outer command.
+이 예시는 `-p` 인라인 프롬프트 플래그와 셸 명령 치환을 이용해 `git diff` 출력을 Copilot CLI로 파이프하여, 한 번에 커밋 메시지를 생성하는 방법을 보여줍니다. `$(...)` 문법은 괄호 안의 명령을 실행하고 그 출력을 바깥 명령에 삽입합니다.
```bash
-# See what changed
+# 무엇이 바뀌었는지 확인
git diff --staged
-# Generate commit message using [Conventional Commit](../GLOSSARY.md#conventional-commit) format
-# (structured messages like "feat(books): add search" or "fix(data): handle empty input")
+# [Conventional Commit](../GLOSSARY.md#conventional-commit) 형식으로 커밋 메시지 생성
+# ("feat(books): add search" 또는 "fix(data): handle empty input" 같은 구조화된 메시지)
copilot -p "Generate a conventional commit message for: $(git diff --staged)"
-# Output: "feat(books): add partial author name search
-#
+# 출력 예시: "feat(books): add partial author name search
+#
# - Update find_by_author to support partial matches
# - Add case-insensitive comparison
# - Improve user experience when searching authors"
@@ -602,44 +601,44 @@ copilot -p "Generate a conventional commit message for: $(git diff --staged)"
---
-
---
-### Explain Changes
+### 변경 사항 설명하기
-Pipe the output of `git show` into a `-p` prompt to get a plain-English summary of the last commit.
+`git show` 출력을 `-p` 프롬프트로 전달하면, 마지막 커밋이 무엇을 바꿨는지 자연어로 요약할 수 있습니다.
```bash
-# What did this commit change?
+# 이 커밋이 무엇을 바꿨지?
copilot -p "Explain what this commit does: $(git show HEAD --stat)"
```
-### PR Description
+### PR 설명(PR Description)
-Combine `git log` output with a structured prompt template to auto-generate a complete pull request description.
+`git log` 출력과 구조화된 프롬프트 템플릿을 결합해, 완성도 높은 PR 설명을 자동 생성할 수 있습니다.
```bash
-# Generate PR description from branch changes
-copilot -p "Generate a pull request description for these changes:
+# 브랜치 변경 사항으로부터 PR 설명 생성
+copilot -p "이 변경 사항들에 대한 풀 리퀘스트 설명을 작성해줘:
$(git log main..HEAD --oneline)
-Include:
-- Summary of changes
-- Why these changes were made
-- Testing done
+포함할 내용:
+- 변경 요약
+- 왜 변경했는지
+- 수행한 테스트
- Breaking changes? (yes/no)"
```
-### Using /pr in Interactive Mode for the Current Branch
+### 인터랙티브 모드에서 현재 브랜치의 /pr 사용하기
-If you're working with a branch in Copilot CLI's interactive mode, you can use the `/pr` command to work with pull requests. Use `/pr` to view a PR, create a new PR, fix an existing PR, or let Copilot CLI auto-decide based on the branch state.
+Copilot CLI의 인터랙티브 모드에서 브랜치 작업 중이라면 `/pr` 명령으로 PR을 다룰 수 있습니다. `/pr`로 PR 보기, 새 PR 생성, 기존 PR 수정, 또는 브랜치 상태에 따라 자동 결정(auto)까지 사용할 수 있습니다.
```bash
copilot
@@ -647,312 +646,312 @@ copilot
> /pr [view|create|fix|auto]
```
-### Review Before Push
+### 푸시 전 리뷰
-Use `git diff main..HEAD` inside a `-p` prompt for a quick pre-push sanity check across all branch changes.
+`git diff main..HEAD`를 `-p` 프롬프트에 넣어, 푸시 전에 브랜치 전체 변경 사항을 빠르게 점검할 수 있습니다.
```bash
-# Last check before pushing
-copilot -p "Review these changes for issues before I push:
+# 푸시 전에 마지막 점검
+copilot -p "푸시하기 전에 이 변경 사항들을 리뷰해서 문제 없는지 확인해줘:
$(git diff main..HEAD)"
```
-### Using /delegate for Background Tasks
+### /delegate로 백그라운드 작업 맡기기
-The `/delegate` command hands off work to the Copilot coding agent on GitHub. Use the `/delegate` slash command (or the `&` shortcut) to offload a well-defined task to a background agent.
+`/delegate` 명령은 GitHub의 Copilot 코딩 에이전트에게 작업을 위임합니다. `/delegate` 슬래시 명령(또는 `&` 단축키)을 사용해, 명확히 정의된 작업을 백그라운드 에이전트에게 오프로딩할 수 있습니다.
```bash
copilot
-> /delegate Add input validation to the login form
+> /delegate 로그인 폼에 입력값 검증을 추가해줘
-# Or use the & prefix shortcut:
-> & Fix the typo in the README header
+# 또는 & 접두사 단축키 사용:
+> & README 헤더의 오타를 고쳐줘
# Copilot CLI:
-# 1. Commits your changes to a new branch
-# 2. Opens a draft pull request
-# 3. Works in the background on GitHub
-# 4. Requests your review when done
+# 1. 새 브랜치에 변경 사항을 커밋
+# 2. 드래프트 PR을 오픈
+# 3. GitHub에서 백그라운드로 작업
+# 4. 완료되면 리뷰 요청
```
-This is great for well-defined tasks you want completed while you focus on other work.
+이 방식은 여러분이 다른 일에 집중하는 동안, 잘 정의된 작업을 맡겨 두기에 좋습니다.
-### Using /diff to Review Session Changes
+### /diff로 세션 변경 사항 리뷰하기
-The `/diff` command shows all changes made during your current session. Use this slash command to see a visual diff of everything Copilot CLI has modified before you commit.
+`/diff` 명령은 현재 세션 동안 변경된 모든 내용을 보여줍니다. 커밋 전에 Copilot CLI가 수정한 모든 파일의 변경 사항을 시각적으로 확인할 때 유용합니다.
```bash
copilot
-# After making some changes...
+# 변경을 몇 가지 한 뒤...
> /diff
-# Shows a visual diff of all files modified in this session
-# Great for reviewing before committing
+# 이 세션에서 수정된 모든 파일의 변경 사항을 시각적으로 표시
+# 커밋 전에 리뷰하기 좋음
```
🎬 See it in action!
+🎬 실제 동작 보기
- + -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 달라질 수 있습니다. 사용 중인 모델, 도구, 응답은 여기 표시된 것과 다를 수 있습니다.*
+
-Now it's your turn to apply these workflows.
+이제 여러분 차례입니다. 이 워크플로를 직접 적용해 보세요.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 해보기
-After completing the demos, try these variations:
+데모를 끝낸 뒤, 아래 변형을 시도해 보세요:
-1. **Bug Detective Challenge**: Ask Copilot CLI to debug the `mark_as_read` function in `samples/book-app-buggy/books_buggy.py`. Did it explain why the function marks ALL books as read instead of just one?
+1. **버그 탐정 챌린지**: `samples/book-app-buggy/books_buggy.py`의 `mark_as_read` 함수를 Copilot CLI에게 디버깅하게 해보세요. 왜 한 권만이 아니라 모든 책이 읽음 처리되는지 설명했나요?
-2. **Test Challenge**: Generate tests for the `add_book` function in the book app. Count how many edge cases Copilot CLI includes that you wouldn't have thought of.
+2. **테스트 챌린지**: book app의 `add_book` 함수에 대한 테스트를 생성해 보세요. Copilot CLI가 포함한 엣지 케이스 중, 여러분이 미처 생각하지 못했던 것이 몇 개나 있나요?
-3. **Commit Message Challenge**: Make any small change to a book app file, stage it (`git add .`), then run:
+3. **커밋 메시지 챌린지**: book app 파일을 아무거나 조금 수정한 뒤 스테이징(`git add .`)하고, 다음을 실행해 보세요:
```bash
copilot -p "Generate a conventional commit message for: $(git diff --staged)"
```
- Is the message better than what you would have written quickly?
+ 빠르게 직접 쓴 것보다 메시지가 더 낫나요?
-**Self-Check**: You understand development workflows when you can explain why "debug this bug" is more powerful than "find bugs" (context matters!).
+**셀프 체크**: 개발 워크플로를 이해했다면, "이 버그 디버깅해줘"가 "버그 찾아줘"보다 강력한 이유(맥락이 중요함)를 설명할 수 있어야 합니다.
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: Refactor, Test, and Ship
+### 메인 챌린지: 리팩터링하고, 테스트하고, 배포(Ship)하기
-The hands-on examples focused on `find_book_by_title` and code reviews. Now practice the same workflow skills on different functions in `book-app-project`:
+실습 예시는 `find_book_by_title`과 코드 리뷰에 초점을 맞췄습니다. 이제 같은 워크플로 스킬을 `book-app-project`의 다른 함수에 적용해 보세요:
-1. **Review**: Ask Copilot CLI to review `remove_book()` in `books.py` for edge cases and potential issues:
- `@samples/book-app-project/books.py Review the remove_book() function. What happens if the title partially matches another book (e.g., "Dune" vs "Dune Messiah")? Are there any edge cases not handled?`
-2. **Refactor**: Ask Copilot CLI to improve `remove_book()` to handle edge cases like case-insensitive matching and returning useful feedback when a book isn't found
-3. **Test**: Generate pytest tests specifically for the improved `remove_book()` function, covering:
- - Removing a book that exists
- - Case-insensitive title matching
- - A book that doesn't exist returns appropriate feedback
- - Removing from an empty collection
-4. **Review**: Stage your changes and run `/review` to check for any remaining issues
-5. **Commit**: Generate a conventional commit message:
+1. **리뷰**: Copilot CLI에게 `books.py`의 `remove_book()`을 엣지 케이스/잠재 이슈 관점에서 리뷰하게 하세요:
+ `@samples/book-app-project/books.py remove_book() 함수를 리뷰해줘. 제목이 다른 책과 부분적으로 겹칠 때(예: "Dune" vs "Dune Messiah") 어떻게 될까? 처리되지 않은 엣지 케이스가 있나?`
+2. **리팩터링**: Copilot CLI에게 `remove_book()`을 개선하여 대소문자 무시 매칭, 책을 찾지 못했을 때 유용한 피드백을 반환하도록 해보세요.
+3. **테스트**: 개선된 `remove_book()`에 대해 다음을 커버하는 pytest 테스트를 생성하세요:
+ - 존재하는 책 삭제
+ - 대소문자 무시 제목 매칭
+ - 존재하지 않는 책을 삭제할 때 적절한 피드백 반환
+ - 빈 컬렉션에서 삭제
+4. **리뷰**: 변경 사항을 스테이징하고 `/review`로 남은 이슈가 없는지 확인하세요.
+5. **커밋**: conventional commit 메시지를 생성하세요:
`copilot -p "Generate a conventional commit message for: $(git diff --staged)"`
-
-### Bonus Challenge: Create an application with the Copilot CLI
+### 보너스 챌린지: Copilot CLI로 애플리케이션 만들기
-> 💡 **Note**: This GitHub Skills exercise uses **Node.js** rather than Python. The GitHub Copilot CLI techniques you'll practice - creating issues, generating code, and collaborating from the terminal - apply to any language.
+> 💡 **참고**: 이 GitHub Skills 실습은 Python이 아니라 **Node.js**를 사용합니다. 하지만 여기서 연습하는 Copilot CLI 기법(이슈 만들기, 코드 생성, 터미널에서 협업)은 어떤 언어에도 적용됩니다.
-The exercise shows developers how to use GitHub Copilot CLI to create issues, generate code, and collaborate from the terminal while building a Node.js calculator app. You'll install the CLI, use templates and agents, and practice iterative, command-line driven development.
+이 실습은 Node.js 계산기 앱을 만들면서, 터미널에서 Copilot CLI로 이슈를 만들고, 코드를 생성하고, 템플릿/에이전트를 활용하며, 반복적으로 개발하는 방법을 보여줍니다.
-##### 💡 Hints (click to expand)
+💡 힌트(클릭하여 펼치기)
-**Sample prompts for each step:** +**각 단계의 샘플 프롬프트:** ```bash copilot -# Step 1: Review -> @samples/book-app-project/books.py Review the remove_book() function. What edge cases are not handled? +# 1단계: 리뷰 +> @samples/book-app-project/books.py remove_book() 함수 리뷰해줘. 어떤 엣지 케이스가 처리되지 않았어? -# Step 2: Refactor -> Improve remove_book() to use case-insensitive matching and return a clear message when the book isn't found. Show me the before and after code. +# 2단계: 리팩터링 +> remove_book()을 대소문자 무시 매칭을 사용하도록 개선하고, 책을 찾지 못했을 때 명확한 메시지를 반환하게 해줘. 변경 전/후 코드를 보여줘. -# Step 3: Test -> Generate pytest tests for the improved remove_book() function, including: -> - Removing a book that exists -> - Case-insensitive matching ("dune" should remove "Dune") -> - Book not found returns appropriate response -> - Removing from an empty collection +# 3단계: 테스트 +> 개선된 remove_book()에 대한 pytest 테스트를 생성해줘. 다음을 포함해줘: +> - 존재하는 책 삭제 +> - 대소문자 무시 매칭("dune"이 "Dune"을 삭제) +> - 책을 못 찾았을 때 적절한 응답 +> - 빈 컬렉션에서 삭제 -# Step 4: Review +# 4단계: 리뷰 > /review -# Step 5: Commit -> Generate a conventional commit message for this refactor +# 5단계: 커밋 +> 이 리팩터링에 대한 conventional commit 메시지를 만들어줘 ``` -**Tip:** After improving `remove_book()`, try asking Copilot CLI: "Are there any other functions in this file that could benefit from the same improvements?". It may suggest similar changes to `find_book_by_title()` or `find_by_author()`. +**팁:** `remove_book()`을 개선한 뒤, Copilot CLI에게 "이 파일에서 같은 개선이 도움이 될 만한 다른 함수가 있을까?"라고 물어보세요. `find_book_by_title()`이나 `find_by_author()`에 비슷한 개선을 제안할 수도 있습니다.
[Start the "Create applications with the Copilot CLI" Skills Exercise](https://github.com/skills/create-applications-with-the-copilot-cli)
+##### ["Copilot CLI로 애플리케이션 만들기" Skills 실습 시작하기](https://github.com/skills/create-applications-with-the-copilot-cli)
---
-
---
-# Summary
+# 요약
-## 🔑 Key Takeaways
+## 🔑 핵심 정리
-🔧 Common Mistakes & Troubleshooting (click to expand)
+🔧 자주 하는 실수 & 문제 해결 (클릭하여 펼치기)
-### Common Mistakes +### 자주 하는 실수 -| Mistake | What Happens | Fix | +| 실수 | 어떤 일이 벌어지나 | 해결 | |---------|--------------|-----| -| Using vague prompts like "Review this code" | Generic feedback that misses specific issues | Be specific: "Review for SQL injection, XSS, and auth issues" | -| Not using `/review` for code reviews | Missing the optimized code-review agent | Use `/review` which is tuned for high signal-to-noise output | -| Asking to "find bugs" without context | Copilot CLI doesn't know what bug you're experiencing | Describe the symptom: "Users report X happens when Y" | -| Generating tests without specifying framework | Tests may use wrong syntax or assertion library | Specify: "Generate tests using Jest" or "using pytest" | +| "이 코드 리뷰해줘"처럼 모호한 프롬프트 | 중요한 문제를 놓치는 일반적인 피드백 | 구체적으로: "SQL 인젝션, XSS, 인증 보안 이슈를 확인해줘" | +| 코드 리뷰에 `/review`를 쓰지 않음 | 최적화된 코드 리뷰 에이전트를 놓침 | 높은 신호 대비 낮은 잡음 출력에 튜닝된 `/review` 사용 | +| 맥락 없이 "버그 찾아줘"라고 요청 | 어떤 버그인지 몰라 진단이 어려움 | 증상을 설명: "사용자들이 X를 할 때 Y가 발생" | +| 테스트 프레임워크를 지정하지 않음 | 잘못된 문법/어설션 라이브러리로 테스트가 생성될 수 있음 | "Jest로" 또는 "pytest로"처럼 프레임워크를 명시 | -### Troubleshooting +### 문제 해결 -**Review seems incomplete** - Be more specific about what to look for: +**리뷰가 덜 자세해 보일 때** — 무엇을 확인할지 더 구체적으로 요청하세요: ```bash copilot -# Instead of: -> Review @samples/book-app-project/book_app.py +# 대신: +> @samples/book-app-project/book_app.py 리뷰해줘 -# Try: -> Review @samples/book-app-project/book_app.py for input validation, error handling, and edge cases +# 이렇게: +> @samples/book-app-project/book_app.py 를 입력값 검증, 에러 처리, 엣지 케이스 관점에서 리뷰해줘 ``` -**Tests don't match my framework** - Specify the framework: +**테스트가 내 프레임워크와 맞지 않을 때** — 프레임워크를 지정하세요: ```bash copilot -> @samples/book-app-project/books.py Generate tests using pytest (not unittest) +> @samples/book-app-project/books.py pytest로 테스트를 생성해줘 (unittest 말고) ``` -**Refactoring changes behavior** - Ask Copilot CLI to preserve behavior: +**리팩터링이 동작을 바꿀 때** — 동작 보존을 강조하세요: ```bash copilot -> @samples/book-app-project/book_app.py Refactor command handling to use dictionary dispatch. IMPORTANT: Maintain identical external behavior - no breaking changes +> @samples/book-app-project/book_app.py 명령 처리 로직을 딕셔너리 디스패치로 리팩터링해줘. 중요: 외부 동작은 완전히 동일해야 해 - breaking change 금지 ```
+
-1. **Code review** becomes comprehensive with specific prompts
-2. **Refactoring** is safer when you generate tests first
-3. **Debugging** benefits from showing Copilot CLI the error AND the code
-4. **Test generation** should include edge cases and error scenarios
-5. **Git integration** automates commit messages and PR descriptions
+1. **코드 리뷰**는 구체적인 프롬프트로 더 포괄적이 된다
+2. **리팩터링**은 테스트를 먼저 생성하면 더 안전해진다
+3. **디버깅**은 에러와 코드를 함께 보여주면 효과가 커진다
+4. **테스트 생성**은 엣지 케이스와 에러 시나리오를 포함해야 한다
+5. **Git 통합**은 커밋 메시지와 PR 설명을 자동화한다
-> 📋 **Quick Reference**: See the [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for a complete list of commands and shortcuts.
+> 📋 **빠른 참고**: 전체 명령과 단축키 목록은 [GitHub Copilot CLI 명령 레퍼런스](https://docs.github.com/en/copilot/reference/cli-command-reference)를 확인하세요.
---
-## ✅ Checkpoint: You've Mastered the Essentials
+## ✅ 체크포인트: 핵심을 마스터했습니다
-**Congratulations!** You now have all the core skills to be productive with GitHub Copilot CLI:
+**축하합니다!** 이제 GitHub Copilot CLI로 생산적으로 일하기 위한 핵심 역량을 갖췄습니다:
-| Skill | Chapter | You Can Now... |
+| 스킬 | 챕터 | 이제 할 수 있는 것 |
|-------|---------|----------------|
-| Basic Commands | Ch 01 | Use interactive mode, plan mode, programmatic mode (-p), and slash commands |
-| Context | Ch 02 | Reference files with `@`, manage sessions, understand context windows |
-| Workflows | Ch 03 | Review code, refactor, debug, generate tests, integrate with git |
+| 기본 명령 | Ch 01 | 인터랙티브 모드, 플랜 모드, 프로그래매틱 모드(-p), 슬래시 명령 사용 |
+| 컨텍스트 | Ch 02 | `@`로 파일 참조, 세션 관리, 컨텍스트 윈도우 이해 |
+| 워크플로 | Ch 03 | 코드 리뷰, 리팩터링, 디버깅, 테스트 생성, git 통합 |
-Chapters 04-06 cover additional features that add even more power and are worthwhile to learn.
+챕터 04~06에는 더 많은 기능이 있으며, 시간을 내서 학습할 가치가 있습니다.
---
-## 🛠️ Building Your Personal Workflow
+## 🛠️ 나만의 워크플로 만들기
-There's no single "right" way to use GitHub Copilot CLI. Here are a few tips as you develop your own patterns:
+GitHub Copilot CLI를 사용하는 ‘정답’은 하나가 아닙니다. 나만의 패턴을 만들 때 도움이 되는 몇 가지 팁입니다:
-> 📚 **Official Documentation**: [Copilot CLI best practices](https://docs.github.com/copilot/how-tos/copilot-cli/cli-best-practices) for recommended workflows and tips from GitHub.
+> 📚 **공식 문서**: 권장 워크플로와 팁은 [Copilot CLI best practices](https://docs.github.com/copilot/how-tos/copilot-cli/cli-best-practices)를 참고하세요.
-- **Start with `/plan`** for anything non-trivial. Refine the plan before execution - a good plan leads to better results.
-- **Save prompts that work well.** When Copilot CLI makes a mistake, note what went wrong. Over time, this becomes your personal playbook.
-- **Experiment freely.** Some developers prefer long, detailed prompts. Others prefer short prompts with follow-ups. Try different approaches and notice what feels natural.
+- **비교적 복잡한 작업은 `/plan`부터 시작**하세요. 실행 전에 계획을 다듬으면 결과가 좋아집니다.
+- **잘 통하는 프롬프트는 저장**해 두세요. Copilot CLI가 실수했을 때 무엇이 문제였는지 기록해 두면, 시간이 지날수록 개인 플레이북이 됩니다.
+- **자유롭게 실험**하세요. 어떤 개발자는 길고 자세한 프롬프트를 선호하고, 어떤 개발자는 짧은 프롬프트+후속 질문을 선호합니다. 자연스러운 방식을 찾아보세요.
-> 💡 **Coming up**: In Chapters 04 and 05, you'll learn how to codify your best practices into custom instructions and skills that Copilot CLI loads automatically.
+> 💡 **다음 챕터 예고**: 챕터 04와 05에서는, Copilot CLI가 자동으로 로드하는 커스텀 인스트럭션과 스킬로 베스트 프랙티스를 ‘코드화’하는 방법을 배웁니다.
---
-## ➡️ What's Next
+## ➡️ 다음은 무엇인가요?
-The remaining chapters cover additional features that extend Copilot CLI's capabilities:
+남은 챕터들은 Copilot CLI의 역량을 확장하는 기능을 다룹니다:
-| Chapter | What It Covers | When You'll Want It |
+| 챕터 | 다루는 내용 | 필요해지는 순간 |
|---------|----------------|---------------------|
-| Ch 04: Agents | Create specialized AI personas | When you want domain experts (frontend, security) |
-| Ch 05: Skills | Auto-load instructions for tasks | When you repeat the same prompts often |
-| Ch 06: MCP | Connect external services | When you need live data from GitHub, databases |
+| Ch 04: 에이전트 | 특화된 AI 페르소나 만들기 | 도메인 전문가(프론트엔드, 보안)가 필요할 때 |
+| Ch 05: 스킬 | 반복 작업용 인스트럭션 자동 로드 | 같은 프롬프트를 자주 반복할 때 |
+| Ch 06: MCP | 외부 서비스 연결 | GitHub/DB 등에서 라이브 데이터가 필요할 때 |
-**Recommendation**: Try the core workflows for a week, then return to Chapters 04-06 when you have specific needs.
+**추천**: 핵심 워크플로를 일주일 정도 사용해 보고, 구체적 니즈가 생기면 챕터 04~06으로 돌아오세요.
---
-## Continue to Additional Topics
+## 추가 주제로 계속
-In **[Chapter 04: Agents and Custom Instructions](../04-agents-custom-instructions/README.md)**, you'll learn:
+**[챕터 04: 에이전트와 커스텀 인스트럭션](../04-agents-custom-instructions/README.md)**에서는 다음을 배웁니다:
-- Using built-in agents (`/plan`, `/review`)
-- Creating specialized agents (frontend expert, security auditor) with `.agent.md` files
-- Multi-agent collaboration patterns
-- Custom instruction files for project standards
+- 내장 에이전트(`/plan`, `/review`) 사용
+- `.agent.md` 파일로 특화 에이전트(프론트엔드 전문가, 보안 감사자) 만들기
+- 멀티 에이전트 협업 패턴
+- 프로젝트 표준을 위한 커스텀 인스트럭션 파일
---
-**[← Back to Chapter 02](../02-context-conversations/README.md)** | **[Continue to Chapter 04 →](../04-agents-custom-instructions/README.md)**
+**[← 챕터 02로 돌아가기](../02-context-conversations/README.md)** | **[챕터 04로 계속 →](../04-agents-custom-instructions/README.md)"
\ No newline at end of file
diff --git a/04-agents-custom-instructions/README.md b/04-agents-custom-instructions/README.md
index a84d8894..a0f12f23 100644
--- a/04-agents-custom-instructions/README.md
+++ b/04-agents-custom-instructions/README.md
@@ -1,78 +1,79 @@
-> **What if you could hire a Python code reviewer, testing expert, and security reviewer... all in one tool?**
+**파이썬 코드 리뷰어, 테스트 전문가, 보안 리뷰어를 모두 하나의 도구로 고용할 수 있다면 어떨까요?**
-In Chapter 03, you mastered the essential workflows: code review, refactoring, debugging, test generation, and git integration. Those make you highly productive with GitHub Copilot CLI. Now, let's take it further.
+3장에서는 코드 리뷰, 리팩토링, 디버깅, 테스트 생성, Git 통합 등 필수적인 워크플로우를 익혔습니다. 이러한 워크플로우를 통해 GitHub Copilot CLI를 매우 효율적으로 활용할 수 있습니다. 이제 한 단계 더 나아가 보겠습니다.
-So far, you've been using Copilot CLI as a general-purpose assistant. Agents let you give it a specific persona with built-in standards, like a code reviewer that enforces type hints and PEP 8, or a testing helper that writes pytest cases. You'll see how the same prompt gets noticeably better results when handled by an agent with targeted instructions.
+지금까지 Copilot CLI는 범용 도우미로 사용해 왔습니다. 에이전트를 사용하면 타입 힌트 및 PEP 8을 준수하는 코드 리뷰어 또는 pytest 케이스를 작성하는 테스트 도우미처럼 특정 역할과 표준을 Copilot에 부여할 수 있습니다. 에이전트에 특정 지침을 입력하면 동일한 작업도 훨씬 더 나은 결과를 얻을 수 있습니다.
-## 🎯 Learning Objectives
+## 🎯 학습 목표
-By the end of this chapter, you'll be able to:
+이 장을 마치면 다음을 수행할 수 있게 됩니다.
-- Use built-in agents: Plan (`/plan`), Code-review (`/review`), and understand automatic agents (Explore, Task)
-- Create specialized agents using agent files (`.agent.md`)
-- Use agents for domain-specific tasks
-- Switch between agents using `/agent` and `--agent`
-- Write custom instruction files for project-specific standards
+- 내장 에이전트 사용: 계획(`/plan`), 코드 검토(`/review`) 및 자동 에이전트(탐색, 작업) 이해
+- 에이전트 파일(`.agent.md`)을 사용하여 특수 에이전트 생성
+- 도메인별 작업에 에이전트 사용
+- `/agent` 및 `--agent`를 사용하여 에이전트 간 전환
+- 프로젝트별 표준에 맞는 사용자 지정 지침 파일 작성
-> ⏱️ **Estimated Time**: ~55 minutes (20 min reading + 35 min hands-on)
+> ⏱️ **예상 소요 시간**: 약 55분 (읽기 20분 + 실습 35분)
---
-## 🧩 Real-World Analogy: Hiring Specialists
+## 🧩 실제 사례: 전문가 고용
-When you need help with your house, you don't call one "general helper." You call specialists:
+집에 도움이 필요할 때, "만능 해결사" 한 명을 부르는 대신 전문가를 부릅니다.
-| Problem | Specialist | Why |
+| 문제 | 전문가 | 이유 |
|---------|------------|-----|
-| Leaky pipe | Plumber | Knows plumbing codes, has specialized tools |
-| Rewiring | Electrician | Understands safety requirements, up to code |
-| New roof | Roofer | Knows materials, local weather considerations |
+| 누수 | 배관공 | 배관 규정을 숙지하고 특수 공구를 보유 |
+| 배선 교체 | 전기 기술자 | 안전 요건을 이해하고 규정을 준수 |
+| 새 지붕 | 지붕 시공 전문가 | 자재 및 지역 기후 조건을 고려 |
-Agents work the same way. Instead of a generic AI, use agents that focus on specific tasks and know the right process to follow. Set up the instructions once, then reuse them whenever you need that specialty: code review, testing, security, documentation.
+에이전트도 마찬가지입니다. 일반적인 AI 대신 특정 작업에 집중하고 올바른 프로세스를 따르는 에이전트를 사용하세요. 지침을 한 번만 설정하면 해당 전문 분야가 필요할 때마다 재사용할 수 있습니다. 예를 들어 코드 검토, 테스트, 보안, 문서화 등이 있습니다.
---
-# Using Agents
+# 에이전트 사용하기
-Get started with built-in and custom agents right away.
+내장 에이전트와 사용자 지정 에이전트를 바로 시작해 보세요.
---
-## *New to Agents?* Start Here!
-Never used or made an agent? Here's all you need to know to get started for this course.
+## *에이전트가 처음이신가요?* 여기에서 시작하세요!
+에이전트를 사용해 본 적도, 만들어 본 적도 없으신가요? 이 강좌를 시작하는 데 필요한 모든 정보를 여기에서 확인하세요.
-1. **Try a *built-in* agent right now:**
- ```bash
- copilot
- > /plan Add input validation for book year in the book app
- ```
- This invokes the Plan agent to create a step-by-step implementation plan.
+1. **내장 에이전트를 지금 바로 사용해 보세요:**
+```bash
+copilot
-2. **See one of our custom agent examples:** It's simple to define an agent's instructions, look at our provided [python-reviewer.agent.md](../.github/agents/python-reviewer.agent.md) file to see the pattern.
+> /plan 책 앱에 책 연도 입력 유효성 검사 추가
+
+```
+이 명령은 Plan 에이전트를 실행하여 단계별 구현 계획을 생성합니다.
-3. **Understand the core concept:** Agents are like consulting a specialist instead of a generalist. A "frontend agent" will focus on accessibility and component patterns automatically, you don't have to remind it because it is already specified in the agent's instructions.
+2. **사용자 지정 에이전트 예제를 살펴보세요:** 에이전트의 지침을 정의하는 것은 간단합니다. 제공된 [python-reviewer.agent.md](../.github/agents/python-reviewer.agent.md) 파일을 참조하여 패턴을 확인하세요.
+3. **핵심 개념을 이해하세요:** 에이전트는 일반적인 사람이 아닌 특정 분야의 전문가에게 자문을 구하는 것과 같습니다. "프런트엔드 에이전트"는 접근성과 컴포넌트 패턴에 자동으로 초점을 맞추므로, 에이전트의 지침에 이미 명시되어 있어 별도로 상기시켜줄 필요가 없습니다.
-## Built-in Agents
+## 내장 에이전트
-**You've already used some built-in agents in Chapter 03 Development Workflow!**
-`/plan` and `/review` are actually built-in agents. Now you know what's happening under the hood. Here's the full list: +**3장 개발 워크플로에서 이미 몇 가지 내장 에이전트를 사용해 보셨습니다!** +
`/plan`과 `/review`는 실제로 내장 에이전트입니다. 이제 내부적으로 어떤 일이 일어나는지 알게 되셨습니다. 전체 목록은 다음과 같습니다. -| Agent | How to Invoke | What It Does | +| 에이전트 | 호출 방법 | 기능 | |-------|---------------|--------------| -| **Plan** | `/plan` or `Shift+Tab` (cycle modes) | Creates step-by-step implementation plans before coding | -| **Code-review** | `/review` | Reviews staged/unstaged changes with focused, actionable feedback | -| **Init** | `/init` | Generates project configuration files (instructions, agents) | -| **Explore** | *Automatic* | Used internally when you ask Copilot to explore or analyze the codebase | -| **Task** | *Automatic* | Executes commands like tests, builds, lints, and dependency installs | +| **계획** | `/plan` 또는 `Shift+Tab` (순환 모드) | 코딩 전에 단계별 구현 계획을 생성합니다. | +| **코드 검토** | `/review` | 스테이징/스테이징되지 않은 변경 사항을 검토하고 실행 가능한 피드백을 제공합니다. | +| **초기화** | `/init` | 프로젝트 구성 파일(지침, 에이전트)을 생성합니다. | +| **탐색** | *자동* | Copilot에 코드베이스 탐색 또는 분석을 요청할 때 내부적으로 사용됩니다. | +| **작업** | *자동* | 테스트, 빌드, 린트, 종속성 설치 등의 명령을 실행합니다.
-**Built-in agents in action** - Examples of invoking Plan, Code-review, Explore, and Task +**내장 에이전트 작동 예시** - 계획, 코드 검토, 탐색, 작업 실행 예시 ```bash copilot @@ -89,138 +90,138 @@ copilot > Explore how book data is loaded # Uses Explore agent ``` -What about the Task Agent? It works behind the scenes to manage and track what is going on and to report back in a clean and clear format: +태스크 에이전트는 어떨까요? 태스크 에이전트는 백그라운드에서 작동하여 진행 상황을 관리하고 추적하며, 다음과 같이 깔끔하고 명확한 형식으로 보고합니다. -| Outcome | What You See | +| 결과 | 표시되는 내용 | |---------|--------------| -| ✅ **Success** | Brief summary (e.g., "All 247 tests passed", "Build succeeded") | -| ❌ **Failure** | Full output with stack traces, compiler errors, and detailed logs | +| ✅ **성공** | 간략한 요약 (예: "247개 테스트 모두 통과", "빌드 성공") | +| ❌ **실패** | 스택 트레이스, 컴파일러 오류 및 자세한 로그를 포함한 전체 출력 | - -> 📚 **Official Documentation**: [GitHub Copilot CLI Agents](https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#use-custom-agents) +> 📚 **공식 문서**: [GitHub Copilot CLI 에이전트](https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#use-custom-agents) --- -# Adding Agents to Copilot CLI +# Copilot CLI에 에이전트 추가 -You can simply define your own agents to be part of your workflow! Define once, then direct! +워크플로우에 포함할 에이전트를 직접 정의할 수 있습니다! 한 번 정의하면 바로 사용할 수 있습니다!
-## 🗂️ Add your agents
+## 🗂️ 에이전트 추가하기
-Agent files are markdown files with a `.agent.md` extension. They have two parts: YAML frontmatter (metadata) and markdown instructions.
+에이전트 파일은 `.agent.md` 확장자를 가진 마크다운 파일입니다. 에이전트 파일은 YAML 프론트매터(메타데이터)와 마크다운 명령어 두 부분으로 구성됩니다.
-> 💡 **New to YAML frontmatter?** It's a small block of settings at the top of the file, surrounded by `---` markers. YAML is just `key: value` pairs. The rest of the file is regular markdown.
+> 💡 **YAML 프론트매터가 처음이신가요?** 파일 맨 위에 `---` 태그로 둘러싸인 작은 설정 블록입니다. YAML은 `키: 값` 쌍으로 이루어져 있습니다. 파일의 나머지 부분은 일반 마크다운입니다.
-Here's a minimal agent:
+다음은 최소한의 에이전트 예시입니다.
```markdown
---
name: my-reviewer
-description: Code reviewer focused on bugs and security issues
+description: 버그와 보안 문제에 집중한 코드 리뷰어입니다
---
# Code Reviewer
-You are a code reviewer focused on finding bugs and security issues.
+당신은 버그와 보안 문제를 찾는 데 집중하는 코드 리뷰어입니다.
-When reviewing code, always check for:
-- SQL injection vulnerabilities
-- Missing error handling
-- Hardcoded secrets
+코드를 검토할 때는 항상 다음을 확인하세요.:
+- SQL 인젝션 취약점
+- 오류 처리 누락
+- 하드코딩된 비밀
```
-> 💡 **Required vs Optional**: The `description` field is required. Other fields like `name`, `tools`, and `model` are optional.
+> 💡 **필수 vs 선택**: `description` 필드는 필수입니다. `name`, `tools`, `model` 등의 필드는 선택 사항입니다.
-## Where to put agent files
+## 에이전트 파일 위치
-| Location | Scope | Best For |
+| 위치 | 범위 | 최적 사용처 |
|----------|-------|----------|
-| `.github/agents/` | Project-specific | Team-shared agents with project conventions |
-| `~/.copilot/agents/` | Global (all projects) | Personal agents you use everywhere |
+| `.github/agents/` | 프로젝트별 | 프로젝트 규칙을 따르는 팀 공유 에이전트 |
+| `~/.copilot/agents/` | 전역 (모든 프로젝트) | 어디에서나 사용하는 개인 에이전트 |
-**This project includes sample agent files in the [.github/agents/](../.github/agents/) folder**. You can write your own, or customize the ones already provided.
+**이 프로젝트에는 `.github/agents/` 폴더에 샘플 에이전트 파일이 포함되어 있습니다.** 직접 에이전트 파일을 작성하거나 제공된 파일을 사용자 지정할 수 있습니다.
-
-## 🚀 Two ways to use custom agents
+## 🚀 사용자 지정 상담원 사용 방법 두 가지
+
+### 대화형 모드
+대화형 모드에서 `/agent` 명령어를 사용하여 상담원 목록을 확인하고, 작업을 시작할 상담원을 선택합니다.
-### Interactive mode
-Inside interactive mode, list agents using `/agent` and select the agent to start working with.
-Select an agent to continue your conversation with.
+대화를 계속할 상담원을 선택합니다.
```bash
copilot
> /agent
```
-To change to a different agent, or to return to default mode, use the `/agent` command again.
+다른 에이전트로 변경하거나 기본 모드로 되돌리려면 `/agent` 명령을 다시 사용하십시오.
-### Programmatic mode
+### 프로그래밍 방식 모드
-Launch straight into a new session with an agent.
+Agent와 바로 새 세션을 시작하세요.
```bash
copilot --agent python-reviewer
> Review @samples/book-app-project/books.py
```
-> 💡 **Switching agents**: You can switch to a different agent at any time by using `/agent` or `--agent` again. To return to the standard Copilot CLI experience, use `/agent` and select **no agent**.
+> 💡**에이전트 전환**: `/agent` 또는 `--agent`를 다시 사용하여 언제든지 다른 에이전트로 전환할 수 있습니다. 표준 Copilot CLI 환경으로 돌아가려면 `/agent`를 사용하고 **에이전트 없음**을 선택하십시오.
---
-# Going Deeper with Agents
+# 에이전트와 더 깊이 소통하기
📂 See the sample agents in this course
+📂 이 과정에서 샘플 에이전트를 확인하세요
-| File | Description | +| 파일 | 설명 | |------|-------------| -| `hello-world.agent.md` | Minimal example - start here | -| `python-reviewer.agent.md` | Python code quality reviewer | -| `pytest-helper.agent.md` | Pytest testing specialist | +| `hello-world.agent.md` | 최소 예제 - 여기서 시작하세요 | +| `python-reviewer.agent.md` | Python 코드 품질 검토자 | +| `pytest-helper.agent.md` | Pytest 테스트 전문가 | ```bash -# Or copy one to your personal agents folder (available in every project) +# 또는 개인 에이전트 폴더(모든 프로젝트에서 사용 가능)에 복사하세요. cp .github/agents/python-reviewer.agent.md ~/.copilot/agents/ ``` -For more community agents, see [github/awesome-copilot](https://github.com/github/awesome-copilot) +더 많은 커뮤니티 에이전트를 보려면 [github/awesome-copilot](https://github.com/github/awesome-copilot)을 참조하세요.
-> 💡 **This section is optional.** The built-in agents (`/plan`, `/review`) are powerful enough for most workflows. Create custom agents when you need specialized expertise that's consistently applied across your work.
+> 💡 **이 섹션은 선택 사항입니다.** 내장 에이전트(`/plan`, `/review`)는 대부분의 워크플로에 충분히 강력합니다. 작업 전반에 걸쳐 일관되게 적용되는 전문적인 지식이 필요한 경우 사용자 지정 에이전트를 생성하세요.
-Each topic below is self-contained. **Pick what interests you - you don't need to read them all at once.**
+아래 각 항목은 독립적입니다. **관심 있는 항목만 선택하세요. 한 번에 모두 읽을 필요는 없습니다.**
-| I want to... | Jump to |
+| 지금 하고 싶은 것... | 바로가기 |
|---|---|
-| See why agents beat generic prompts | [Specialist vs Generic](#specialist-vs-generic-see-the-difference) |
-| Combine agents on a feature | [Working with Multiple Agents](#working-with-multiple-agents) |
-| Organize, name, and share agents | [Organizing & Sharing Agents](#organizing--sharing-agents) |
-| Set up always-on project context | [Configuring Your Project for Copilot](#configuring-your-project-for-copilot) |
-| Look up YAML properties and tools | [Agent File Reference](#agent-file-reference) |
+| 에이전트가 일반 프롬프트보다 나은 이유 알아보기 | [전문가 vs 일반](#specialist-vs-generic-see-the-difference) |
+| 기능에 에이전트 결합하기 | [여러 에이전트 사용](#working-with-multiple-agents) |
+| 에이전트 구성, 이름 지정 및 공유하기 | [에이전트 구성 및 공유](#organizing--sharing-agents) |
+| 상시 작동 프로젝트 컨텍스트 설정하기 | [Copilot용 프로젝트 구성](#configuring-your-project-for-copilot) |
+| YAML 속성 및 도구 찾아보기 | [에이전트 파일 참조](#agent-file-reference) |
-Select a scenario below to expand it.
+아래 시나리오를 선택하여 자세히 살펴보세요.
---
-
@@ -302,50 +303,51 @@ def search_by_year_range(
Specialist vs Generic: See the Difference - Why agents produce better output than generic prompts
+Specialist vs Generic: 차이점을 알아보세요 - 에이전트가 일반 프롬프트보다 더 나은 결과를 생성하는 이유는 무엇일까요?
-## Specialist vs Generic: See the Difference +## Specialist vs Generic: 차이점을 확인해 보세요 -This is where agents prove their value. Watch the difference: +바로 이 지점에서 에이전트의 진가가 드러납니다. 차이를 직접 확인해 보세요: -### Without an Agent (Generic Copilot) +### 에이전트 없이 (Generic Copilot) ```bash copilot -> Add a function to search books by year range in the book app +> 도서 앱에서 연도별 검색 기능을 추가하세요 ``` **Generic output**: @@ -233,19 +234,19 @@ def search_by_year_range(books, start_year, end_year): return results ``` -Basic. Works. But missing a lot. +기본적인 것. 효과가 있어요. 하지만 많은 부분을 놓치고 있습니다. --- -### With the Python Reviewer Agent +### 파이썬 리뷰어 에이전트와 함께할 때 ```bash copilot > /agent -# Select "python-reviewer" +# "python-reviewer"를 선택하세요 -> Add a function to search books by year range in the book app +> 도서 앱에서 연도별로 책을 검색하는 기능을 추가하세요 ``` **Specialist output**: @@ -285,16 +286,16 @@ def search_by_year_range( ] ``` -**What the python-reviewer agent automatically includes**: -- ✅ Type hints on all parameters and return values -- ✅ Comprehensive docstring with Args/Returns/Raises -- ✅ Input validation with proper error handling -- ✅ List comprehension for better performance -- ✅ Edge case handling (missing/invalid year values) -- ✅ PEP 8 compliant formatting -- ✅ Defensive programming practices +**python-reviewer 에이전트가 자동으로 포함하는 기능**: +- ✅ 모든 매개변수 및 반환 값에 대한 타입 힌트 +- ✅ Args/Returns/Raises를 포함한 포괄적인 docstring +- ✅ 적절한 오류 처리를 포함한 입력 유효성 검사 +- ✅ 성능 향상을 위한 리스트 컴프리헨션 +- ✅ 예외 처리 (누락되거나 유효하지 않은 연도 값) +- ✅ PEP 8 준수 형식 +- ✅ 방어적 프로그래밍 방식 -**The difference**: Same prompt, dramatically better output. The agent brings expertise you'd forget to ask for. +**차이점**: 동일한 프롬프트에서 훨씬 더 나은 출력 결과를 제공합니다. 에이전트는 사용자가 미처 요청하지 못했을 수도 있는 전문적인 정보를 제공합니다.
-
@@ -353,15 +355,15 @@ When agents are configured, Copilot can also call them as tools during complex t
Working with Multiple Agents - Combine specialists, switch mid-session, agent-as-tools
+여러 에이전트와 협업하기 - 전문가 결합, 세션 중 전환, Agent를 도구로 활용
-## Working with Multiple Agents +## 여러 에이전트와 협업하기 -The real power comes when specialists work together on a feature. +전문가들이 협력하여 기능을 개발할 때 진정한 시너지가 발휘됩니다. -### Example: Building a Simple Feature +### 예시: 간단한 기능 구축 ```bash copilot -> I want to add a "search by year range" feature to the book app +> 책 앱에 "연도 범위로 검색" 기능을 추가하고 싶습니다. -# Use python-reviewer for design +# 설계 단계에서는 python-reviewer를 사용합니다. > /agent -# Select "python-reviewer" +# "python-reviewer"를 선택합니다. -> @samples/book-app-project/books.py Design a find_by_year_range method. What's the best approach? +> @samples/book-app-project/books.py find_by_year_range 메서드를 설계하세요. 어떤 접근 방식이 가장 좋을까요? -# Switch to pytest-helper for test design +# 테스트 설계 단계에서는 pytest-helper로 전환합니다. > /agent -# Select "pytest-helper" +# "pytest-helper"를 선택합니다. + +> @samples/book-app-project/tests/test_books.py find_by_year_range 메서드에 대한 테스트 케이스를 설계하세요. -> @samples/book-app-project/tests/test_books.py Design test cases for a find_by_year_range method. -> What edge cases should we cover? +> 어떤 예외 상황을 고려해야 할까요? -# Synthesize both designs -> Create an implementation plan that includes the method implementation and comprehensive tests. +# 두 설계 결과를 종합합니다. +> 메서드 구현과 포괄적인 테스트를 포함하는 구현 계획을 작성합니다. ``` -**The key insight**: You're the architect directing specialists. They handle the details, you handle the vision. +**핵심 통찰**: 당신은 전문가들을 이끄는 건축가입니다. 그들은 세부 사항을 처리하고, 당신은 비전을 제시합니다.
-
-### Agent as Tools
+### 도구로서의 Agents
-When agents are configured, Copilot can also call them as tools during complex tasks. If you ask for a full-stack feature, Copilot may automatically delegate parts to the appropriate specialist agents.
+에이전트가 구성되면 Copilot은 복잡한 작업을 수행하는 동안 해당 에이전트를 도구로 호출할 수도 있습니다. 풀스택 기능을 요청하면 Copilot은 적절한 전문 에이전트에 작업의 일부를 자동으로 위임할 수 있습니다.
🎬 See it in action!
+🎬 실제로 작동하는 모습을 확인하세요!
 -*Demo output varies - your model, tools, and responses will differ from what's shown here.* +*데모 출력 결과는 다를 수 있습니다. 사용하시는 모델, 도구 및 응답은 여기에 표시된 내용과 다를 수 있습니다.*
-
+
-**Start simple:** Create a single `*.agent.md` file in your project folder. Move it to a permanent location once you're happy with it.
+**간단하게 시작하세요:** 프로젝트 폴더에 `*.agent.md` 파일을 하나만 생성하세요. 만족스러우면 영구적인 위치로 이동하세요.
-Beyond agent files, Copilot also reads **project-level instruction files** automatically, no `/agent` needed. See [Configuring Your Project for Copilot](#configuring-your-project-for-copilot) below for `AGENTS.md`, `.instructions.md`, and `/init`.
+에이전트 파일 외에도 Copilot은 **프로젝트 수준의 지침 파일**을 자동으로 읽습니다. 따라서 `/agent`는 필요하지 않습니다. `AGENTS.md`, `.instructions.md` 및 `/init`에 대한 자세한 내용은 아래의 [Copilot용 프로젝트 구성](#configuring-your-project-for-copilot)을 참조하세요.
@@ -398,43 +400,42 @@ Beyond agent files, Copilot also reads **project-level instruction files** autom
Organizing & Sharing Agents - Naming, file placement, instruction files, and team sharing
+조직 및 공유 에이전트 - 파일 이름 지정, 파일 배치, 지침 파일 및 팀 공유
## Organizing & Sharing Agents -### Naming Your Agents +### 에이전트 이름 지정하기 -When you create agent files, the name matters. It's what you'll type after `/agent` or `--agent`, and what your teammates will see in the agent list. +에이전트 파일을 생성할 때 이름은 중요합니다. `/agent` 또는 `--agent` 뒤에 입력하게 될 이름이며, 팀원들이 에이전트 목록에서 보게 될 이름이기도 합니다. -| ✅ Good Names | ❌ Avoid | +| ✅ 좋은 이름 | ❌ 피해야 할 이름 | |--------------|----------| | `frontend` | `my-agent` | | `backend-api` | `agent1` | @@ -369,28 +371,28 @@ When you create agent files, the name matters. It's what you'll type after `/age | `react-specialist` | `code` | | `python-backend` | `assistant` | -**Naming conventions:** -- Use lowercase with hyphens: `my-agent-name.agent.md` -- Include the domain: `frontend`, `backend`, `devops`, `security` -- Be specific when needed: `react-typescript` vs just `frontend` +**명명 규칙:** +- 소문자와 하이픈 사용: `my-agent-name.agent.md` +- 도메인 포함: `frontend`, `backend`, `devops`, `security` +- 필요한 경우 구체적으로 명시: `react-typescript` vs. `frontend` --- -### Sharing with Your Team +### 팀과의 공유 -Place agent files in `.github/agents/` and they're version controlled. Push to your repo and every team member gets them automatically. But agents are just one type of file Copilot reads from your project. It also supports **instruction files** that apply automatically to every session, without anyone needing to run `/agent`. +에이전트 파일은 `.github/agents/` 폴더에 저장하면 버전 관리가 됩니다. 저장소에 푸시하면 모든 팀원이 자동으로 파일을 받게 됩니다. 하지만 에이전트 파일은 Copilot이 프로젝트에서 읽어들이는 파일 유형 중 하나일 뿐입니다. Copilot은 `/agent`를 실행하지 않아도 모든 세션에 자동으로 적용되는 **지침 파일**도 지원합니다. -Think of it this way: agents are specialists you call on, and instruction files are team rules that are always active. +쉽게 말해, 에이전트는 도움을 요청할 수 있는 전문가이고, 지침 파일은 항상 활성화되어 있는 팀 규칙입니다. -### Where to Put Your Files +### 파일 저장 위치 -You already know the two main locations (see [Where to put agent files](#where-to-put-agent-files) above). Use this decision tree to choose: +주요 저장 위치는 이미 두 곳(위의 [에이전트 파일 저장 위치](#where-to-put-agent-files) 참조)을 알고 계실 겁니다. 다음 결정 트리를 사용하여 에이전트 파일 위치를 선택하세요. -
+
-**Start simple:** Create a single `*.agent.md` file in your project folder. Move it to a permanent location once you're happy with it.
+**간단하게 시작하세요:** 프로젝트 폴더에 `*.agent.md` 파일을 하나만 생성하세요. 만족스러우면 영구적인 위치로 이동하세요.
-Beyond agent files, Copilot also reads **project-level instruction files** automatically, no `/agent` needed. See [Configuring Your Project for Copilot](#configuring-your-project-for-copilot) below for `AGENTS.md`, `.instructions.md`, and `/init`.
+에이전트 파일 외에도 Copilot은 **프로젝트 수준의 지침 파일**을 자동으로 읽습니다. 따라서 `/agent`는 필요하지 않습니다. `AGENTS.md`, `.instructions.md` 및 `/init`에 대한 자세한 내용은 아래의 [Copilot용 프로젝트 구성](#configuring-your-project-for-copilot)을 참조하세요.
-
+
-Create your own agents and see them in action.
+나만의 에이전트를 만들고 실제로 작동하는 모습을 확인해 보세요.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 시도해 보세요
```bash
@@ -605,27 +606,33 @@ copilot
---
-## 📝 Assignment
+## 📝 과제
+
+### 주요 과제: 전문 에이전트 팀 구축
+
+실습 예제에서는 `검토자` 및 `문서 작성자` 에이전트를 생성했습니다. 이제 다른 작업을 위해 에이전트를 만들고 사용하는 연습을 해보세요. 바로 도서 앱의 데이터 유효성 검사를 개선하는 것입니다.
+
+1. 도서 앱에 맞게 에이전트 파일 3개(각 에이전트당 1개씩, 총 3개)를 생성하여 `.github/agents/` 폴더에 배치합니다.
+2. 에이전트:
+
+- **데이터 유효성 검사기**: `data.json` 파일에서 누락되거나 형식이 잘못된 데이터(저자 필드가 비어 있거나, 연도가 0이거나, 필드가 누락된 경우 등)를 검사합니다.
+
+- **오류 처리기**: 일관성 없는 오류 처리를 보이는 Python 코드를 검토하고 통일된 접근 방식을 제안합니다.
+
+- **문서 작성기**: 문서 문자열과 README 파일 내용을 생성하거나 업데이트합니다.
+3. 도서 앱에서 각 에이전트를 사용합니다.
-### Main Challenge: Build a Specialized Agent Team
+- `데이터 유효성 검사기` → `@samples/book-app-project/data.json` 파일 감사
-The hands-on example created `reviewer` and `documentor` agents. Now practice creating and using agents for a different task - improving data validation in the book app:
+- `오류 처리기` → `@samples/book-app-project/books.py` 및 `@samples/book-app-project/utils.py` 파일 검토
-1. Create 3 agent files (`.agent.md`) tailored to the book app, one per agent, placed in `.github/agents/`
-2. Your agents:
- - **data-validator**: checks `data.json` for missing or malformed data (empty authors, year=0, missing fields)
- - **error-handler**: reviews Python code for inconsistent error handling and suggests a unified approach
- - **doc-writer**: generates or updates docstrings and README content
-3. Use each agent on the book app:
- - `data-validator` → audit `@samples/book-app-project/data.json`
- - `error-handler` → review `@samples/book-app-project/books.py` and `@samples/book-app-project/utils.py`
- - `doc-writer` → add docstrings to `@samples/book-app-project/books.py`
-4. Collaborate: use `error-handler` to identify error-handling gaps, then `doc-writer` to document the improved approach
+- `문서 작성기` → 문서 문자열 추가 `@samples/book-app-project/books.py`
+4. 협업: `error-handler`를 사용하여 오류 처리의 부족한 부분을 파악한 다음, `doc-writer`를 사용하여 개선된 접근 방식을 문서화합니다.
-**Success criteria**: You have 3 working agents that produce consistent, high-quality output and you can switch between them with `/agent`.
+**성공 기준**: 일관되고 고품질의 출력을 생성하는 3개의 에이전트가 있으며, `/agent`를 사용하여 에이전트 간에 전환할 수 있습니다.
Configuring Your Project for Copilot - AGENTS.md, instruction files, and /init setup
+Copilot용 프로젝트 구성하기 - AGENTS.md, 지침 파일 및 /init 설정
-## Configuring Your Project for Copilot +## Copilot을 위한 프로젝트 구성 -Agents are specialists you invoke on demand. **Project configuration files** are different: Copilot reads them automatically in every session to understand your project's conventions, tech stack, and rules. No one needs to run `/agent`; the context is always active for everyone working in the repo. +에이전트는 필요에 따라 호출하는 전문가입니다. **프로젝트 구성 파일**은 다릅니다. Copilot은 매 세션마다 프로젝트 구성 파일을 자동으로 읽어 프로젝트의 규칙, 기술 스택 및 규정을 파악합니다. 따라서 `/agent`를 실행할 필요가 없습니다. 저장소에서 작업하는 모든 사용자는 항상 활성화된 컨텍스트를 사용할 수 있습니다. -### Quick Setup with /init +### `/init`을 사용한 빠른 설정 -The fastest way to get started is to let Copilot generate configuration files for you: +가장 빠른 시작 방법은 Copilot이 구성 파일을 자동으로 생성하도록 하는 것입니다. ```bash copilot > /init ``` -Copilot will scan your project and create tailored instruction files. You can edit them afterwards. +Copilot은 프로젝트를 스캔하여 맞춤형 지침 파일을 생성합니다. 생성된 파일은 나중에 편집할 수 있습니다. -### Instruction File Formats - -| File | Scope | Notes | +### 지침 파일 형식 +| 파일 | 범위 | 참고 사항 | |------|-------|-------| -| `AGENTS.md` | Project root or nested | **Cross-platform standard** - works with Copilot and other AI assistants | -| `.github/copilot-instructions.md` | Project | GitHub Copilot specific | -| `.github/instructions/*.instructions.md` | Project | Granular, topic-specific instructions | -| `CLAUDE.md`, `GEMINI.md` | Project root | Supported for compatibility | +| `AGENTS.md` | 프로젝트 루트 또는 하위 폴더 | **크로스 플랫폼 표준** - Copilot 및 기타 AI 비서와 호환 | +| `.github/copilot-instructions.md` | 프로젝트 | GitHub Copilot 전용 | +| `.github/instructions/*.instructions.md` | 프로젝트 | 세부적이고 주제별 지침 | +| `CLAUDE.md`, `GEMINI.md` | 프로젝트 루트 | 호환성을 위해 지원 | -> 🎯 **Just getting started?** Use `AGENTS.md` for project instructions. You can explore the other formats later as needed. +> 🎯 **처음 시작하시나요?** 프로젝트 지침에는 `AGENTS.md`를 사용하세요. 필요에 따라 나중에 다른 형식을 살펴볼 수 있습니다. ### AGENTS.md -`AGENTS.md` is the recommended format. It's an [open standard](https://agents.md/) that works across Copilot and other AI coding tools. Place it in your repository root and Copilot reads it automatically. This project's own [AGENTS.md](../AGENTS.md) is a working example. +`AGENTS.md`는 권장되는 형식입니다. Copilot 및 기타 AI 코딩 도구에서 사용할 수 있는 [개방형 표준](https://agents.md/)입니다. 저장소 루트에 배치하면 Copilot이 자동으로 읽습니다. 이 프로젝트의 [AGENTS.md](../AGENTS.md)는 작동 예시입니다. -A typical `AGENTS.md` describes your project context, code style, security requirements, and testing standards. Use `/init` to generate one, or write your own following the pattern in our example file. +일반적인 `AGENTS.md` 파일에는 프로젝트 컨텍스트, 코드 스타일, 보안 요구 사항 및 테스트 표준이 설명되어 있습니다. `/init`을 사용하여 생성하거나, 예시 파일의 패턴을 따라 직접 작성할 수 있습니다. -### Custom Instruction Files (.instructions.md) +### 사용자 지정 지침 파일(.instructions.md) -For teams that want more granular control, split instructions into topic-specific files. Each file covers one concern and applies automatically: +더욱 세밀한 제어가 필요한 팀의 경우, 지침을 주제별 파일로 분리할 수 있습니다. 각 파일은 하나의 문제를 다루며 자동으로 적용됩니다. ``` .github/ @@ -444,13 +445,13 @@ For teams that want more granular control, split instructions into topic-specifi └── api-design.instructions.md ``` -> 💡 **Note**: Instruction files work with any language. This example uses Python to match our course project, but you can create similar files for TypeScript, Go, Rust, or any technology your team uses. +💡 **참고**: 명령어 파일은 모든 언어에서 작동합니다. 이 예제는 수업 프로젝트에 맞춰 Python을 사용하지만, TypeScript, Go, Rust 또는 팀에서 사용하는 다른 기술에 대해서도 유사한 파일을 만들 수 있습니다. -**Finding community instruction files**: Browse [github/awesome-copilot](https://github.com/github/awesome-copilot) for pre-made instruction files covering .NET, Angular, Azure, Python, Docker, and many more technologies. +**커뮤니티에서 제공하는 명령어 파일 찾기**: [github/awesome-copilot](https://github.com/github/awesome-copilot)에서 .NET, Angular, Azure, Python, Docker 등 다양한 기술을 다루는 미리 만들어진 명령어 파일을 찾아보세요. -### Disabling Custom Instructions +### 사용자 지정 명령어 비활성화 -If you need Copilot to ignore all project-specific configurations (useful for debugging or comparing behavior): +디버깅이나 동작 비교를 위해 Copilot이 프로젝트별 설정을 모두 무시하도록 하려면 다음과 같이 하세요. ```bash copilot --no-custom-instructions @@ -462,90 +463,90 @@ copilot --no-custom-instructions
-
---
-# Practice
+# 연습
-Agent File Reference - YAML properties, tool aliases, and complete examples
+에이전트 파일 참조 - YAML 속성, 도구 별칭 및 전체 예제
-## Agent File Reference +## 에이전트 파일 참조 -### A More Complete Example +### 보다 완벽한 예제 -You've seen the [minimal agent format](#-add-your-agents) above. Here's a more comprehensive agent that uses the `tools` property. Create `~/.copilot/agents/python-reviewer.agent.md`: +위에서 [최소 에이전트 형식](#-에이전트 추가)을 보셨습니다. 다음은 `tools` 속성을 사용하는 보다 포괄적인 에이전트입니다. `~/.copilot/agents/python-reviewer.agent.md` 파일을 생성하세요. ```markdown --- name: python-reviewer -description: Python code quality specialist for reviewing Python projects +description: 파이썬 프로젝트 검토를 담당하는 파이썬 코드 품질 전문가 tools: ["read", "edit", "search", "execute"] --- -# Python Code Reviewer +# 파이썬 코드 리뷰어 -You are a Python specialist focused on code quality and best practices. +당신은 코드 품질과 모범 사례에 중점을 두는 Python 전문가입니다. -**Your focus areas:** -- Code quality (PEP 8, type hints, docstrings) -- Performance optimization (list comprehensions, generators) -- Error handling (proper exception handling) -- Maintainability (DRY principles, clear naming) +**주요 관심 분야:** +- 코드 품질 (PEP 8, 타입 힌트, 독스트링) +- 성능 최적화 (리스트 컴프리헨션, 제너레이터) +- 오류 처리 (적절한 예외 처리) +- 유지보수성 (DRY 원칙, 명확한 네이밍) -**Code style requirements:** -- Use Python 3.10+ features (dataclasses, type hints, pattern matching) -- Follow PEP 8 naming conventions -- Use context managers for file I/O -- All functions must have type hints and docstrings +**코드 스타일 요구 사항:** +- Python 3.10 이상 기능 사용 (데이터 클래스, 타입 힌트, 패턴 매칭) +- PEP 8 네이밍 규칙 준수 +- 파일 I/O에 컨텍스트 관리자 사용 +- 모든 함수에 타입 힌트와 독스트링 포함 -**When reviewing code, always check:** -- Missing type hints on function signatures -- Mutable default arguments -- Proper error handling (no bare except) -- Input validation completeness +**코드 검토 시 항상 확인해야 할 사항:** +- 함수 시그니처에 타입 힌트 누락 여부 +- 변경 가능한 기본 인자 +- 적절한 오류 처리 (bare except 사용 금지) +- 입력 유효성 검사 완료 여부 ``` -### YAML Properties +### YAML 속성 -| Property | Required | Description | +| 속성 | 필수 | 설명 | |----------|----------|-------------| -| `name` | No | Display name (defaults to filename) | -| `description` | **Yes** | What the agent does - helps Copilot understand when to suggest it | -| `tools` | No | List of allowed tools (omit = all tools available). See tool aliases below. | -| `target` | No | Limit to `vscode` or `github-copilot` only | +| `name` | 아니요 | 표시 이름 (기본값은 파일 이름) | +| `description` | **예** | 에이전트의 기능 - Copilot이 에이전트를 제안해야 하는 시점을 파악하는 데 도움이 됩니다. | +| `tools` | 아니요 | 허용된 도구 목록 (생략 시 모든 도구 사용 가능). 아래 도구 별칭을 참조하세요. | +| `target` | 아니요 | `vscode` 또는 `github-copilot`으로만 제한 | -### Tool Aliases +### 도구 별칭 -Use these names in the `tools` list: -- `read` - Read file contents -- `edit` - Edit files -- `search` - Search files (grep/glob) -- `execute` - Run shell commands (also: `shell`, `Bash`) -- `agent` - Invoke other custom agents +`tools` 목록에서 다음 이름을 사용하세요. +- `read` - 파일 내용 읽기 +- `edit` - 파일 편집 +- `search` - 파일 검색(grep/glob) +- `execute` - 셸 명령 실행(`shell`, `Bash`도 사용) +- `agent` - 다른 사용자 지정 에이전트 호출 -> 📖 **Official docs**: [Custom agents configuration](https://docs.github.com/copilot/reference/custom-agents-configuration) +> 📖 **공식 문서**: [사용자 지정 에이전트 구성](https://docs.github.com/copilot/reference/custom-agents-configuration) > -> ⚠️ **VS Code Only**: The `model` property (for selecting AI models) works in VS Code but is not supported in GitHub Copilot CLI. You can safely include it for cross-platform agent files. GitHub Copilot CLI will ignore it. +> ⚠️ **VS Code 전용**: `model` 속성(AI 모델 선택용)은 VS Code에서는 작동하지만 GitHub Copilot CLI에서는 지원되지 않습니다. 크로스 플랫폼 에이전트 파일에는 안전하게 포함할 수 있지만 GitHub Copilot CLI는 이를 무시합니다. -### More Agent Templates +### 추가 에이전트 템플릿 -> 💡 **Note for beginners**: The examples below are templates. **Replace the specific technologies with whatever your project uses.** The important thing is the *structure* of the agent, not the specific technologies mentioned. +> 💡 **초보자 참고**: 아래 예시는 템플릿입니다. **구체적인 기술은 프로젝트에서 사용하는 기술로 대체하세요.** 중요한 것은 에이전트의 *구조*이지, 언급된 특정 기술이 아닙니다. -This project includes working examples in the [.github/agents/](../.github/agents/) folder: -- [hello-world.agent.md](../.github/agents/hello-world.agent.md) - Minimal example, start here -- [python-reviewer.agent.md](../.github/agents/python-reviewer.agent.md) - Python code quality reviewer -- [pytest-helper.agent.md](../.github/agents/pytest-helper.agent.md) - Pytest testing specialist +이 프로젝트에는 [.github/agents/](../.github/agents/) 폴더에 다음과 같은 작동 예제가 포함되어 있습니다. +- [hello-world.agent.md](../.github/agents/hello-world.agent.md) - 최소 예제, 여기서 시작하세요. +- [python-reviewer.agent.md](../.github/agents/python-reviewer.agent.md) - Python 코드 품질 검토자 +- [pytest-helper.agent.md](../.github/agents/pytest-helper.agent.md) - Pytest 테스트 전문가 -For community agents, see [github/awesome-copilot](https://github.com/github/awesome-copilot). +커뮤니티 에이전트는 [github/awesome-copilot](https://github.com/github/awesome-copilot)을 참조하세요.
+
-Create your own agents and see them in action.
+나만의 에이전트를 만들고 실제로 작동하는 모습을 확인해 보세요.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 시도해 보세요
```bash
@@ -605,27 +606,33 @@ copilot
---
-## 📝 Assignment
+## 📝 과제
+
+### 주요 과제: 전문 에이전트 팀 구축
+
+실습 예제에서는 `검토자` 및 `문서 작성자` 에이전트를 생성했습니다. 이제 다른 작업을 위해 에이전트를 만들고 사용하는 연습을 해보세요. 바로 도서 앱의 데이터 유효성 검사를 개선하는 것입니다.
+
+1. 도서 앱에 맞게 에이전트 파일 3개(각 에이전트당 1개씩, 총 3개)를 생성하여 `.github/agents/` 폴더에 배치합니다.
+2. 에이전트:
+
+- **데이터 유효성 검사기**: `data.json` 파일에서 누락되거나 형식이 잘못된 데이터(저자 필드가 비어 있거나, 연도가 0이거나, 필드가 누락된 경우 등)를 검사합니다.
+
+- **오류 처리기**: 일관성 없는 오류 처리를 보이는 Python 코드를 검토하고 통일된 접근 방식을 제안합니다.
+
+- **문서 작성기**: 문서 문자열과 README 파일 내용을 생성하거나 업데이트합니다.
+3. 도서 앱에서 각 에이전트를 사용합니다.
-### Main Challenge: Build a Specialized Agent Team
+- `데이터 유효성 검사기` → `@samples/book-app-project/data.json` 파일 감사
-The hands-on example created `reviewer` and `documentor` agents. Now practice creating and using agents for a different task - improving data validation in the book app:
+- `오류 처리기` → `@samples/book-app-project/books.py` 및 `@samples/book-app-project/utils.py` 파일 검토
-1. Create 3 agent files (`.agent.md`) tailored to the book app, one per agent, placed in `.github/agents/`
-2. Your agents:
- - **data-validator**: checks `data.json` for missing or malformed data (empty authors, year=0, missing fields)
- - **error-handler**: reviews Python code for inconsistent error handling and suggests a unified approach
- - **doc-writer**: generates or updates docstrings and README content
-3. Use each agent on the book app:
- - `data-validator` → audit `@samples/book-app-project/data.json`
- - `error-handler` → review `@samples/book-app-project/books.py` and `@samples/book-app-project/utils.py`
- - `doc-writer` → add docstrings to `@samples/book-app-project/books.py`
-4. Collaborate: use `error-handler` to identify error-handling gaps, then `doc-writer` to document the improved approach
+- `문서 작성기` → 문서 문자열 추가 `@samples/book-app-project/books.py`
+4. 협업: `error-handler`를 사용하여 오류 처리의 부족한 부분을 파악한 다음, `doc-writer`를 사용하여 개선된 접근 방식을 문서화합니다.
-**Success criteria**: You have 3 working agents that produce consistent, high-quality output and you can switch between them with `/agent`.
+**성공 기준**: 일관되고 고품질의 출력을 생성하는 3개의 에이전트가 있으며, `/agent`를 사용하여 에이전트 간에 전환할 수 있습니다.
-
-### Bonus Challenge: Instruction Library
+### 보너스 과제: 명령어 라이브러리
-You've built agents you invoke on demand. Now try the other side: **instruction files** that Copilot reads automatically in every session, no `/agent` needed.
+이미 필요에 따라 호출하는 에이전트를 구축했습니다. 이제 그 반대, 즉 Copilot이 매 세션마다 자동으로 읽는 **명령어 파일**을 만들어 보세요. `/agent` 명령어는 필요하지 않습니다.
-Create a `.github/instructions/` folder with at least 3 instruction files:
-- `python-style.instructions.md` for enforcing PEP 8 and type hint conventions
-- `test-standards.instructions.md` for enforcing pytest conventions in test files
-- `data-quality.instructions.md` for validating JSON data entries
+`.github/instructions/` 폴더에 다음 명령어 파일을 최소 3개 이상 생성하세요.
+- `python-style.instructions.md`: PEP 8 및 타입 힌트 규칙 준수
+- `test-standards.instructions.md`: 테스트 파일에서 pytest 규칙 준수
+- `data-quality.instructions.md`: JSON 데이터 항목 유효성 검사
-Test each instruction file on the book app code.
+각 명령어 파일을 도서 앱 코드에 적용하여 테스트하세요.
---
💡 Hints (click to expand)
+💡 힌트 (클릭하여 펼치기)
**Starter templates**: create one file per agent in `.github/agents/`: @@ -690,21 +697,21 @@ copilot
-
+범용 드릴은 유용하지만, 특수한 부착물(비트/어댑터)을 끼우면 훨씬 강력해집니다.
+
-Skills work the same way. Just like swapping drill bits for different jobs, you can add skills to Copilot for different tasks:
+스킬도 같은 방식으로 동작합니다. 드릴 비트를 작업에 맞게 바꾸듯, Copilot에 다양한 작업용 스킬을 추가할 수 있습니다.
-| Skill Attachment | Purpose |
-|------------|---------|
-| `commit` | Generate consistent commit messages |
-| `security-audit` | Check for OWASP vulnerabilities |
-| `generate-tests` | Create comprehensive pytest tests |
-| `code-checklist` | Apply team code quality standards |
+| 스킬 부착물 | 목적 |
+|------------|------|
+| `commit` | 일관된 커밋 메시지 생성 |
+| `security-audit` | OWASP 취약점 점검 |
+| `generate-tests` | 포괄적인 pytest 테스트 생성 |
+| `code-checklist` | 팀 코드 품질 표준 적용 |
-
-*Skills are specialized attachments that extend what Copilot can do*
+*스킬은 Copilot이 할 수 있는 일을 확장하는 특수 부착물입니다*
---
-# How Skills Work
+# 스킬은 어떻게 동작하나요?
-
+
-Learn what skills are, why they matter, and how they differ from agents and MCP.
+스킬이 무엇인지, 왜 중요한지, 그리고 에이전트 및 MCP와 어떻게 다른지 알아봅니다.
---
-## *New to Skills?* Start Here!
+## *스킬이 처음이라면?* 여기서 시작하세요!
-1. **See what skills are already available:**
+1. **이미 어떤 스킬이 있는지 확인하기:**
```bash
copilot
> /skills list
```
- This shows all skills Copilot can find in your project and personal folders.
+ 이 명령은 Copilot이 프로젝트 폴더와 개인 폴더에서 찾을 수 있는 모든 스킬을 보여줍니다.
-2. **Look at a real skill file:** Check out our provided [code-checklist SKILL.md](../.github/skills/code-checklist/SKILL.md) to see the pattern. It's just YAML frontmatter plus markdown instructions.
+2. **실제 스킬 파일 보기:** 제공된 [code-checklist SKILL.md](../.github/skills/code-checklist/SKILL.md)를 확인해 패턴을 보세요. YAML 프런트매터 + 마크다운 지침으로 구성됩니다.
-3. **Understand the core concept:** Skills are task-specific instructions that Copilot loads *automatically* when your prompt matches the skill's description. You don't need to activate them, just ask naturally.
+3. **핵심 개념 이해하기:** 스킬은 프롬프트가 스킬의 `description`과 매칭될 때 Copilot이 *자동으로 로드하는* 작업별 지침입니다. 매번 활성화할 필요 없이 자연스럽게 질문하면 됩니다.
-## Understanding Skills
+## 스킬 이해하기
-Agent Skills are folders containing instructions, scripts, and resources that Copilot **automatically loads when relevant** to your task. Copilot reads your prompt, checks if any skills match, and applies the relevant instructions automatically.
+에이전트 스킬은 지침, 스크립트, 리소스를 담고 있는 폴더로, Copilot이 **작업과 관련 있다고 판단하면 자동으로 로드**합니다. Copilot은 프롬프트를 읽고, 매칭되는 스킬이 있는지 확인한 뒤, 관련 지침을 자동으로 적용합니다.
```bash
copilot
> Check books.py against our quality checklist
-# Copilot detects this matches your "code-checklist" skill
-# and automatically applies its Python quality checklist
+# Copilot이 이것이 "code-checklist" 스킬과 매칭된다고 판단하고
+# 해당 파이썬 품질 체크리스트를 자동으로 적용
> Generate tests for the BookCollection class
-# Copilot loads your "pytest-gen" skill
-# and applies your preferred test structure
+# Copilot이 "pytest-gen" 스킬을 로드하고
+# 선호하는 테스트 구조를 적용
> What are the code quality issues in this file?
-# Copilot loads your "code-checklist" skill
-# and checks against your team's standards
+# Copilot이 "code-checklist" 스킬을 로드하고
+# 팀 표준에 따라 점검
```
-> 💡 **Key Insight**: Skills are **automatically triggered** based on your prompt matching the skill's description. Just ask naturally and Copilot applies relevant skills behind the scenes. You can also invoke skills directly as well which you'll learn about next.
+> 💡 **핵심 인사이트**: 스킬은 프롬프트가 스킬의 설명과 매칭되면 **자동으로 트리거**됩니다. 자연스럽게 요청하면 Copilot이 뒤에서 관련 스킬을 적용합니다. 다음에는 스킬을 직접 호출하는 방법도 배웁니다.
-> 🧰 **Ready-to-use templates**: Check out the [.github/skills](../.github/skills/) folder for simple copy-paste skills you can try out.
+> 🧰 **바로 쓸 수 있는 템플릿**: 간단히 복사/붙여넣기 해서 사용해볼 수 있는 스킬이 [.github/skills](../.github/skills/) 폴더에 있습니다.
-### Direct Slash Command Invocation
+### 슬래시 명령으로 직접 호출하기
-While auto-triggering is the primary way skills work, you can also **invoke skills directly** using their name as a slash command:
+자동 트리거가 스킬의 기본 동작 방식이지만, **스킬 이름을 슬래시 명령으로 직접 호출**할 수도 있습니다.
```bash
-> /generate-tests Create tests for the user authentication module
+> /generate-tests 사용자 인증 모듈에 대한 테스트를 만들어줘
-> /code-checklist Check books.py for code quality issues
+> /code-checklist books.py에서 코드 품질 문제를 확인해줘
-> /security-audit Check the API endpoints for vulnerabilities
+> /security-audit API 엔드포인트의 취약점을 점검해줘
```
-This gives you explicit control when you want to ensure a specific skill is used.
+특정 스킬이 반드시 사용되길 원할 때, 이렇게 명시적으로 제어할 수 있습니다.
-> 📝 **Skills vs Agents Invocation**: Don't confuse skill invocation with agent invocation:
-> - **Skills**: `/skill-name `, e.g., `/code-checklist Check this file`
-> - **Agents**: `/agent` (select from list) or `copilot --agent ` (command line)
+> 📝 **스킬 호출 vs 에이전트 호출**: 스킬 호출과 에이전트 호출을 혼동하지 마세요.
+> - **스킬**: `/skill-name ` 예: `/code-checklist Check this file`
+> - **에이전트**: `/agent`(목록에서 선택) 또는 `copilot --agent `(CLI)
>
-> If you have both a skill and an agent with the same name (e.g., "code-reviewer"), typing `/code-reviewer` invokes the **skill**, not the agent.
+> 스킬과 에이전트가 같은 이름(예: `code-reviewer`)을 공유한다면, `/code-reviewer`는 **에이전트가 아니라 스킬**을 호출합니다.
-### How Do I Know a Skill Was Used?
+### 스킬이 사용됐는지 어떻게 알 수 있나요?
-You can ask Copilot directly:
+Copilot에게 직접 물어볼 수 있습니다.
```bash
> What skills did you use for that response?
@@ -115,42 +114,42 @@ You can ask Copilot directly:
> What skills do you have available for security reviews?
```
-### Skills vs Agents vs MCP
+### 스킬 vs 에이전트 vs MCP
-Skills are just one piece of GitHub Copilot's extensibility model. Here's how they compare to agents and MCP servers.
+스킬은 GitHub Copilot 확장성 모델의 한 부분입니다. 에이전트와 MCP 서버와 비교하면 다음과 같습니다.
-> *Don't worry about MCP quite yet. We'll cover it in [Chapter 06](../06-mcp-servers/). It's included here so you can see how skills fit into the overall picture.*
+> *MCP는 아직 걱정하지 않아도 됩니다. [챕터 06](../06-mcp-servers/)에서 다룹니다. 여기서는 스킬이 전체 그림에서 어디에 위치하는지 보기 위해 포함했습니다.*
-
+
-| Feature | What It Does | When to Use |
-|---------|--------------|-------------|
-| **Agents** | Changes how AI thinks | Need specialized expertise across many tasks |
-| **Skills** | Provides task-specific instructions | Specific, repeatable tasks with detailed steps |
-| **MCP** | Connects external services | Need live data from APIs |
+| 기능 | 무엇을 하나요 | 언제 쓰나요 |
+|------|---------------|------------|
+| **에이전트(Agents)** | AI가 생각하는 방식을 바꿈 | 다양한 작업 전반에 걸친 전문성이 필요할 때 |
+| **스킬(Skills)** | 작업별 구체 지침 제공 | 반복 가능한 특정 작업에 대한 상세한 절차가 필요할 때 |
+| **MCP** | 외부 서비스 연결 | API에서 실시간 데이터가 필요할 때 |
-Use agents for broad expertise, skills for specific task instructions, and MCP for external data. An agent can use one or more skills during a conversation. For example, when you ask an agent to check your code, it might apply both a `security-audit` skill and a `code-checklist` skill automatically.
+광범위한 전문성은 에이전트, 구체적인 작업 지침은 스킬, 외부 데이터는 MCP가 담당합니다. 에이전트는 대화 중 하나 이상의 스킬을 함께 사용할 수 있습니다. 예를 들어 코드를 점검해달라고 요청하면, `security-audit` 스킬과 `code-checklist` 스킬을 모두 자동으로 적용할 수 있습니다.
-> 📚 **Learn More**: See the official [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills) documentation for the complete reference on skill formats and best practices.
+> 📚 **더 알아보기**: 스킬 포맷과 모범 사례의 전체 참조는 공식 문서 [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)를 참고하세요.
---
-## From Manual Prompts to Automatic Expertise
+## 수동 프롬프트에서 자동 전문성으로
-Before diving into how to create skills, let's see *why* they're worth learning. Once you see the consistency gains, the "how" will make more sense.
+스킬을 만드는 방법을 배우기 전에, *왜* 스킬이 가치 있는지 먼저 보겠습니다. 일관성 향상을 체감하면 “방법”이 더 쉽게 이해됩니다.
-### Before Skills: Inconsistent Reviews
+### 스킬 이전: 들쑥날쑥한 리뷰
-Every code review, you might forget something:
+코드 리뷰를 할 때마다 무언가를 놓치기 쉽습니다.
```bash
copilot
> Review this code for issues
-# Generic review - might miss your team's specific concerns
+# 일반적인 리뷰 - 팀의 구체적인 관심사를 놓칠 수 있음
```
-Or you write a long prompt every time:
+혹은 매번 긴 프롬프트를 작성합니다.
```bash
> Review this code checking for bare except clauses, missing type hints,
@@ -158,11 +157,11 @@ Or you write a long prompt every time:
> functions over 50 lines, print statements in production code...
```
-Time: **30+ seconds** to type. Consistency: **varies by memory**.
+시간: 타이핑 **30초+**. 일관성: **기억에 따라 들쑥날쑥**.
-### After Skills: Automatic Best Practices
+### 스킬 이후: 모범 사례 자동 적용
-With a `code-checklist` skill installed, just ask naturally:
+`code-checklist` 스킬이 설치되어 있다면, 자연스럽게 이렇게만 요청하면 됩니다.
```bash
copilot
@@ -170,58 +169,58 @@ copilot
> Check the book collection code for quality issues
```
-**What happens behind the scenes**:
-1. Copilot sees "code quality" and "issues" in your prompt
-2. Checks skill descriptions, finds your `code-checklist` skill matches
-3. Automatically loads your team's quality checklist
-4. Applies all checks without you listing them
+**뒤에서 일어나는 일**:
+1. Copilot이 프롬프트에서 "code quality"와 "issues" 같은 키워드를 감지
+2. 스킬 설명을 확인하고 `code-checklist` 스킬이 매칭됨을 발견
+3. 팀의 품질 체크리스트를 자동 로드
+4. 목록을 직접 나열하지 않아도 모든 점검 항목을 적용
-
+
-*Just ask naturally. Copilot matches your prompt to the right skill and applies it automatically.*
+*자연스럽게 질문하기만 하면 됩니다. Copilot이 프롬프트를 적절한 스킬과 매칭해 자동으로 적용합니다.*
-**Output**:
+**출력 예시**:
```
-## Code Checklist: books.py
-
-### Code Quality
-- [PASS] All functions have type hints
-- [PASS] No bare except clauses
-- [PASS] No mutable default arguments
-- [PASS] Context managers used for file I/O
-- [PASS] Functions are under 50 lines
-- [PASS] Variable and function names follow PEP 8
-
-### Input Validation
-- [FAIL] User input is not validated - add_book() accepts any year value
-- [FAIL] Edge cases not fully handled - empty strings accepted for title/author
-- [PASS] Error messages are clear and helpful
-
-### Testing
-- [FAIL] No corresponding pytest tests found
-
-### Summary
-3 items need attention before merge
+## 코드 체크리스트: books.py
+
+### 코드 품질
+- [PASS] 모든 함수에 타입 힌트가 있음
+- [PASS] bare except 절이 없음
+- [PASS] mutable 기본 인자가 없음
+- [PASS] 파일 I/O에 컨텍스트 매니저 사용
+- [PASS] 함수가 50줄 이하
+- [PASS] 변수/함수 이름이 PEP 8을 따름
+
+### 입력 검증
+- [FAIL] 사용자 입력이 검증되지 않음 - add_book()이 어떤 연도 값이든 받음
+- [FAIL] 엣지 케이스가 완전히 처리되지 않음 - 제목/저자에 빈 문자열 허용
+- [PASS] 오류 메시지가 명확하고 도움이 됨
+
+### 테스트
+- [FAIL] 해당 pytest 테스트가 없음
+
+### 요약
+병합 전에 3개 항목을 수정해야 함
```
-**The difference**: Your team's standards are applied automatically, every time, without typing them out.
+**차이점**: 팀의 표준이 매번, 자동으로, 프롬프트를 길게 쓰지 않아도 적용됩니다.
---
+
-Build your own skills from SKILL.md files.
+`SKILL.md` 파일로 스킬을 직접 만들어봅니다.
---
-## Skill Locations
+## 스킬 위치
-Skills are stored in `.github/skills/` (project-specific) or `~/.copilot/skills/` (user level).
+스킬은 `.github/skills/`(프로젝트 단위) 또는 `~/.copilot/skills/`(사용자 단위)에 저장됩니다.
-### How Copilot Finds Skills
+### Copilot이 스킬을 찾는 방법
-Copilot automatically scans these locations for skills:
+Copilot은 다음 위치를 자동으로 스캔해 스킬을 찾습니다.
-| Location | Scope |
-|----------|-------|
-| `.github/skills/` | Project-specific (shared with team via git) |
-| `~/.copilot/skills/` | User-specific (your personal skills) |
+| 위치 | 범위 |
+|------|------|
+| `.github/skills/` | 프로젝트 단위(깃으로 팀과 공유) |
+| `~/.copilot/skills/` | 사용자 단위(개인 스킬) |
-### Skill Structure
+### 스킬 구조
-Each skill lives in its own folder with a `SKILL.md` file. You can optionally include scripts, examples, or other resources:
+각 스킬은 `SKILL.md` 파일이 들어 있는 독립 폴더에 위치합니다. 선택적으로 스크립트/예제/리소스도 포함할 수 있습니다.
```
.github/skills/
└── my-skill/
- ├── SKILL.md # Required: Skill definition and instructions
- ├── examples/ # Optional: Example files Copilot can reference
+ ├── SKILL.md # 필수: 스킬 정의 및 지침
+ ├── examples/ # 선택: Copilot이 참고할 예제 파일
│ └── sample.py
- └── scripts/ # Optional: Scripts the skill can use
+ └── scripts/ # 선택: 스킬에서 사용할 스크립트
└── validate.sh
```
-> 💡 **Tip**: The directory name should match the `name` in your SKILL.md frontmatter (lowercase with hyphens).
+> 💡 **팁**: 디렉터리 이름은 `SKILL.md`의 `name` 값(하이픈 사용 소문자)과 일치하는 것이 좋습니다.
-### SKILL.md Format
+### SKILL.md 형식
-Skills use a simple markdown format with YAML frontmatter:
+스킬은 YAML 프런트매터가 있는 간단한 마크다운 형식을 사용합니다.
```markdown
---
name: code-checklist
-description: Comprehensive code quality checklist with security, performance, and maintainability checks
+description: 보안, 성능, 유지보수성 점검을 포함한 포괄적인 코드 품질 체크리스트
license: MIT
---
-# Code Checklist
+# 코드 체크리스트
-When checking code, look for:
+코드를 점검할 때 다음을 확인합니다.
-## Security
-- SQL injection vulnerabilities
-- XSS vulnerabilities
-- Authentication/authorization issues
-- Sensitive data exposure
+## 보안
+- SQL 인젝션 취약점
+- XSS 취약점
+- 인증/인가 이슈
+- 민감 데이터 노출
-## Performance
-- N+1 query problems (running one query per item instead of one query for all items)
-- Unnecessary loops or computations
-- Memory leaks
-- Blocking operations
+## 성능
+- N+1 쿼리 문제(항목마다 쿼리 1개가 아니라 전체를 위한 쿼리 1개를 쓰지 않는 경우)
+- 불필요한 루프/계산
+- 메모리 누수
+- 블로킹 작업
-## Maintainability
-- Function length (flag functions > 50 lines)
-- Code duplication
-- Missing error handling
-- Unclear naming
+## 유지보수성
+- 함수 길이(50줄 초과 함수 플래그)
+- 코드 중복
+- 에러 처리 누락
+- 불명확한 네이밍
-## Output Format
-Provide issues as a numbered list with severity:
-- [CRITICAL] - Must fix before merge
-- [HIGH] - Should fix before merge
-- [MEDIUM] - Should address soon
-- [LOW] - Nice to have
+## 출력 형식
+심각도와 함께 번호 매긴 목록으로 이슈를 제공합니다.
+- [CRITICAL] - 병합 전 반드시 수정
+- [HIGH] - 병합 전 수정 권장
+- [MEDIUM] - 곧 처리 필요
+- [LOW] - 있으면 좋은 개선
```
-**YAML Properties:**
+**YAML 속성:**
-| Property | Required | Description |
-|----------|----------|-------------|
-| `name` | **Yes** | Unique identifier (lowercase, hyphens for spaces) |
-| `description` | **Yes** | What the skill does and when Copilot should use it |
-| `license` | No | License that applies to this skill |
+| 속성 | 필수 | 설명 |
+|------|------|------|
+| `name` | **예** | 고유 식별자(소문자, 공백 대신 하이픈) |
+| `description` | **예** | 스킬이 무엇을 하는지, 언제 로드되어야 하는지 |
+| `license` | 아니오 | 이 스킬에 적용되는 라이선스 |
-> 📖 **Official docs**: [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)
+> 📖 **공식 문서**: [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)
-### Creating Your First Skill
+### 첫 스킬 만들기
-Let's build a security audit skill that checks for OWASP Top 10 vulnerabilities:
+OWASP Top 10 취약점을 점검하는 보안 감사 스킬을 만들어봅시다.
```bash
-# Create skill directory
+# 스킬 디렉터리 생성
mkdir -p .github/skills/security-audit
-# Create the SKILL.md file
+# SKILL.md 파일 생성
cat > .github/skills/security-audit/SKILL.md << 'EOF'
---
name: security-audit
-description: Security-focused code review checking OWASP (Open Web Application Security Project) Top 10 vulnerabilities
+description: OWASP(오픈 웹 애플리케이션 보안 프로젝트) Top 10 취약점을 점검하는 보안 중심 코드 리뷰
---
# Security Audit
-Perform a security audit checking for:
-
-## Injection Vulnerabilities
-- SQL injection (string concatenation in queries)
-- Command injection (unsanitized shell commands)
-- LDAP injection
-- XPath injection
-
-## Authentication Issues
-- Hardcoded credentials
-- Weak password requirements
-- Missing rate limiting
-- Session management flaws
-
-## Sensitive Data
-- Plaintext passwords
-- API keys in code
-- Logging sensitive information
-- Missing encryption
-
-## Access Control
-- Missing authorization checks
-- Insecure direct object references
-- Path traversal vulnerabilities
-
-## Output
-For each issue found, provide:
-1. File and line number
-2. Vulnerability type
-3. Severity (CRITICAL/HIGH/MEDIUM/LOW)
-4. Recommended fix
+다음을 확인하는 보안 감사를 수행합니다.
+
+## 인젝션 취약점
+- SQL 인젝션(쿼리에 문자열을 이어붙이는 경우)
+- 커맨드 인젝션(정제되지 않은 쉘 명령)
+- LDAP 인젝션
+- XPath 인젝션
+
+## 인증 이슈
+- 하드코딩된 자격 증명
+- 약한 비밀번호 요구사항
+- 레이트 리밋 미설정
+- 세션 관리 결함
+
+## 민감 데이터
+- 평문 비밀번호
+- 코드 내 API 키
+- 민감 정보를 로깅
+- 암호화 누락
+
+## 접근 제어
+- 인가 체크 누락
+- IDOR(불안전한 직접 객체 참조)
+- 경로 순회 취약점
+
+## 출력
+발견한 각 이슈에 대해 다음을 제공합니다.
+1. 파일과 라인 번호
+2. 취약점 유형
+3. 심각도(CRITICAL/HIGH/MEDIUM/LOW)
+4. 권장 수정 방법
EOF
-# Test your skill (skills load automatically based on your prompt)
+# 스킬 테스트(스킬은 프롬프트에 따라 자동으로 로드됨)
copilot
> @samples/book-app-project/ Check this code for security vulnerabilities
-# Copilot detects "security vulnerabilities" matches your skill
-# and automatically applies its OWASP checklist
+# Copilot이 "security vulnerabilities"가 스킬과 매칭된다고 판단하고
+# OWASP 체크리스트를 자동 적용
```
-**Expected output** (your results will vary):
-
+**예상 출력**(결과는 달라질 수 있음):
```
Security Audit: book-app-project
-[HIGH] Hardcoded file path (book_app.py, line 12)
- File path is hardcoded rather than configurable
- Fix: Use environment variable or config file
+[HIGH] 하드코딩된 파일 경로 (book_app.py, 12행)
+ 파일 경로가 설정 가능하지 않고 하드코딩되어 있음
+ 수정: 환경 변수 또는 설정 파일 사용
-[MEDIUM] No input validation (book_app.py, line 34)
- User input passed directly to function without sanitization
- Fix: Add input validation before processing
+[MEDIUM] 입력 검증 없음 (book_app.py, 34행)
+ 사용자 입력이 정제 없이 함수로 전달됨
+ 수정: 처리 전에 입력 검증 추가
-✅ No SQL injection found
-✅ No hardcoded credentials found
+✅ SQL 인젝션 없음
+✅ 하드코딩된 자격 증명 없음
```
---
-## Writing Good Skill Descriptions
+## 좋은 스킬 설명 작성하기
-The `description` field in your SKILL.md is crucial! It's how Copilot decides whether to load your skill:
+`SKILL.md`의 `description` 필드는 매우 중요합니다. Copilot이 스킬을 로드할지 결정하는 기준이기 때문입니다.
```markdown
---
name: security-audit
-description: Use for security reviews, vulnerability scanning,
- checking for SQL injection, XSS, authentication issues,
- OWASP Top 10 vulnerabilities, and security best practices
+description: 보안 리뷰, 취약점 스캐닝, SQL 인젝션, XSS, 인증 이슈,
+ OWASP Top 10 취약점을 점검하는 보안 모범 사례 점검에 사용
---
```
-> 💡 **Tip**: Include keywords that match how you naturally ask questions. If you say "security review," include "security review" in the description.
+> 💡 **팁**: 평소 질문할 때 쓰는 키워드를 설명에 넣으세요. "security review"라고 자주 말한다면 `description`에도 "security review"를 넣는 식입니다.
-### Combining Skills with Agents
+### 에이전트와 스킬 결합하기
-Skills and agents work together. The agent provides expertise, the skill provides specific instructions:
+스킬과 에이전트는 함께 작동합니다. 에이전트는 전문성을 제공하고, 스킬은 구체적인 지침을 제공합니다.
```bash
-# Start with a code-reviewer agent
+# code-reviewer 에이전트로 시작
copilot --agent code-reviewer
> Check the book app for quality issues
-# code-reviewer agent's expertise combines
-# with your code-checklist skill's checklist
+# code-reviewer 에이전트의 전문성과
+# code-checklist 스킬의 체크리스트가 결합
```
---
-# Managing and Sharing Skills
+# 스킬 관리 및 공유
-Discover installed skills, find community skills, and share your own.
+설치된 스킬을 확인하고, 커뮤니티 스킬을 찾고, 직접 공유하는 방법을 알아봅니다.
-
+
---
-## Managing Skills with the `/skills` Command
+## `/skills` 명령으로 스킬 관리하기
-Use the `/skills` command to manage your installed skills:
+`/skills` 명령을 사용해 설치된 스킬을 관리할 수 있습니다.
-| Command | What It Does |
-|---------|--------------|
-| `/skills list` | Show all installed skills |
-| `/skills info ` | Get details about a specific skill |
-| `/skills add ` | Enable a skill (from a repository or marketplace) |
-| `/skills remove ` | Disable or uninstall a skill |
-| `/skills reload` | Reload skills after editing SKILL.md files |
+| 명령 | 하는 일 |
+|------|---------|
+| `/skills list` | 설치된 모든 스킬 표시 |
+| `/skills info ` | 특정 스킬 상세 정보 보기 |
+| `/skills add ` | 스킬 활성화(저장소/마켓플레이스에서) |
+| `/skills remove ` | 스킬 비활성화 또는 제거 |
+| `/skills reload` | `SKILL.md` 수정 후 스킬 다시 로드 |
-> 💡 **Remember**: You don't need to "activate" skills for each prompt. Once installed, skills are **automatically triggered** when your prompt matches their description. These commands are for managing which skills are available, not for using them.
+> 💡 **기억하세요**: 매 프롬프트마다 스킬을 "활성화"할 필요는 없습니다. 설치만 되어 있으면 프롬프트가 설명과 매칭될 때 **자동으로 트리거**됩니다. 이 명령들은 스킬을 사용하는 것이 아니라, *어떤 스킬을 사용할 수 있게 할지*를 관리하기 위한 것입니다.
-### Example: View Your Skills
+### 예시: 내 스킬 보기
```bash
copilot
@@ -498,96 +495,96 @@ Description: Security-focused code review checking OWASP Top 10 vulnerabilities
---
-# Install a plugin from the marketplace
+# 마켓플레이스에서 플러그인 설치
```
-Plugins can bundle multiple capabilities together - a single plugin might include related skills, agents, and MCP server configurations that work together.
+플러그인은 여러 기능을 묶을 수 있습니다. 하나의 플러그인이 관련 스킬/에이전트/MCP 서버 설정을 함께 포함할 수도 있습니다.
-### Community Skill Repositories
+### 커뮤니티 스킬 저장소
-Pre-made skills are also available from community repositories:
+미리 만들어진 스킬은 커뮤니티 저장소에서도 찾을 수 있습니다.
-- **[Awesome Copilot](https://github.com/github/awesome-copilot)** - Official GitHub Copilot resources including skills documentation and examples
+- **[Awesome Copilot](https://github.com/github/awesome-copilot)** - 스킬 문서 및 예시를 포함한 공식 GitHub Copilot 리소스
-### Installing a Community Skill Manually
+### 커뮤니티 스킬을 수동으로 설치하기
-If you find a skill in a GitHub repository, copy its folder into your skills directory:
+GitHub 저장소에서 스킬을 찾았다면, 해당 폴더를 스킬 디렉터리로 복사하면 됩니다.
```bash
-# Clone the awesome-copilot repository
+# awesome-copilot 저장소 클론
git clone https://github.com/github/awesome-copilot.git /tmp/awesome-copilot
-# Copy a specific skill to your project
+# 특정 스킬을 프로젝트에 복사
cp -r /tmp/awesome-copilot/skills/code-checklist .github/skills/
-# Or for personal use across all projects
+# 또는 모든 프로젝트에 공통으로 쓰는 개인 스킬로 복사
cp -r /tmp/awesome-copilot/skills/code-checklist ~/.copilot/skills/
```
-> ⚠️ **Review before installing**: Always read a skill's `SKILL.md` before copying it into your project. Skills control what Copilot does, and a malicious skill could instruct it to run harmful commands or modify code in unexpected ways.
+> ⚠️ **설치 전 검토**: 스킬을 복사하기 전에 반드시 `SKILL.md`를 읽어보세요. 스킬은 Copilot의 동작을 제어하며, 악성 스킬은 유해한 명령 실행이나 예상치 못한 코드 변경을 지시할 수 있습니다.
---
-# Practice
+# 실습
-
+
-Apply what you've learned by building and testing your own skills.
+배운 내용을 바탕으로 스킬을 직접 만들고 테스트해봅니다.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 해보기
-### Build More Skills
+### 더 많은 스킬 만들기
-Here are two more skills showing different patterns. Follow the same `mkdir` + `cat` workflow from "Creating Your First Skill" above or copy and paste the skills into the proper location. More examples are available in [.github/skills](../.github/skills).
+아래 두 스킬은 서로 다른 패턴을 보여줍니다. 앞서 "첫 스킬 만들기"에서 했던 `mkdir` + `cat` 워크플로를 그대로 따라 하거나, 스킬을 적절한 위치에 복사/붙여넣기 하세요. 더 많은 예시는 [.github/skills](../.github/skills)에 있습니다.
-### pytest Test Generation Skill
+### pytest 테스트 생성 스킬
-A skill that ensures consistent pytest structure across your codebase:
+코드베이스 전반에서 일관된 pytest 구조를 보장하는 스킬입니다.
```bash
mkdir -p .github/skills/pytest-gen
@@ -595,38 +592,38 @@ mkdir -p .github/skills/pytest-gen
cat > .github/skills/pytest-gen/SKILL.md << 'EOF'
---
name: pytest-gen
-description: Generate comprehensive pytest tests with fixtures and edge cases
+description: 픽스처와 엣지 케이스를 포함한 포괄적인 pytest 테스트를 생성
---
-# pytest Test Generation
+# pytest 테스트 생성
-Generate pytest tests that include:
+다음을 포함하는 pytest 테스트를 생성합니다.
-## Test Structure
-- Use pytest conventions (test_ prefix)
-- One assertion per test when possible
-- Clear test names describing expected behavior
-- Use fixtures for setup/teardown
+## 테스트 구조
+- pytest 규칙 사용(test_ 접두사)
+- 가능하면 테스트당 assertion 1개
+- 기대 동작을 설명하는 명확한 테스트 이름
+- setup/teardown을 위해 fixture 사용
-## Coverage
-- Happy path scenarios
-- Edge cases: None, empty strings, empty lists
-- Boundary values
-- Error scenarios with pytest.raises()
+## 커버리지
+- 정상 시나리오
+- 엣지 케이스: None, 빈 문자열, 빈 리스트
+- 경계값
+- pytest.raises()를 사용한 오류 시나리오
-## Fixtures
-- Use @pytest.fixture for reusable test data
-- Use tmpdir/tmp_path for file operations
-- Mock external dependencies with pytest-mock
+## 픽스처
+- 재사용 가능한 테스트 데이터를 위해 @pytest.fixture 사용
+- 파일 작업에는 tmpdir/tmp_path 사용
+- pytest-mock으로 외부 의존성 모킹
-## Output
-Provide complete, runnable test file with proper imports.
+## 출력
+올바른 import를 포함한, 실행 가능한 전체 테스트 파일을 제공합니다.
EOF
```
-### Team PR Review Skill
+### 팀 PR 리뷰 스킬
-A skill that enforces consistent PR review standards across your team:
+팀 전반에 일관된 PR 리뷰 기준을 적용하는 스킬입니다.
```bash
mkdir -p .github/skills/pr-review
@@ -634,231 +631,231 @@ mkdir -p .github/skills/pr-review
cat > .github/skills/pr-review/SKILL.md << 'EOF'
---
name: pr-review
-description: Team-standard PR review checklist
+description: 팀 표준 PR 리뷰 체크리스트
---
-# PR Review
+# PR 리뷰
-Review code changes against team standards:
+팀 표준에 따라 변경 사항을 리뷰합니다.
-## Security Checklist
-- [ ] No hardcoded secrets or API keys
-- [ ] Input validation on all user data
-- [ ] No bare except clauses
-- [ ] No sensitive data in logs
+## 보안 체크리스트
+- [ ] 하드코딩된 시크릿 또는 API 키 없음
+- [ ] 모든 사용자 데이터에 입력 검증
+- [ ] bare except 절 없음
+- [ ] 로그에 민감 데이터 없음
-## Code Quality
-- [ ] Functions under 50 lines
-- [ ] No print statements in production code
-- [ ] Type hints on public functions
-- [ ] Context managers for file I/O
-- [ ] No TODOs without issue references
+## 코드 품질
+- [ ] 함수 50줄 이하
+- [ ] 프로덕션 코드에 print 문 없음
+- [ ] 공개 함수에 타입 힌트
+- [ ] 파일 I/O에 컨텍스트 매니저 사용
+- [ ] 이슈 참조 없는 TODO 없음
-## Testing
-- [ ] New code has tests
-- [ ] Edge cases covered
-- [ ] No skipped tests without explanation
+## 테스트
+- [ ] 새 코드에 테스트가 있음
+- [ ] 엣지 케이스 포함
+- [ ] 설명 없는 skipped 테스트 없음
-## Documentation
-- [ ] API changes documented
-- [ ] Breaking changes noted
-- [ ] README updated if needed
+## 문서
+- [ ] API 변경 문서화
+- [ ] BREAKING CHANGE 기록
+- [ ] 필요 시 README 업데이트
-## Output Format
-Provide results as:
-- ✅ PASS: Items that look good
-- ⚠️ WARN: Items that could be improved
-- ❌ FAIL: Items that must be fixed before merge
+## 출력 형식
+결과를 다음과 같이 제공합니다.
+- ✅ PASS: 문제가 없어 보이는 항목
+- ⚠️ WARN: 개선 가능 항목
+- ❌ FAIL: 병합 전 반드시 수정해야 하는 항목
EOF
```
-### Go Further
+### 더 해보기
-1. **Skill Creation Challenge**: Create a `quick-review` skill that does a 3-point checklist:
- - Bare except clauses
- - Missing type hints
- - Unclear variable names
+1. **스킬 생성 챌린지**: 3가지 항목만 빠르게 점검하는 `quick-review` 스킬을 만들어보세요.
+ - bare except 절
+ - 타입 힌트 누락
+ - 불명확한 변수 이름
- Test it by asking: "Do a quick review of books.py"
+ "Do a quick review of books.py"라고 요청해 테스트합니다.
-2. **Skill Comparison**: Time yourself writing a detailed security review prompt manually. Then just ask "Check for security issues in this file" and let your security-audit skill load automatically. How much time did the skill save?
+2. **스킬 비교**: 수동으로 상세한 보안 리뷰 프롬프트를 작성하는 데 걸리는 시간을 재보세요. 그 다음 "Check for security issues in this file"이라고만 요청해 `security-audit` 스킬이 자동 로드되게 해보세요. 스킬이 시간을 얼마나 절약해줬나요?
-3. **Team Skill Challenge**: Think about your team's code review checklist. Could you encode it as a skill? Write down 3 things the skill should always check.
+3. **팀 스킬 챌린지**: 팀의 코드 리뷰 체크리스트를 떠올려 보세요. 스킬로 인코딩할 수 있을까요? 스킬이 항상 확인해야 할 3가지 항목을 적어보세요.
-**Self-Check**: You understand skills when you can explain why the `description` field matters (it's how Copilot decides whether to load your skill).
+**셀프 체크**: `description` 필드가 왜 중요한지(스킬 로딩의 기준) 설명할 수 있나요?
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: Build a Book Summary Skill
+### 메인 챌린지: 도서 요약 스킬 만들기
-The examples above created `pytest-gen` and `pr-review` skills. Now practice creating a completely different kind of skill: one for generating formatted output from data.
+앞의 예시는 `pytest-gen`과 `pr-review` 스킬을 만들었습니다. 이제 완전히 다른 종류의 스킬, 즉 데이터로부터 형식화된 출력(포맷)을 만드는 스킬을 연습해봅니다.
-1. List your current skills: Run Copilot and pass it `/skills list`. You can also use `ls .github/skills/` to see project skills or `ls ~/.copilot/skills/` for personal skills.
-2. Create a `book-summary` skill at `.github/skills/book-summary/SKILL.md` that generates a formatted markdown summary of the book collection
-3. Your skill should have:
- - Clear name and description (description is crucial for matching!)
- - Specific formatting rules (e.g., markdown table with title, author, year, read status)
- - Output conventions (e.g., use ✅/❌ for read status, sort by year)
-4. Test the skill: `@samples/book-app-project/data.json Summarize the books in this collection`
-5. Verify the skill auto-triggers by checking `/skills list`
-6. Try invoking it directly with `/book-summary Summarize the books in this collection`
+1. 현재 스킬 목록 보기: Copilot을 실행하고 `/skills list`를 입력하세요. 또는 프로젝트 스킬은 `ls .github/skills/`, 개인 스킬은 `ls ~/.copilot/skills/`로 확인할 수 있습니다.
+2. `.github/skills/book-summary/SKILL.md`에 `book-summary` 스킬을 만들어 도서 컬렉션의 형식화된 마크다운 요약을 생성하세요.
+3. 스킬은 다음을 포함해야 합니다.
+ - 명확한 name과 description(매칭을 위해 description이 매우 중요!)
+ - 구체적인 포맷 규칙(예: 제목/저자/연도/읽음 여부를 포함한 마크다운 테이블)
+ - 출력 규칙(예: 읽음 여부는 ✅/❌ 사용, 연도 기준 정렬)
+4. 스킬 테스트: `@samples/book-app-project/data.json Summarize the books in this collection`
+5. `/skills list`로 스킬 자동 트리거를 확인
+6. `/book-summary Summarize the books in this collection`로 직접 호출도 시도
-**Success criteria**: You have a working `book-summary` skill that Copilot automatically applies when you ask about the book collection.
+**성공 기준**: 도서 컬렉션을 물어볼 때 Copilot이 자동으로 적용하는 `book-summary` 스킬을 만들었다.
-Think of MCP servers like browser extensions. Your browser on its own can display web pages, but extensions connect it to extra services:
+MCP 서버를 브라우저 확장 프로그램과 비슷하게 생각해 보세요. 브라우저 자체는 웹 페이지를 표시할 수 있지만, 확장 프로그램은 브라우저를 추가 서비스에 연결해 줍니다.
-| Browser Extension | What It Connects To | MCP Equivalent |
-|-------------------|---------------------|----------------|
-| Password manager | Your password vault | **GitHub MCP** → your repos, issues, PRs |
-| Grammarly | Writing analysis service | **Context7 MCP** → library documentation |
-| File manager | Cloud storage | **Filesystem MCP** → local project files |
+| 브라우저 확장 프로그램 | 연결 대상 | MCP와 유사한 기능 |
+|----------------------|-----------|-----------------|
+| 비밀번호 관리자 | 비밀번호 보관소 | **GitHub MCP** → 저장소, 이슈, PR |
+| Grammarly | 글쓰기 분석 서비스 | **Context7 MCP** → 라이브러리 문서 관리 |
+| 파일 관리자 | 클라우드 스토리지 | **파일 시스템 MCP** → 로컬 프로젝트 파일 |
-Without extensions, your browser is still useful, but with them, it becomes a powerhouse. MCP servers do the same for Copilot. They connect it to real, live data sources so it can read your GitHub issues, explore your file system, fetch up-to-date documentation, and more.
+확장 프로그램이 없어도 브라우저는 여전히 유용하지만, 확장 프로그램을 사용하면 강력한 도구로 거듭납니다. MCP 서버는 Copilot에도 똑같은 역할을 합니다. MCP 서버는 Copilot을 실제 데이터 소스에 연결하여 GitHub 이슈를 읽고, 파일 시스템을 탐색하고, 최신 문서를 가져오는 등 다양한 작업을 수행할 수 있도록 지원합니다.
-***MCP servers connect Copilot to the outside world: GitHub, repositories, documentation, and more***
+***MCP 서버는 Copilot을 외부 세계(GitHub, 저장소, 문서 등)에 연결합니다.***
-> 💡 **Key insight**: Without MCP, Copilot can only see files you explicitly share with `@`. With MCP, it can proactively explore your project, check your GitHub repo, and look up documentation, all automatically.
+> 💡 **핵심 정보**: MCP가 없으면 Copilot은 `@`로 명시적으로 공유한 파일만 볼 수 있습니다. MCP를 사용하면 Copilot은 프로젝트를 능동적으로 탐색하고, GitHub 저장소를 확인하고, 문서를 검색하는 등의 모든 작업을 자동으로 수행할 수 있습니다.
---
-# Quick Start: MCP in 30 Seconds
+# 빠른 시작: 30초 만에 MCP 시작하기
-## Get started with the built-in GitHub MCP server
-Let's see MCP in action right now, before configuring anything.
-The GitHub MCP server is included by default. Try this:
+## GitHub MCP 서버 내장 기능 시작하기
+
+설정을 하기 전에 MCP가 어떻게 작동하는지 바로 살펴보겠습니다.
+
+GitHub MCP 서버는 기본적으로 포함되어 있습니다. 다음을 시도해 보세요.
```bash
copilot
-> List the recent commits in this repository
+> 이 저장소의 최근 커밋 목록을 표시합니다.
```
-If Copilot returns real commit data, you've just seen MCP in action. That's the GitHub MCP server reaching out to GitHub on your behalf. But GitHub is just *one* server. This chapter shows you how to add more (filesystem access, up-to-date documentation, and others) so Copilot can do even more.
+Copilot이 실제 커밋 데이터를 반환한다면, MCP가 제대로 작동하는 것을 보신 겁니다. GitHub MCP 서버가 여러분을 대신하여 GitHub에 접속한 것이죠. 하지만 GitHub는 단 하나의 서버일 뿐입니다. 이 장에서는 파일 시스템 접근, 최신 문서 업데이트 등 Copilot이 더 많은 기능을 수행할 수 있도록 서버를 추가하는 방법을 보여줍니다.
---
-## The `/mcp show` Command
+## `/mcp show` 명령어
-Use `/mcp show` to see which MCP servers are configured and whether they're enabled:
+구성된 MCP 서버와 활성화 여부를 확인하려면 `/mcp show` 명령어를 사용하십시오.
```bash
copilot
@@ -73,59 +75,59 @@ MCP Servers:
✓ filesystem (enabled) - File system access
```
-> 💡 **Only seeing the GitHub server?** That's expected! If you haven't added any additional MCP servers yet, GitHub is the only one listed. You'll add more in the next section.
+> 💡 **GitHub 서버만 보이시나요?** 정상입니다! 아직 MCP 서버를 추가하지 않았다면 GitHub만 표시됩니다. 다음 섹션에서 더 많은 서버를 추가할 수 있습니다.
-> 📚 **Want to see all `/mcp` commands?** There are additional commands for adding, editing, enabling, and deleting servers. See the [full command reference](#-additional-mcp-commands) at the end of this chapter.
+> 📚 **모든 `/mcp` 명령어를 보고 싶으신가요?** 서버를 추가, 편집, 활성화 및 삭제하는 추가 명령어가 있습니다. 이 장의 끝에 있는 [전체 명령어 참조](#-추가-mcp-명령어)를 확인하세요.
-Now that you've seen MCP in action, let's set up additional servers. This section covers the configuration file format and how to add new servers.
+MCP가 실제로 동작하는 모습을 보셨으니, 이제 추가 서버를 설정해 봅시다. 이 섹션에서는 구성 파일 형식과 새 서버를 추가하는 방법을 다룹니다.
---
-## MCP Configuration File
+## MCP 구성 파일
-MCP servers are configured in `~/.copilot/mcp-config.json` (user-level, applies to all projects) or `.vscode/mcp.json` (project-level, applies to just the current workspace).
+MCP 서버는 `~/.copilot/mcp-config.json`(사용자 수준, 모든 프로젝트에 적용) 또는 `.vscode/mcp.json`(프로젝트 수준, 현재 작업 공간에만 적용)에서 구성됩니다.
```json
{
@@ -140,44 +142,44 @@ MCP servers are configured in `~/.copilot/mcp-config.json` (user-level, applies
}
```
-*Most MCP servers are distributed as npm packages and run via the `npx` command.*
+*대부분의 MCP 서버는 npm 패키지로 배포되며 `npx` 명령어로 실행됩니다.*
---
-## Server Usage Examples
+## 서버 사용 예시
-**Pick a server to explore, or work through them in order.**
+**관심 있는 서버를 선택하거나, 순서대로 살펴보세요.**
-| I want to try... | Jump to |
-|---|---|
-| GitHub repos, issues, and PRs | [GitHub Server](#github-server-built-in) |
-| Browsing project files | [Filesystem Server Usage](#filesystem-server-usage) |
-| Library documentation lookup | [Context7 Server Usage](#context7-server-usage) |
-| Custom server, Microsoft Learn MCP and web_fetch usage | [Beyond the Basics Usage](#beyond-the-basics-usage) |
+| 시도하고 싶은 것 | 이동 |
+|----------------|------|
+| GitHub 저장소, 이슈, PR | [GitHub 서버](#github-서버-내장) |
+| 프로젝트 파일 탐색 | [파일 시스템 서버 사용법](#파일-시스템-서버-사용법) |
+| 라이브러리 문서 조회 | [Context7 서버 사용법](#context7-서버-사용법) |
+| 사용자 지정 서버, Microsoft Learn MCP 및 web_fetch 사용 | [기본 이상의 기능 사용법](#기본-이상의-기능-사용법) |
-*Complete MCP workflow: GitHub MCP retrieves repo data, Filesystem MCP finds code, Context7 MCP provides best practices, and Copilot handles analysis*
+*완전한 MCP 워크플로: GitHub MCP가 저장소 데이터를 가져오고, 파일 시스템 MCP가 코드를 찾고, Context7 MCP가 모범 사례를 제공하며, Copilot이 분석을 처리합니다.*
-Each example below is self-contained. **Pick one that interests you, or read them all.**
+아래의 각 예시는 독립적입니다. **관심 있는 것을 선택하거나, 모두 읽어보세요.**
-| I want to see... | Jump to |
-|---|---|
-| Multiple servers working together | [Multi-Server Exploration](#multi-server-exploration) |
-| Going from issue to PR in one session | [Issue-to-PR Workflow](#issue-to-pr-workflow) |
-| A quick project health check | [Health Dashboard](#health-dashboard) |
+| 보고 싶은 것 | 이동 |
+|-------------|------|
+| 여러 서버가 함께 작동하는 모습 | [다중 서버 탐색](#다중-서버-탐색) |
+| 이슈에서 PR까지 한 세션에서 처리 | [이슈-to-PR 워크플로](#이슈-to-pr-워크플로) |
+| 빠른 프로젝트 상태 확인 | [상태 대시보드](#상태-대시보드) |
-**🎉 You now know the essentials!** You understand MCP, you've seen how to configure servers, and you've seen real workflows in action. Now it's time to try it yourself.
+**🎉 이제 기본 사항을 모두 이해하셨습니다!** MCP가 무엇인지, 서버를 구성하는 방법, 그리고 실제 워크플로를 살펴보셨습니다. 이제 직접 해볼 시간입니다.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 해보기
-Now it's your turn! Complete these exercises to practice using MCP servers with the book app project.
+이제 여러분의 차례입니다! 책 앱 프로젝트에서 MCP 서버를 사용하는 연습을 위해 이 연습 문제들을 완료하세요.
-### Exercise 1: Check Your MCP Status
+### 연습 1: MCP 상태 확인
-Start by seeing what MCP servers are available:
+사용 가능한 MCP 서버를 확인하는 것부터 시작해 보세요.
```bash
copilot
@@ -711,103 +712,103 @@ copilot
> /mcp show
```
-You should see the GitHub server listed as enabled. If not, run `/login` to authenticate.
+GitHub 서버가 활성화되어 있는 것으로 표시되어야 합니다. 그렇지 않은 경우 `/login`을 실행하여 인증하세요.
---
-### Exercise 2: Explore the Book App with Filesystem MCP
+### 연습 2: 파일 시스템 MCP로 책 앱 탐색
-If you've configured the filesystem server, use it to explore the book app:
+파일 시스템 서버를 구성했다면, 책 앱을 탐색해 보세요.
```bash
copilot
-> How many Python files are in samples/book-app-project/?
-> What functions are defined in each file?
+> samples/book-app-project/에 Python 파일이 몇 개 있나요?
+> 각 파일에 정의된 함수는 무엇인가요?
```
-**Expected result**: Copilot lists `book_app.py`, `books.py`, and `utils.py` with their functions.
+**예상 결과**: Copilot이 `book_app.py`, `books.py`, `utils.py`와 해당 함수들을 나열합니다.
-> 💡 **Don't have filesystem MCP configured yet?** Create the config file from the [Complete Configuration](#complete-configuration-file) section above. Then restart Copilot.
+> 💡 **파일 시스템 MCP를 아직 구성하지 않으셨나요?** 위의 [완전한 구성](#완전한-구성-파일) 섹션에서 구성 파일을 생성하세요. 그런 다음 Copilot을 재시작하세요.
---
-### Exercise 3: Query Repository History with GitHub MCP
+### 연습 3: GitHub MCP로 저장소 히스토리 쿼리
-Use the built-in GitHub MCP to explore this course repository:
+내장된 GitHub MCP를 사용하여 이 강의 저장소를 탐색하세요.
```bash
copilot
-> List the last 5 commits in this repository
+> 이 저장소의 마지막 커밋 5개를 나열해 주세요.
-> What branches exist in this repository?
+> 이 저장소에 어떤 브랜치가 있나요?
```
-**Expected result**: Copilot shows recent commit messages and branch names from the GitHub remote.
+**예상 결과**: Copilot이 GitHub 원격에서 최근 커밋 메시지와 브랜치 이름을 표시합니다.
-> ⚠️ **In a Codespace?** This works automatically. Authentication is inherited. If you're on a local clone, make sure `gh auth status` shows you're logged in.
+> ⚠️ **Codespace에서 작업하시나요?** 이것은 자동으로 작동합니다. 인증이 상속됩니다. 로컬 클론에 있다면 `gh auth status`에서 로그인되어 있는지 확인하세요.
---
-### Exercise 4: Combine Multiple MCP Servers
+### 연습 4: 여러 MCP 서버 결합
-Now combine filesystem and GitHub MCP in a single session:
+이제 파일 시스템과 GitHub MCP를 단일 세션에서 결합해 보세요.
```bash
copilot
-> Read samples/book-app-project/data.json and tell me what books are
-> in the collection. Then check the recent commits to see when this
-> file was last modified.
+> samples/book-app-project/data.json을 읽고 컬렉션에 어떤 책이 있는지
+> 알려주세요. 그런 다음 이 파일이 마지막으로 수정된 시점을 알아보기 위해
+> 최근 커밋을 확인해 주세요.
```
-**Expected result**: Copilot reads the JSON file (filesystem MCP), lists the 5 books including "The Hobbit", "1984", "Dune", "To Kill a Mockingbird", and "Mysterious Book", then queries GitHub for commit history.
+**예상 결과**: Copilot이 JSON 파일을 읽고(파일 시스템 MCP), "The Hobbit", "1984", "Dune", "To Kill a Mockingbird", "Mysterious Book"을 포함한 5권의 책을 나열한 후 GitHub에서 커밋 히스토리를 쿼리합니다.
-**Self-Check**: You understand MCP when you can explain why "Check my repo's commit history" is better than manually running `git log` and pasting the output into your prompt.
+**자가 점검**: "내 저장소의 커밋 히스토리를 확인해 줘"가 수동으로 `git log`를 실행하고 출력을 프롬프트에 붙여넣는 것보다 나은 이유를 설명할 수 있을 때 MCP를 이해한 것입니다.
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: Book App MCP Exploration
+### 주요 과제: 책 앱 MCP 탐색
-Practice using MCP servers together on the book app project. Complete these steps in a single Copilot session:
+책 앱 프로젝트에서 MCP 서버를 함께 사용하는 연습을 하세요. 단일 Copilot 세션에서 이 단계들을 완료하세요.
-1. **Verify MCP is working**: Run `/mcp show` and confirm at least the GitHub server is enabled
-2. **Set up filesystem MCP** (if not already done): Create `~/.copilot/mcp-config.json` with the filesystem server configuration
-3. **Explore the code**: Ask Copilot to use the filesystem server to:
- - List all functions in `samples/book-app-project/books.py`
- - Check which functions in `samples/book-app-project/utils.py` are missing type hints
- - Read `samples/book-app-project/data.json` and identify any data quality issues (hint: look at the last entry)
-4. **Check repository activity**: Ask Copilot to use GitHub MCP to:
- - List recent commits that touched files in `samples/book-app-project/`
- - Check if there are any open issues or pull requests
-5. **Combine servers**: In a single prompt, ask Copilot to:
- - Read the test file at `samples/book-app-project/tests/test_books.py`
- - Compare the tested functions against all functions in `books.py`
- - Summarize what test coverage is missing
+1. **MCP 작동 확인**: `/mcp show`를 실행하고 최소한 GitHub 서버가 활성화되어 있는지 확인하세요.
+2. **파일 시스템 MCP 설정** (아직 완료하지 않은 경우): 파일 시스템 서버 구성으로 `~/.copilot/mcp-config.json`을 생성하세요.
+3. **코드 탐색**: Copilot에게 파일 시스템 서버를 사용하여 다음을 요청하세요.
+ - `samples/book-app-project/books.py`의 모든 함수 나열
+ - `samples/book-app-project/utils.py`에서 타입 힌트가 없는 함수 확인
+ - `samples/book-app-project/data.json`을 읽고 데이터 품질 문제 식별 (힌트: 마지막 항목을 살펴보세요)
+4. **저장소 활동 확인**: Copilot에게 GitHub MCP를 사용하여 다음을 요청하세요.
+ - `samples/book-app-project/`의 파일에 영향을 준 최근 커밋 나열
+ - 열린 이슈 또는 풀 리퀘스트가 있는지 확인
+5. **서버 결합**: 단일 프롬프트에서 Copilot에게 다음을 요청하세요.
+ - `samples/book-app-project/tests/test_books.py`의 테스트 파일 읽기
+ - 테스트된 함수를 `books.py`의 모든 함수와 비교
+ - 누락된 테스트 커버리지 요약
-**Success criteria**: You can seamlessly combine filesystem and GitHub MCP data in a single Copilot session, and you can explain what each MCP server contributed to the response.
+**성공 기준**: 단일 Copilot 세션에서 파일 시스템과 GitHub MCP 데이터를 자연스럽게 결합할 수 있으며, 각 MCP 서버가 응답에 기여한 내용을 설명할 수 있습니다.
-
+심포니 오케스트라는 여러 파트로 구성됩니다.
+- **현악기**는 기반을 제공합니다(핵심 워크플로와 유사).
+- **금관악기**는 힘을 더합니다(전문 지식을 갖춘 에이전트와 유사).
+- **목관악기**는 색채를 더합니다(역량을 확장하는 스킬과 유사).
-A symphony orchestra has many sections:
-- **Strings** provide the foundation (like your core workflows)
-- **Brass** adds power (like agents with specialized expertise)
-- **Woodwinds** add color (like skills that extend capabilities)
-- **Percussion** keeps rhythm (like MCP connecting to external systems)
+- **타악기**는 리듬을 유지합니다(MCP가 외부 시스템과 연결되는 것과 유사).
-Individually, each section sounds limited. Together, conducted well, they create something magnificent.
+각 파트는 개별적으로는 한계가 있지만, 잘 지휘될 때 비로소 웅장한 소리를 만들어냅니다.
-**That's what this chapter teaches!**
-*Like a conductor with an orchestra, you orchestrate agents, skills, and MCP into unified workflows* +**이 장에서 바로 그 방법을 알려드립니다!**
+*지휘자가 오케스트라를 지휘하듯, 에이전트, 스킬, MCP를 통합 워크플로로 조율합니다.* -Let's start by walking through a scenario that modifies code, generates tests, reviews it, and creates a PR - all in one session. +코드 수정, 테스트 생성, 코드 검토, 그리고 PR 생성까지 모든 작업을 한 번에 수행하는 시나리오를 살펴보면서 시작해 보겠습니다. --- -## Idea to Merged PR in One Session +## 아이디어 구상부터 PR 병합까지 한 번의 세션으로 완료하기 -Instead of switching between your editor, terminal, test runner, and GitHub UI and losing context each time, you can combine all your tools in one terminal session. We'll break down this pattern in the [Integration Pattern](#the-integration-pattern-for-power-users) section below. +편집기, 터미널, 테스트 러너, GitHub UI를 번갈아 가며 사용하고 매번 작업 내용을 잃어버리는 대신, 모든 도구를 하나의 터미널 세션에서 통합하여 사용할 수 있습니다. 이 패턴에 대한 자세한 설명은 아래 [통합 패턴](#the-integration-pattern-for-power-users) 섹션에서 다루겠습니다. ```bash -# Start Copilot in interactive mode +# Copilot을 대화형 모드로 시작 copilot -> I need to add a "list unread" command to the book app that shows only -> books where read is False. What files need to change? +> 읽지 않은 책 목록 보기 기능을 도서 앱에 추가하고 싶습니다. +> 읽은 책이 False인 책만 표시되도록 하려면 어떤 파일을 수정해야 하나요? -# Copilot creates high-level plan... +# Copilot이 상위 수준 계획을 생성합니다... -# SWITCH TO PYTHON-REVIEWER AGENT +# PYTHON-REVIEWER 에이전트로 전환 > /agent -# Select "python-reviewer" +# "python-reviewer" 선택 -> @samples/book-app-project/books.py Design a get_unread_books method. -> What is the best approach? +> @samples/book-app-project/books.py 파일에서 읽지 않은 책 수를 가져오는 get_unread_books 메서드를 설계하세요. +> 가장 좋은 접근 방식은 무엇일까요? -# Python-reviewer agent produces: -# - Method signature and return type -# - Filter implementation using list comprehension -# - Edge case handling for empty collections +# Python-reviewer 에이전트 출력 결과: +# - 메서드 시그니처 및 반환 타입 +# - 리스트 컴프리헨션을 사용한 필터 구현 +# - 빈 컬렉션에 대한 예외 처리 -# SWITCH TO PYTEST-HELPER AGENT +# PYTEST-HELPER 에이전트로 전환 > /agent -# Select "pytest-helper" +# "pytest-helper" 선택 -> @samples/book-app-project/tests/test_books.py Design test cases for -> filtering unread books. +> @samples/book-app-project/tests/test_books.py 읽지 않은 책 필터링에 대한 테스트 케이스를 설계합니다. -# Pytest-helper agent produces: -# - Test cases for empty collections -# - Test cases with mixed read/unread books -# - Test cases with all books read +# Pytest-helper 에이전트는 다음을 생성합니다. +# - 빈 컬렉션에 대한 테스트 케이스 +# - 읽은 책과 읽지 않은 책이 혼합된 경우의 테스트 케이스 +# - 모든 책을 읽은 경우의 테스트 케이스 -# IMPLEMENT -> Add a get_unread_books method to BookCollection in books.py -> Add a "list unread" command option in book_app.py -> Update the help text in the show_help function +# 구현 +> books.py의 BookCollection에 get_unread_books 메서드 추가 +> book_app.py에 "읽지 않은 책 목록 보기" 명령 옵션 추가 +> show_help 함수의 도움말 텍스트 업데이트 -# TEST -> Generate comprehensive tests for the new feature +# 테스트 +> 새 기능에 대한 포괄적인 테스트 생성 -# Multiple tests are generated similar to the following: -# - Happy path (3 tests) — filters correctly, excludes read, includes unread -# - Edge cases (4 tests) — empty collection, all read, none read, single book -# - Parametrized (5 cases) — varying read/unread ratios via @pytest.mark.parametrize -# - Integration (4 tests) — interplay with mark_as_read, remove_book, add_book, and data integrity +# 다음과 유사한 여러 테스트가 생성됩니다. +# - 정상 경로(3개 테스트) — 필터링이 올바르게 작동하고, 읽은 책은 제외하고, 읽지 않은 책은 포함합니다. +# - 예외 상황(4개 테스트) — 빈 컬렉션, 모든 책 읽음, 읽지 않은 책 없음, 책 한 권만 있는 경우 +# - 매개변수화된 경우(5개 테스트) — @pytest.mark.parametrize를 통해 읽은 책과 읽지 않은 책의 비율을 변경합니다. +# - 통합 테스트(4개 테스트) — mark_as_read, remove_book, add_book 및 데이터 무결성과의 상호 작용 -# Review the changes +# 변경 사항 검토 > /review -# If review passes, use /pr to operate on the pull request for the current branch -> /pr [view|create|fix|auto] +# 검토가 통과되면 /pr을 사용하여 제출하세요. 현재 브랜치에 대한 풀 리퀘스트를 작업합니다. +> /pr [보기|생성|수정|자동] -# Or ask naturally if you want Copilot to draft it from the terminal -> Create a pull request titled "Feature: Add list unread books command" +# 또는 Copilot이 터미널에서 풀 리퀘스트를 생성하도록 하려면 자연스럽게 요청할 수도 있습니다. +> "Feature: Add list unread books command"라는 제목의 풀 리퀘스트를 생성합니다. ``` -**Traditional approach**: Switching between editor, terminal, test runner, docs, and GitHub UI. Each switch causes context loss and friction. +**기존 방식**: 에디터, 터미널, 테스트 러너, 문서, GitHub UI 사이를 계속 전환해야 했습니다. 전환할 때마다 맥락을 놓치고 불편함을 느꼈습니다. -**The key insight**: You directed specialists like an architect. They handled the details. You handled the vision. +**핵심 통찰**: 마치 건축가처럼 전문가들을 이끌었습니다. 그들은 세부 사항을 처리했고, 당신은 비전을 제시했습니다. -> 💡 **Going further**: For large multi-step plans like this, try `/fleet` to let Copilot run independent subtasks in parallel. See the [official docs](https://docs.github.com/copilot/concepts/agents/copilot-cli/fleet) for details. +> 💡 **더 나아가** 이와 같은 대규모 다단계 계획의 경우, Copilot이 독립적인 하위 작업을 병렬로 실행할 수 있도록 `/fleet`을 사용해 보세요. 자세한 내용은 [공식 문서](https://docs.github.com/copilot/concepts/agents/copilot-cli/fleet)를 참조하십시오. --- -# Additional Workflows +# 추가 워크플로
-For power users who completed Chapters 04-06, these workflows show how agents, skills, and MCP multiply your effectiveness.
+4장부터 6장까지 완료한 고급 사용자라면, 이 워크플로를 통해 Agent, 스킬, 그리고 MCP가 어떻게 업무 효율성을 극대화하는지 확인할 수 있습니다.
-## The Integration Pattern
+## 통합 패턴
-Here's the mental model for combining everything:
+모든 것을 결합하는 개념적 모델은 다음과 같습니다.
---
-## Workflow 1: Bug Investigation and Fix
+## 워크플로 1: 버그 조사 및 수정
-Real-world bug fixing with full tool integration:
+실제 환경에서 버그를 수정하고 모든 도구를 통합적으로 활용합니다.
```bash
copilot
-# PHASE 1: Understand the bug from GitHub (MCP provides this)
-> Get the details of issue #1
+# 1단계: GitHub에서 버그 파악 (MCP 제공)
+> 이슈 #1의 세부 정보 가져오기
-# Learn: "find_by_author doesn't work with partial names"
+# 학습 내용: "find_by_author 함수가 부분 이름 일치에 문제가 있습니다"
-# PHASE 2: Research best practice (deep research with web + GitHub sources)
-> /research Best practices for Python case-insensitive string matching
+# 2단계: 모범 사례 조사 (웹 및 GitHub 자료를 활용한 심층 조사)
+> /research Python 대소문자 구분 없는 문자열 일치 모범 사례
-# PHASE 3: Find related code
-> @samples/book-app-project/books.py Show me the find_by_author method
+# 3단계: 관련 코드 찾기
+> @samples/book-app-project/books.py find_by_author 메서드 표시
-# PHASE 4: Get expert analysis
+# 4단계: 전문가 분석 받기
> /agent
-# Select "python-reviewer"
+# "python-reviewer" 선택
-> Analyze this method for issues with partial name matching
+> 부분 이름 일치 관련 문제 분석
-# Agent identifies: Method uses exact equality instead of substring matching
+# 에이전트 분석 결과: 메서드가 부분 문자열 일치 대신 정확한 동일성 비교를 사용합니다
-# PHASE 5: Fix with agent guidance
-> Implement the fix using lowercase comparison and 'in' operator
+# 5단계: 에이전트의 안내에 따라 수정
+> 소문자 비교 및 'in' 연산자를 사용하여 수정 구현
-# PHASE 6: Generate tests
+# 6단계: 테스트 생성
> /agent
-# Select "pytest-helper"
+# "pytest-helper" 선택
-> Generate pytest tests for find_by_author with partial matches
-> Include test cases: partial name, case variations, no matches
+> 생성 pytest에서 find_by_author 함수에 대한 부분 일치 테스트 수행
+> 테스트 케이스 추가: 부분 이름, 대소문자 변형, 일치 항목 없음
-# PHASE 7: Commit and PR
-> Generate a commit message for this fix
+# 7단계: 커밋 및 풀 리퀘스트 생성
+> 이 수정 사항에 대한 커밋 메시지 생성
-> Create a pull request linking to issue #1
+> 이슈 #1에 연결되는 풀 리퀘스트 생성
```
---
-## Workflow 2: Code Review Automation (Optional)
+## 워크플로 2: 코드 검토 자동화 (선택 사항)
-> 💡 **This section is optional.** Pre-commit hooks are useful for teams but not required to be productive. Skip this if you're just getting started.
->
-> ⚠️ **Performance note**: This hook calls `copilot -p` for each staged file, which takes several seconds per file. For large commits, consider limiting to critical files or running reviews manually with `/review` instead.
+> 💡 **이 섹션은 선택 사항입니다.** 커밋 전 훅은 팀 작업에 유용하지만 생산성을 위해 필수적인 것은 아닙니다. 처음 시작하는 경우 이 부분을 건너뛰세요.
-A **git hook** is a script that Git runs automatically at certain points, For example, right before a commit. You can use this to run automated checks on your code. Here's how to set up an automated Copilot review on your commits:
+> ⚠️ **성능 참고**: 이 훅은 스테이징된 각 파일에 대해 `copilot -p`를 호출하며, 파일당 몇 초가 소요됩니다. 대규모 커밋의 경우 중요한 파일에만 적용하거나 `/review`를 사용하여 수동으로 리뷰를 실행하는 것을 고려해 보세요.
+
+**Git 훅**은 Git이 특정 시점(예: 커밋 직전)에 자동으로 실행하는 스크립트입니다. 이를 통해 코드에 대한 자동화된 검사를 실행할 수 있습니다. 다음은 커밋에 대한 Copilot 자동 리뷰를 설정하는 방법입니다.
```bash
-# Create a pre-commit hook
+# 사전 커밋 훅 생성
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
-# Get staged files (Python files only)
+# 스테이징된 파일 가져오기 (파이썬 파일만 해당)
STAGED=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.py$')
if [ -n "$STAGED" ]; then
- echo "Running Copilot review on staged files..."
+ echo "스테이징된 파일에 대해 Copilot 검토를 실행 중입니다..."
for file in $STAGED; do
echo "Reviewing $file..."
- # Use timeout to prevent hanging (60 seconds per file)
- # --allow-all auto-approves file reads/writes so the hook can run unattended.
- # Only use this in automated scripts. In interactive sessions, let Copilot ask for permission.
- REVIEW=$(timeout 60 copilot --allow-all -p "Quick security review of @$file - critical issues only" 2>/dev/null)
-
- # Check if timeout occurred
+ # 멈춤 현상을 방지하기 위해 타임아웃을 사용합니다(파일당 60초).
+ # --allow-all 옵션은 파일 읽기/쓰기 권한을 자동으로 승인하여 후크가 자동으로 실행되도록 합니다.
+ # 자동화된 스크립트에서만 사용하십시오. 대화형 세션에서는 Copilot이 권한을 요청하도록 하십시오.
+ REVIEW=$(timeout 60 copilot --allow-all -p "Quick security review of @$file - critical issues only" 2>/dev/null)
+
+ # 타임아웃 발생 여부 확인
if [ $? -eq 124 ]; then
echo "Warning: Review timed out for $file (skipping)"
continue
@@ -205,24 +204,25 @@ if [ -n "$STAGED" ]; then
fi
done
- echo "Review passed"
+ echo "검토 통과"
fi
EOF
chmod +x .git/hooks/pre-commit
```
-> ⚠️ **macOS users**: The `timeout` command is not included by default on macOS. Install it with `brew install coreutils` or replace `timeout 60` with a simple invocation without a timeout guard.
+> ⚠️ **macOS 사용자**: `timeout` 명령어는 macOS에 기본적으로 포함되어 있지 않습니다. `brew install coreutils` 명령어로 설치하거나, `timeout 60` 대신 타임아웃 가드가 없는 간단한 명령어를 사용하세요.
+
+> 📚 **공식 문서**: 전체 훅 API에 대한 자세한 내용은 [훅 사용 방법](https://docs.github.com/copilot/how-tos/copilot-cli/use-hooks) 및 [훅 구성 참조](https://docs.github.com/copilot/reference/hooks-configuration)를 참조하세요.
-> 📚 **Official Documentation**: [Use hooks](https://docs.github.com/copilot/how-tos/copilot-cli/use-hooks) and [Hooks configuration reference](https://docs.github.com/copilot/reference/hooks-configuration) for the complete hooks API.
>
-> 💡 **Built-in alternative**: Copilot CLI also has a built-in hooks system (`copilot hooks`) that can run automatically on events like pre-commit. The manual git hook above gives you full control, while the built-in system is simpler to configure. See the docs above to decide which approach fits your workflow.
+> 💡 **내장 대안**: Copilot CLI에는 pre-commit과 같은 이벤트에서 자동으로 실행되는 내장 훅 시스템(`copilot hooks`)도 있습니다. 위의 수동 Git 훅은 완벽한 제어를 제공하는 반면, 내장 시스템은 구성이 더 간단합니다. 어떤 방식이 워크플로에 적합한지 위의 문서를 참조하세요.
-Now every commit gets a quick security review:
+이제 모든 커밋은 빠른 보안 검토를 거칩니다.
```bash
git add samples/book-app-project/books.py
-git commit -m "Update book collection methods"
+git commit -m "도서 수집 방법을 업데이트합니다"
# Output:
# Running Copilot review on staged files...
@@ -235,122 +235,122 @@ git commit -m "Update book collection methods"
---
-## Workflow 3: Onboarding to a New Codebase
+## 워크플로 3: 새로운 코드베이스 온보딩
-When joining a new project, combine context, agents, and MCP to ramp up fast:
+새로운 프로젝트에 참여할 때는 컨텍스트, 에이전트 및 MCP를 결합하여 빠르게 적응하세요.
```bash
-# Start Copilot in interactive mode
+# Copilot을 대화형 모드로 시작하세요
copilot
-# PHASE 1: Get the big picture with context
-> @samples/book-app-project/ Explain the high-level architecture of this codebase
+# PHASE 1: 맥락을 고려하여 전체적인 상황을 파악하세요.
+> @samples/book-app-project/ 이 코드베이스의 상위 수준 아키텍처를 설명하십시오.
-# PHASE 2: Understand a specific flow
-> @samples/book-app-project/book_app.py Walk me through what happens
-> when a user runs "python book_app.py add"
+# PHASE 2: 특정 흐름을 이해하세요
+> @samples/book-app-project/book_app.py 어떤 일이 발생하는지 설명해 주세요.
+> 사용자가 "python book_app.py add"를 실행할 때
-# PHASE 3: Get expert analysis with an agent
+# PHASE 3: Agent와 전문가 분석을 받으세요
> /agent
-# Select "python-reviewer"
+# "python-reviewer"를 선택하세요
-> @samples/book-app-project/books.py Are there any design issues,
-> missing error handling, or improvements you would recommend?
+> @samples/book-app-project/books.py 파일에 디자인 문제,
+> 누락된 오류 처리 또는 권장할 만한 개선 사항이 있습니까?
-# PHASE 4: Find something to work on (MCP provides GitHub access)
-> List open issues labeled "good first issue"
+# PHASE 4: 작업할 주제를 찾아보세요 (MCP는 GitHub 접근 권한을 제공합니다)
+> "첫 번째 이슈로 적합"이라고 표시된 미해결 이슈 목록을 확인하세요
-# PHASE 5: Start contributing
-> Pick the simplest open issue and outline a plan to fix it
+# PHASE 5: 기여를 시작하세요
+> 가장 간단한 미해결 문제를 선택하고 해결 계획을 세우세요
```
-This workflow combines `@` context, agents, and MCP into a single onboarding session, exactly the integration pattern from earlier in this chapter.
+이 워크플로는 `@` 컨텍스트, 에이전트 및 MCP를 단일 온보딩 세션으로 결합하며, 이는 이 장 앞부분에서 설명한 통합 패턴과 정확히 일치합니다.
---
-# Best Practices & Automation
+# 모범 사례 및 자동화
-Patterns and habits that make your workflows more effective.
+업무 효율성을 높이는 패턴과 습관.
---
-## Best Practices
+## 모범 사례
-### 1. Start with Context Before Analysis
+### 1. 분석에 앞서 맥락 파악부터 시작하세요
-Always gather context before asking for analysis:
+분석을 요청하기 전에 항상 맥락을 파악하세요.
```bash
# Good
-> Get the details of issue #42
+> 42번 이슈의 자세한 내용을 확인하세요
> /agent
-# Select python-reviewer
-> Analyze this issue
+# 파이썬 리뷰어를 선택하세요
+> 이 문제를 분석하세요
-# Less effective
+# 효과가 떨어짐
> /agent
-# Select python-reviewer
-> Fix login bug
-# Agent doesn't have issue context
+# 파이썬 리뷰어를 선택하세요
+> 로그인 버그 수정
+# Agent에 문제 컨텍스트가 없습니다.
```
-### 2. Know the Difference: Agents, Skills, and Custom Instructions
+### 2. 차이점을 알아두세요: 에이전트, 스킬, 그리고 사용자 지정 지침
-Each tool has a sweet spot:
+각 도구에는 최적의 사용 지점이 있습니다.
```bash
-# Agents: Specialized personas you explicitly activate
+# Agents: 사용자가 명시적으로 활성화하는 특수 페르소나
> /agent
-# Select python-reviewer
-> Review this authentication code for security issues
+# 파이썬 리뷰어를 선택
+> 이 인증 코드의 보안 문제를 검토하십시오.
-# Skills: Modular capabilities that auto-activate when your prompt
-# matches the skill's description (you must create them first — see Ch 05)
-> Generate comprehensive tests for this code
-# If you have a testing skill configured, it activates automatically
+# Skills: 사용자의 요청에 따라 자동으로 활성화되는 모듈형 기능
+# 스킬 설명과 일치해야 합니다(먼저 생성해야 합니다. 5장을 참조하세요).
+> 이 코드에 대한 포괄적인 테스트를 생성하세요.
+# 테스트 스킬이 구성되어 있으면 자동으로 활성화됩니다.
-# Custom instructions (.github/copilot-instructions.md): Always-on
-# guidance that applies to every session without switching or triggering
+# 사용자 지정 지침(.github/copilot-instructions.md): 항상 켜짐
+# 세션 전환이나 트리거 없이 모든 세션에 적용되는 지침입니다.
```
-> 💡 **Key point**: Agents and skills can both analyze AND generate code. The real difference is **how they activate** — agents are explicit (`/agent`), skills are automatic (prompt-matched), and custom instructions are always on.
+> 💡 **핵심 요점**: 에이전트와 스킬 모두 코드를 분석하고 생성할 수 있습니다. 진정한 차이점은 **활성화 방식**에 있습니다. 에이전트는 명시적 실행(`/agent`)을 통해 작동하고, 스킬은 자동 실행(프롬프트 일치)을 통해 작동하며, 사용자 지정 지침은 항상 활성화되어 있습니다.
-### 3. Keep Sessions Focused
+### 3. Session의 초점을 유지하세요
-Use `/rename` to label your session (makes it easy to find in history) and `/exit` to end it cleanly:
+세션에 이름을 지정하려면 `/rename` 명령어를 사용하고(이렇게 하면 기록에서 쉽게 찾을 수 있습니다), 깔끔하게 종료하려면 `/exit` 명령어를 사용하세요.
```bash
-# Good: One feature per session
+# Good: 세션당 하나의 기능만 사용 가능
> /rename list-unread-feature
-# Work on list unread
+# 읽지 않은 목록 작업
> /exit
copilot
> /rename export-csv-feature
-# Work on CSV export
+# CSV 내보내기 작업
> /exit
-# Less effective: Everything in one long session
+# 효과가 떨어지는 방식: 모든 것을 한 번의 긴 시간에 끝내는 것
```
-### 4. Make Workflows Reusable with Copilot
+### 4. Copilot을 사용하여 워크플로우를 재사용 가능하게 만드세요
-Instead of just documenting workflows in a wiki, encode them directly in your repo where Copilot can use them:
+워크플로를 위키에 문서화하는 대신, Copilot이 사용할 수 있도록 저장소에 직접 인코딩하세요.
-- **Custom instructions** (`.github/copilot-instructions.md`): Always-on guidance for coding standards, architecture rules, and build/test/deploy steps. Every session follows them automatically.
-- **Prompt files** (`.github/prompts/`): Reusable, parameterized prompts your team can share — like templates for code reviews, component generation, or PR descriptions.
-- **Custom agents** (`.github/agents/`): Encode specialized personas (e.g., a security reviewer or a docs writer) that anyone on the team can activate with `/agent`.
-- **Custom skills** (`.github/skills/`): Package step-by-step workflow instructions that auto-activate when relevant.
+- **Custom instructions** (`.github/copilot-instructions.md`): 코딩 표준, 아키텍처 규칙, 빌드/테스트/배포 단계에 대한 항상 연결된 안내를 제공합니다. 모든 세션은 자동으로 그들을 따라갑니다.
+- **Prompt files** (`.github/prompts/`): 코드 리뷰, 컴포넌트 생성, PR 설명 템플릿 등 재사용 가능한 매개변수화된 프롬프트를 팀이 공유할 수 있습니다.
+- **Custom agents** (`.github/agents/`): 팀 내 누구나 '/agent'로 활성화할 수 있는 전문 페르소나(예: 보안 리뷰어나 문서 작성자)를 인코딩합니다.
+- **Custom skills** (`.github/skills/`): 관련 사항이 있을 때 자동으로 활성화되는 단계별 워크플로우 지침을 패키지로 구성하세요.
-> 💡 **The payoff**: New team members get your workflows for free — they're built into the repo, not locked in someone's head.
+> 💡 **결점**: 새로운 팀 구성원은 워크플로를 무료로 이용할 수 있습니다. 워크플로는 저장소에 구축되어 있으므로 누군가의 머릿속에만 갇혀 있지 않습니다.
---
-## Bonus: Production Patterns
+## 보너스: 제작 패턴
-These patterns are optional but valuable for professional environments.
+이 패턴들은 선택 사항이지만, 전문적인 환경에서 유용합니다.
-### PR Description Generator
+### 보도자료 설명 생성기
```bash
# Generate comprehensive PR descriptions
@@ -365,7 +365,7 @@ $COMMITS
Include: Summary, Changes Made, Testing Done, Screenshots Needed"
```
-### CI/CD Integration
+### CI/CD 통합
For teams with existing CI/CD pipelines, you can automate Copilot reviews on every pull request using GitHub Actions. This includes posting review comments automatically and filtering for critical issues.
@@ -373,7 +373,7 @@ For teams with existing CI/CD pipelines, you can automate Copilot reviews on eve
---
-# Practice
+# 관행
@@ -381,132 +381,130 @@ Put the complete workflow into practice.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 시도해 보세요
-After completing the demos, try these variations:
+데모를 완료한 후 다음 변형들을 시도해 보세요:
-1. **End-to-End Challenge**: Pick a small feature (e.g., "list unread books" or "export to CSV"). Use the full workflow:
- - Plan with `/plan`
- - Design with agents (python-reviewer, pytest-helper)
+1. **종합 구현 과제**: 작은 기능 하나를 선택하세요(예: "읽지 않은 책 목록 보기" 또는 "CSV 파일로 내보내기"). 전체 워크플로를 활용해 보세요.
+ - `/plan` 명령어를 사용하여 계획을 세우세요.
+ - 에이전트를 활용한 설계 (python-reviewer, pytest-helper)
- Implement
- - Generate tests
- - Create PR
+ - 테스트 생성
+ - PR 만들기
-2. **Automation Challenge**: Set up the pre-commit hook from the Code Review Automation workflow. Make a commit with an intentional file path vulnerability. Does it get blocked?
+2. **자동화 챌린지**: 코드 검토 자동화 워크플로에서 사전 커밋 훅을 설정합니다. 의도적으로 파일 경로 취약점을 포함한 커밋을 생성합니다. 이 커밋이 차단됩니까?
-3. **Your Production Workflow**: Design your own workflow for a common task you do. Write it down as a checklist. What parts could be automated with skills, agents, or hooks?
+3. **귀사의 생산 워크플로우**: 자주 하는 작업에 대한 워크플로우를 직접 설계해 보세요. 체크리스트 형태로 작성해 보고, 스킬, 에이전트 또는 훅을 활용하여 자동화할 수 있는 부분은 무엇인지 생각해 보세요.
-**Self-Check**: You've completed the course when you can explain to a colleague how agents, skills, and MCP work together - and when to use each.
+**셀프 체크**: 에이전트, 스킬, MCP가 어떻게 상호 작용하는지, 그리고 각각을 언제 사용해야 하는지 동료에게 설명할 수 있게 되면 과정을 완료한 것입니다.
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: End-to-End Feature
+### 주요 과제: 엔드 투 엔드 기능 구현
-The hands-on examples walked through building a "list unread books" feature. Now practice the full workflow on a different feature: **search books by year range**:
+실습 예제를 통해 "읽지 않은 책 목록" 기능을 구축하는 과정을 단계별로 안내했습니다. 이제 다른 기능인 **연도 범위로 책 검색**에 전체 워크플로를 적용해 보겠습니다.
-1. Start Copilot and gather context: `@samples/book-app-project/books.py`
-2. Plan with `/plan Add a "search by year" command that lets users find books published between two years`
-3. Implement a `find_by_year_range(start_year, end_year)` method in `BookCollection`
-4. Add a `handle_search_year()` function in `book_app.py` that prompts the user for start and end years
-5. Generate tests: `@samples/book-app-project/books.py @samples/book-app-project/tests/test_books.py Generate tests for find_by_year_range() including edge cases like invalid years, reversed range, and no results.`
-6. Review with `/review`
-7. Update the README: `@samples/book-app-project/README.md Add documentation for the new "search by year" command.`
-8. Generate a commit message
+1. Copilot을 시작하고 컨텍스트를 수집합니다. `@samples/book-app-project/books.py`
+2. `/plan` 명령으로 계획을 세웁니다. 사용자가 두 해 사이에 출판된 책을 찾을 수 있는 "연도별 검색" 명령을 추가합니다.
+3. `BookCollection` 클래스에 `find_by_year_range(start_year, end_year)` 메서드를 구현합니다.
+4. `book_app.py` 파일에 시작 연도와 종료 연도를 입력받는 `handle_search_year()` 함수를 추가합니다.
+5. 테스트를 생성합니다. `@samples/book-app-project/books.py @samples/book-app-project/tests/test_books.py `잘못된 연도, 범위 반전, 검색 결과 없음과 같은 예외 상황을 포함하여 `find_by_year_range()` 함수에 대한 테스트를 생성합니다.`
+6. `/review` 명령으로 검토합니다.
+7. README 파일을 업데이트합니다. `@samples/book-app-project/README.md`에 다음 내용을 추가합니다. 새로운 "연도별 검색" 명령에 대한 문서를 작성합니다.
+8. 커밋 메시지를 생성합니다.
-Document your workflow as you go.
+진행 과정을 문서화하세요.
-**Success criteria**: You've completed the feature from idea to commit using Copilot CLI, including planning, implementation, tests, documentation, and review.
+**성공 기준**: Copilot CLI를 사용하여 아이디어 구상부터 커밋까지(계획, 구현, 테스트, 문서화 및 검토 포함) 기능을 완료했습니다.
-> 💡 **Bonus**: If you have agents set up from Chapter 04, try creating and using custom agents. For example, an error-handler agent for implementation review and a doc-writer agent for the README update.
+> 💡 **보너스**: 4장에서 에이전트를 설정했다면, 사용자 지정 에이전트를 만들어 사용해 보세요. 예를 들어, 구현 검토를 위한 오류 처리 에이전트와 README 업데이트를 위한 문서 작성 에이전트를 만들 수 있습니다.
-
@@ -27,73 +27,74 @@ This course is designed for:
-## 🎯 What You'll Learn
+## 🎯 배우게 될 것
-This hands-on course takes you from zero to productive with GitHub Copilot CLI. You'll work with a single Python book collection app throughout all chapters, progressively improving it using AI-assisted workflows. By the end, you'll confidently use AI to review code, generate tests, debug issues, and automate workflows: all from your terminal.
+이 실습 중심 과정은 GitHub Copilot CLI를 처음 접하는 사람도 바로 활용할 수 있도록 도와줍니다. 모든 챕터에서 하나의 Python 도서 컬렉션 앱을 사용하며, AI 기반 워크플로를 통해 점진적으로 개선해 나갑니다. 과정을 마치면 터미널에서 AI를 활용하여 코드 검토, 테스트 생성, 문제 디버깅, 워크플로 자동화 등을 자신 있게 수행할 수 있게 됩니다.
-**No AI experience required.** If you can use a terminal, you can learn this.
+**AI 경험은 필요 없습니다.** 터미널을 사용할 수 있다면 배울 수 있습니다.
-**Perfect for:** Developers, students, and anyone who has experience with software development.
+**개발자, 학생, 그리고 소프트웨어 개발 경험이 있는 모든 분들께 완벽함.
## ✅ Prerequisites
-Before starting, ensure you have:
+시작하기 전에 반드시 확인하세요:
-- **GitHub account**: [Create one free](https://github.com/signup)
-- **GitHub Copilot access**: [Free offering](https://github.com/features/copilot/plans), [Monthly subscription](https://github.com/features/copilot/plans), or [Free for students/teachers](https://education.github.com/pack)
-- **Terminal basics**: Comfortable with `cd`, `ls`, running commands +- **GitHub 계정**: [Create one free](https://github.com/signup)
+- **GitHub Copilot 접근 권한**: [Free offering](https://github.com/features/copilot/plans), [Monthly subscription](https://github.com/features/copilot/plans), or [Free for students/teachers](https://education.github.com/pack)
+- **터미널 기본 사용법**: `cd`, `ls` 명령어 사용 및 명령 실행에 익숙해야 함 -## 🤖 Understanding the GitHub Copilot Family +## 🤖 GitHub Copilot 가족 이해하기 -GitHub Copilot has evolved into a family of AI-powered tools. Here's where each one lives: +GitHub Copilot은 이제 AI 기반 도구 모음으로 발전했습니다. 각 도구의 위치는 다음과 같습니다.: -| Product | Where It Runs | Description | +| 제품 | 실행 환경 | 설명 | |---------|---------------|----------| -| [**GitHub Copilot CLI**](https://docs.github.com/copilot/how-tos/copilot-cli/cli-getting-started)
(this course) | Your terminal | Terminal-native AI coding assistant | -| [**GitHub Copilot**](https://docs.github.com/copilot) | VS Code, Visual Studio, JetBrains, etc. | Agent mode, chat, inline suggestions | -| [**Copilot on GitHub.com**](https://github.com/copilot) | GitHub | Immersive chat about your repos, create agents, and more | -| [**GitHub Copilot coding agent**](https://docs.github.com/copilot/using-github-copilot/using-copilot-coding-agent-to-work-on-tasks) | GitHub | Assign issues to agents, get PRs back | +| [**GitHub Copilot CLI**](https://docs.github.com/copilot/how-tos/copilot-cli/cli-getting-started)
(this course) | Your terminal | 터미널 네이티브 AI 코딩 어시스턴트 | +| [**GitHub Copilot**](https://docs.github.com/copilot) | VS Code, Visual Studio, JetBrains, etc. | 에이전트 모드, 채팅, 인라인 제안 | +| [**Copilot on GitHub.com**](https://github.com/copilot) | GitHub | 저장소에 대한 몰입감 있는 대화, 에이전트 생성 등 | +| [**GitHub Copilot coding agent**](https://docs.github.com/copilot/using-github-copilot/using-copilot-coding-agent-to-work-on-tasks) | GitHub | 이슈를 에이전트에게 할당하고, PR을 되찾으세요 | -This course focuses on **GitHub Copilot CLI**, bringing AI assistance directly to your terminal. +이 과정은 **GitHub Copilot CLI**에 중점을 두어 AI 지원을 직접 터미널로 제공합니다. -## 📚 Course Structure +## 📚 과정 구조  -| Chapter | Title | What You'll Build | +| 챕터 | 제목 | 만들게 될 것 | |:-------:|-------|-------------------| -| 00 | 🚀 [Quick Start](./00-quick-start/README.md) | Installation and verification | -| 01 | 👋 [First Steps](./01-setup-and-first-steps/README.md) | Live demos + three interaction modes | -| 02 | 🔍 [Context and Conversations](./02-context-conversations/README.md) | Multi-file project analysis | -| 03 | ⚡ [Development Workflows](./03-development-workflows/README.md) | Code review, debug, test generation | -| 04 | 🤖 [Create Specialized AI Assistants](./04-agents-custom-instructions/README.md) | Custom agents for your workflow | -| 05 | 🛠️ [Automate Repetitive Tasks](./05-skills/README.md) | Skills that load automatically | -| 06 | 🔌 [Connect to GitHub, Databases & APIs](./06-mcp-servers/README.md) | MCP server integration | -| 07 | 🎯 [Putting It All Together](./07-putting-it-together/README.md) | Complete feature workflows | +| 00 | 🚀 [Quick Start](./00-quick-start/README.md) | 설치 및 검증 | +| 01 | 👋 [First Steps](./01-setup-and-first-steps/README.md) | 라이브 데모 + 세 가지 상호작용 모드 | +| 02 | 🔍 [Context and Conversations](./02-context-conversations/README.md) | 다중 파일 프로젝트 분석 | +| 03 | ⚡ [Development Workflows](./03-development-workflows/README.md) | 코드 리뷰, 디버그, 테스트 생성| +| 04 | 🤖 [Create Specialized AI Assistants](./04-agents-custom-instructions/README.md) | 워크플로우에 맞는 맞춤 에이전트 | +| 05 | 🛠️ [Automate Repetitive Tasks](./05-skills/README.md) | 자동으로 로드되는 스킬들 | +| 06 | 🔌 [Connect to GitHub, Databases & APIs](./06-mcp-servers/README.md) | MCP 서버 통합 | +| 07 | 🎯 [Putting It All Together](./07-putting-it-together/README.md) | 완전한 기능 워크플로우 | -## 📖 How This Course Works +## 📖 이 과정의 작동 방식 -Each chapter follows the same pattern: +각 장은 같은 패턴을 따릅니다: -1. **Real-World Analogy**: Understand the concept through familiar comparisons -2. **Core Concepts**: Learn the essential knowledge -3. **Hands-On Examples**: Run actual commands and see results -4. **Assignment**: Practice what you learned -5. **What's Next**: Preview of the following chapter +1. **Real-World Analogy**: 친숙한 비교를 통해 개념을 이해하세요 +2. **Core Concepts**: 필수 지식을 배우세요 +3. **Hands-On Examples**: 실제 명령을 실행해 보고 결과를 확인하세요 +4. **Assignment**: 배운 것을 연습하세요 +5. **What's Next**: 다음 장 미리보기 -**Code examples are runnable.** Every copilot text block in this course can be copied and run in your terminal. +**코드 예제는 실행 가능합니다.** 이 강좌의 모든 Copilot 텍스트 블록은 복사하여 터미널에서 실행할 수 있습니다. -## 📋 GitHub Copilot CLI Command Reference +## 📋 GitHub Copilot CLI 명령어 참조 -The **[GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference)** helps you find commands and keyboard shortcuts to help you use Copilot CLI effectively. +**[GitHub Copilot CLI 명령어 참조](https://docs.github.com/en/copilot/reference/cli-command-reference)**는 Copilot CLI를 효과적으로 사용하는 데 도움이 되는 명령어와 단축키를 찾는 데 유용합니다. -## 🙋 Getting Help +## 🙋 도움 요청 -- 🐛 **Found a bug?** [Open an Issue](https://github.com/github/copilot-cli-for-beginners/issues) -- 🤝 **Want to contribute?** PRs welcome! -- 📚 **Official Docs:** [GitHub Copilot CLI Documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) +- 🐛 **버그를 발견하셨나요?** [이슈 제출](https://github.com/github/copilot-cli-for-beginners/issues) +- 🤝 **기여하고 싶으신가요?** PR을 환영합니다! -## License +- 📚 **공식 문서:** [GitHub Copilot CLI 문서](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) -This project is licensed under the terms of the MIT open source license. Please refer to the [LICENSE](./LICENSE) file for the full terms. +## 라이선스 + +이 프로젝트는 MIT 오픈 소스 라이선스 조건에 따라 배포됩니다. 전체 조건은 [LICENSE](./LICENSE) 파일을 참조하십시오. diff --git a/SECURITY.md b/SECURITY.md index 4279c87f..b70d73b7 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -1,31 +1,38 @@ -Thanks for helping make GitHub safe for everyone. +모두를 위한 안전한 GitHub 환경 조성에 도움을 주셔서 감사합니다. -# Security +# 보안 -GitHub takes the security of our software products and services seriously, including all of the open source code repositories managed through our GitHub organizations, such as [GitHub](https://github.com/GitHub). +GitHub는 GitHub 조직을 통해 관리되는 모든 오픈 소스 코드 저장소(예: [GitHub](https://github.com/GitHub))를 포함하여 소프트웨어 제품 및 서비스의 보안을 중요하게 생각합니다. -Even though [open source repositories are outside of the scope of our bug bounty program](https://bounty.github.com/index.html#scope) and therefore not eligible for bounty rewards, we will ensure that your finding gets passed along to the appropriate maintainers for remediation. +[오픈 소스 저장소는 버그 바운티 프로그램](https://bounty.github.com/index.html#scope)의 적용 범위에 포함되지 않으므로 바운티 보상 대상은 아니지만, 발견하신 내용은 해당 저장소 관리자에게 전달하여 수정 조치를 취하도록 하겠습니다. -## Reporting Security Issues +## 보안 문제 보고 -If you believe you have found a security vulnerability in any GitHub-owned repository, please report it to us through coordinated disclosure. +GitHub 소유 저장소에서 보안 취약점을 발견했다고 생각되면, 협력적 공개 방식을 통해 보고해 주세요. -**Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.** +**공개 GitHub 이슈, 토론 또는 풀 리퀘스트를 통해 보안 취약점을 보고하지 마세요.** -Instead, please send an email to opensource-security[@]github.com. +대신 opensource-security[@]github.com으로 이메일을 보내주세요. -Please include as much of the information listed below as you can to help us better understand and resolve the issue: - * The type of issue (e.g., buffer overflow, SQL injection, or cross-site scripting) - * Full paths of source file(s) related to the manifestation of the issue - * The location of the affected source code (tag/branch/commit or direct URL) - * Any special configuration required to reproduce the issue - * Step-by-step instructions to reproduce the issue - * Proof-of-concept or exploit code (if possible) - * Impact of the issue, including how an attacker might exploit the issue +문제를 더 잘 이해하고 해결하는 데 도움이 되도록 아래 정보를 최대한 자세히 포함해 주세요. -This information will help us triage your report more quickly. +* 문제 유형 (예: 버퍼 오버플로, SQL 인젝션, 크로스 사이트 스크립팅) -## Policy +* 문제 발생과 관련된 소스 파일의 전체 경로 -See [GitHub's Safe Harbor Policy](https://docs.github.com/en/site-policy/security-policies/github-bug-bounty-program-legal-safe-harbor#1-safe-harbor-terms) \ No newline at end of file +* 영향을 받는 소스 코드 위치 (태그/브랜치/커밋 또는 직접 URL) + +* 문제를 재현하는 데 필요한 특별 구성 + +* 문제 재현 단계별 지침 + +* 개념 증명 또는 익스플로잇 코드 (가능한 경우) + +* 공격자가 문제를 악용할 수 있는 방법을 포함한 문제의 영향 + +이러한 정보는 보고서를 더 신속하게 분류하는 데 도움이 됩니다. + +## 정책 + +[GitHub의 세이프 하버 정책](https://docs.github.com/en/site-policy/security-policies/github-bug-bounty-program-legal-safe-harbor#1-safe-harbor-terms)을 참조하세요. diff --git a/SUPPORT.md b/SUPPORT.md index aab64d4d..458e1bd6 100644 --- a/SUPPORT.md +++ b/SUPPORT.md @@ -1,11 +1,11 @@ -# Support +# 지원 -## How to file issues and get help +## 문제 보고 및 도움 요청 방법 -This project uses GitHub issues to track bugs and feature requests. Please search the existing issues before filing new issues to avoid duplicates. For new issues, file your bug or feature request as a new issue. +이 프로젝트는 버그 및 기능 요청을 추적하기 위해 GitHub 이슈를 사용합니다. 중복을 방지하기 위해 새 이슈를 제출하기 전에 기존 이슈를 검색해 주세요. 새로운 이슈를 제출할 때는 버그 또는 기능 요청을 새 이슈로 등록해 주세요. -For help or questions about using this project, please file an issue. +이 프로젝트 사용에 대한 도움이나 질문이 있는 경우 이슈를 등록해 주세요. -## GitHub Support Policy +## GitHub 지원 정책 -Support for this project is limited to the resources listed above. \ No newline at end of file +이 프로젝트에 대한 지원은 위에 명시된 리소스로 제한됩니다.
🔧 Common Mistakes & Troubleshooting (click to expand)
+🔧 흔히 발생하는 실수 및 문제 해결 방법 (클릭하여 펼치기)
### Common Mistakes @@ -751,33 +758,33 @@ copilot # This loads custom instructions by default --- -# Summary +# 요약 -## 🔑 Key Takeaways +## 🔑 핵심 요점 -1. **Built-in agents**: `/plan` and `/review` are directly invoked; Explore and Task work automatically -2. **Custom agents** are specialists defined in `.agent.md` files -3. **Good agents** have clear expertise, standards, and output formats -4. **Multi-agent collaboration** solves complex problems by combining expertise -5. **Instruction files** (`.instructions.md`) encode team standards for automatic application -6. **Consistent output** comes from well-defined agent instructions +1. **내장 에이전트**: `/plan` 및 `/review`가 직접 호출됩니다. 탐색 및 작업은 자동으로 수행됩니다. +2. **사용자 지정 에이전트**는 `.agent.md` 파일에 정의된 전문가입니다. +3. **우수한 에이전트**는 명확한 전문성, 표준 및 출력 형식을 갖추고 있습니다. +4. **다중 에이전트 협업**은 전문성을 결합하여 복잡한 문제를 해결합니다. +5. **지침 파일**(`.instructions.md`)은 자동 적용을 위한 팀 표준을 인코딩합니다. +6. **일관된 출력**은 잘 정의된 에이전트 지침에서 비롯됩니다. -> 📋 **Quick Reference**: See the [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for a complete list of commands and shortcuts. +> 📋 **빠른 참조**: 전체 명령 및 바로 가기 목록은 [GitHub Copilot CLI 명령 참조](https://docs.github.com/en/copilot/reference/cli-command-reference)를 참조하세요. --- -## ➡️ What's Next +## ➡️ 다음 단계 -Agents change *how Copilot approaches and takes targeted actions* in your code. Next, you'll learn about **skills** - which change *what steps* it follows. Wondering how agents and skills differ? Chapter 05 covers that head-on. +에이전트는 Copilot이 코드에서 특정 작업을 수행하는 방식(*어떻게 접근하고 실행하는지*)을 변경합니다. 다음으로는 Copilot이 따르는 단계(*어떤 단계를 따르는지*)를 변경하는 **스킬**에 대해 알아보겠습니다. 에이전트와 스킬의 차이점이 궁금하신가요? 5장에서 자세히 다룹니다. -In **[Chapter 05: Skills System](../05-skills/README.md)**, you'll learn: +**[5장: 스킬 시스템](../05-skills/README.md)**에서는 다음 내용을 학습합니다. -- How skills auto-trigger from your prompts (no slash command needed) -- Installing community skills -- Creating custom skills with SKILL.md files -- The difference between agents, skills, and MCP -- When to use each one +- 프롬프트에서 스킬이 자동으로 실행되는 방법(슬래시 명령 필요 없음) +- 커뮤니티 스킬 설치 +- SKILL.md 파일을 사용하여 사용자 지정 스킬 생성 +- 에이전트, 스킬, MCP의 차이점 +- 각각을 사용해야 하는 시점 --- -**[← Back to Chapter 03](../03-development-workflows/README.md)** | **[Continue to Chapter 05 →](../05-skills/README.md)** +**[← 3장으로 돌아가기](../03-development-workflows/README.md)** | **[5장으로 계속 →](../05-skills/README.md)** diff --git a/05-skills/README.md b/05-skills/README.md index b2150150..846d183e 100644 --- a/05-skills/README.md +++ b/05-skills/README.md @@ -1,113 +1,112 @@ - + -> **What if Copilot could automatically apply your team's best practices without you having to explain them every time?** +> **만약 Copilot이 매번 설명하지 않아도 팀의 모범 사례를 자동으로 적용할 수 있다면 어떨까요?** -In this chapter, you'll learn about Agent Skills: folders of instructions that Copilot automatically loads when relevant to your task. While agents change *how* Copilot thinks, skills teach Copilot *specific ways to complete tasks*. You'll create a security audit skill that Copilot applies whenever you ask about security, build team-standard review criteria that ensure consistent code quality, and learn how skills work across Copilot CLI, VS Code, and the Copilot coding agent. +이 장에서는 *에이전트 스킬(Agent Skills)*을 배웁니다. 에이전트 스킬은 Copilot이 작업과 관련 있다고 판단할 때 **자동으로 로드하는 지침 폴더**입니다. 에이전트가 Copilot이 *어떻게* 생각하는지를 바꾼다면, 스킬은 Copilot이 *특정 작업을 완료하는 구체적인 방식*을 가르칩니다. 여러분은 “보안”을 묻는 순간마다 Copilot이 적용하는 보안 감사 스킬을 만들고, 일관된 코드 품질을 보장하는 팀 표준 리뷰 기준을 구축하며, Copilot CLI, VS Code, Copilot 코딩 에이전트 전반에서 스킬이 어떻게 동작하는지 학습합니다. -## 🎯 Learning Objectives +## 🎯 학습 목표 -By the end of this chapter, you'll be able to: +이 장을 마치면 다음을 할 수 있습니다. -- Understand how Agent Skills work and when to use them -- Create custom skills with SKILL.md files -- Use community skills from shared repositories -- Know when to use skills vs agents vs MCP +- 에이전트 스킬이 어떻게 동작하는지, 언제 사용해야 하는지 이해한다 +- `SKILL.md` 파일로 커스텀 스킬을 만든다 +- 공유 저장소의 커뮤니티 스킬을 활용한다 +- 스킬 vs 에이전트 vs MCP를 언제 선택해야 하는지 안다 -> ⏱️ **Estimated Time**: ~55 minutes (20 min reading + 35 min hands-on) +> ⏱️ **예상 소요 시간**: 약 55분 (읽기 20분 + 실습 35분) --- -## 🧩 Real-World Analogy: Power Tools +## 🧩 현실 세계 비유: 전동 공구 -A general-purpose drill is useful, but specialized attachments make it powerful. -
+범용 드릴은 유용하지만, 특수한 부착물(비트/어댑터)을 끼우면 훨씬 강력해집니다.
+
-Skills work the same way. Just like swapping drill bits for different jobs, you can add skills to Copilot for different tasks:
+스킬도 같은 방식으로 동작합니다. 드릴 비트를 작업에 맞게 바꾸듯, Copilot에 다양한 작업용 스킬을 추가할 수 있습니다.
-| Skill Attachment | Purpose |
-|------------|---------|
-| `commit` | Generate consistent commit messages |
-| `security-audit` | Check for OWASP vulnerabilities |
-| `generate-tests` | Create comprehensive pytest tests |
-| `code-checklist` | Apply team code quality standards |
+| 스킬 부착물 | 목적 |
+|------------|------|
+| `commit` | 일관된 커밋 메시지 생성 |
+| `security-audit` | OWASP 취약점 점검 |
+| `generate-tests` | 포괄적인 pytest 테스트 생성 |
+| `code-checklist` | 팀 코드 품질 표준 적용 |
-
-*Skills are specialized attachments that extend what Copilot can do*
+*스킬은 Copilot이 할 수 있는 일을 확장하는 특수 부착물입니다*
---
-# How Skills Work
+# 스킬은 어떻게 동작하나요?
-
+
-Learn what skills are, why they matter, and how they differ from agents and MCP.
+스킬이 무엇인지, 왜 중요한지, 그리고 에이전트 및 MCP와 어떻게 다른지 알아봅니다.
---
-## *New to Skills?* Start Here!
+## *스킬이 처음이라면?* 여기서 시작하세요!
-1. **See what skills are already available:**
+1. **이미 어떤 스킬이 있는지 확인하기:**
```bash
copilot
> /skills list
```
- This shows all skills Copilot can find in your project and personal folders.
+ 이 명령은 Copilot이 프로젝트 폴더와 개인 폴더에서 찾을 수 있는 모든 스킬을 보여줍니다.
-2. **Look at a real skill file:** Check out our provided [code-checklist SKILL.md](../.github/skills/code-checklist/SKILL.md) to see the pattern. It's just YAML frontmatter plus markdown instructions.
+2. **실제 스킬 파일 보기:** 제공된 [code-checklist SKILL.md](../.github/skills/code-checklist/SKILL.md)를 확인해 패턴을 보세요. YAML 프런트매터 + 마크다운 지침으로 구성됩니다.
-3. **Understand the core concept:** Skills are task-specific instructions that Copilot loads *automatically* when your prompt matches the skill's description. You don't need to activate them, just ask naturally.
+3. **핵심 개념 이해하기:** 스킬은 프롬프트가 스킬의 `description`과 매칭될 때 Copilot이 *자동으로 로드하는* 작업별 지침입니다. 매번 활성화할 필요 없이 자연스럽게 질문하면 됩니다.
-## Understanding Skills
+## 스킬 이해하기
-Agent Skills are folders containing instructions, scripts, and resources that Copilot **automatically loads when relevant** to your task. Copilot reads your prompt, checks if any skills match, and applies the relevant instructions automatically.
+에이전트 스킬은 지침, 스크립트, 리소스를 담고 있는 폴더로, Copilot이 **작업과 관련 있다고 판단하면 자동으로 로드**합니다. Copilot은 프롬프트를 읽고, 매칭되는 스킬이 있는지 확인한 뒤, 관련 지침을 자동으로 적용합니다.
```bash
copilot
> Check books.py against our quality checklist
-# Copilot detects this matches your "code-checklist" skill
-# and automatically applies its Python quality checklist
+# Copilot이 이것이 "code-checklist" 스킬과 매칭된다고 판단하고
+# 해당 파이썬 품질 체크리스트를 자동으로 적용
> Generate tests for the BookCollection class
-# Copilot loads your "pytest-gen" skill
-# and applies your preferred test structure
+# Copilot이 "pytest-gen" 스킬을 로드하고
+# 선호하는 테스트 구조를 적용
> What are the code quality issues in this file?
-# Copilot loads your "code-checklist" skill
-# and checks against your team's standards
+# Copilot이 "code-checklist" 스킬을 로드하고
+# 팀 표준에 따라 점검
```
-> 💡 **Key Insight**: Skills are **automatically triggered** based on your prompt matching the skill's description. Just ask naturally and Copilot applies relevant skills behind the scenes. You can also invoke skills directly as well which you'll learn about next.
+> 💡 **핵심 인사이트**: 스킬은 프롬프트가 스킬의 설명과 매칭되면 **자동으로 트리거**됩니다. 자연스럽게 요청하면 Copilot이 뒤에서 관련 스킬을 적용합니다. 다음에는 스킬을 직접 호출하는 방법도 배웁니다.
-> 🧰 **Ready-to-use templates**: Check out the [.github/skills](../.github/skills/) folder for simple copy-paste skills you can try out.
+> 🧰 **바로 쓸 수 있는 템플릿**: 간단히 복사/붙여넣기 해서 사용해볼 수 있는 스킬이 [.github/skills](../.github/skills/) 폴더에 있습니다.
-### Direct Slash Command Invocation
+### 슬래시 명령으로 직접 호출하기
-While auto-triggering is the primary way skills work, you can also **invoke skills directly** using their name as a slash command:
+자동 트리거가 스킬의 기본 동작 방식이지만, **스킬 이름을 슬래시 명령으로 직접 호출**할 수도 있습니다.
```bash
-> /generate-tests Create tests for the user authentication module
+> /generate-tests 사용자 인증 모듈에 대한 테스트를 만들어줘
-> /code-checklist Check books.py for code quality issues
+> /code-checklist books.py에서 코드 품질 문제를 확인해줘
-> /security-audit Check the API endpoints for vulnerabilities
+> /security-audit API 엔드포인트의 취약점을 점검해줘
```
-This gives you explicit control when you want to ensure a specific skill is used.
+특정 스킬이 반드시 사용되길 원할 때, 이렇게 명시적으로 제어할 수 있습니다.
-> 📝 **Skills vs Agents Invocation**: Don't confuse skill invocation with agent invocation:
-> - **Skills**: `/skill-name
+
-| Feature | What It Does | When to Use |
-|---------|--------------|-------------|
-| **Agents** | Changes how AI thinks | Need specialized expertise across many tasks |
-| **Skills** | Provides task-specific instructions | Specific, repeatable tasks with detailed steps |
-| **MCP** | Connects external services | Need live data from APIs |
+| 기능 | 무엇을 하나요 | 언제 쓰나요 |
+|------|---------------|------------|
+| **에이전트(Agents)** | AI가 생각하는 방식을 바꿈 | 다양한 작업 전반에 걸친 전문성이 필요할 때 |
+| **스킬(Skills)** | 작업별 구체 지침 제공 | 반복 가능한 특정 작업에 대한 상세한 절차가 필요할 때 |
+| **MCP** | 외부 서비스 연결 | API에서 실시간 데이터가 필요할 때 |
-Use agents for broad expertise, skills for specific task instructions, and MCP for external data. An agent can use one or more skills during a conversation. For example, when you ask an agent to check your code, it might apply both a `security-audit` skill and a `code-checklist` skill automatically.
+광범위한 전문성은 에이전트, 구체적인 작업 지침은 스킬, 외부 데이터는 MCP가 담당합니다. 에이전트는 대화 중 하나 이상의 스킬을 함께 사용할 수 있습니다. 예를 들어 코드를 점검해달라고 요청하면, `security-audit` 스킬과 `code-checklist` 스킬을 모두 자동으로 적용할 수 있습니다.
-> 📚 **Learn More**: See the official [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills) documentation for the complete reference on skill formats and best practices.
+> 📚 **더 알아보기**: 스킬 포맷과 모범 사례의 전체 참조는 공식 문서 [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)를 참고하세요.
---
-## From Manual Prompts to Automatic Expertise
+## 수동 프롬프트에서 자동 전문성으로
-Before diving into how to create skills, let's see *why* they're worth learning. Once you see the consistency gains, the "how" will make more sense.
+스킬을 만드는 방법을 배우기 전에, *왜* 스킬이 가치 있는지 먼저 보겠습니다. 일관성 향상을 체감하면 “방법”이 더 쉽게 이해됩니다.
-### Before Skills: Inconsistent Reviews
+### 스킬 이전: 들쑥날쑥한 리뷰
-Every code review, you might forget something:
+코드 리뷰를 할 때마다 무언가를 놓치기 쉽습니다.
```bash
copilot
> Review this code for issues
-# Generic review - might miss your team's specific concerns
+# 일반적인 리뷰 - 팀의 구체적인 관심사를 놓칠 수 있음
```
-Or you write a long prompt every time:
+혹은 매번 긴 프롬프트를 작성합니다.
```bash
> Review this code checking for bare except clauses, missing type hints,
@@ -158,11 +157,11 @@ Or you write a long prompt every time:
> functions over 50 lines, print statements in production code...
```
-Time: **30+ seconds** to type. Consistency: **varies by memory**.
+시간: 타이핑 **30초+**. 일관성: **기억에 따라 들쑥날쑥**.
-### After Skills: Automatic Best Practices
+### 스킬 이후: 모범 사례 자동 적용
-With a `code-checklist` skill installed, just ask naturally:
+`code-checklist` 스킬이 설치되어 있다면, 자연스럽게 이렇게만 요청하면 됩니다.
```bash
copilot
@@ -170,58 +169,58 @@ copilot
> Check the book collection code for quality issues
```
-**What happens behind the scenes**:
-1. Copilot sees "code quality" and "issues" in your prompt
-2. Checks skill descriptions, finds your `code-checklist` skill matches
-3. Automatically loads your team's quality checklist
-4. Applies all checks without you listing them
+**뒤에서 일어나는 일**:
+1. Copilot이 프롬프트에서 "code quality"와 "issues" 같은 키워드를 감지
+2. 스킬 설명을 확인하고 `code-checklist` 스킬이 매칭됨을 발견
+3. 팀의 품질 체크리스트를 자동 로드
+4. 목록을 직접 나열하지 않아도 모든 점검 항목을 적용
-
+
-*Just ask naturally. Copilot matches your prompt to the right skill and applies it automatically.*
+*자연스럽게 질문하기만 하면 됩니다. Copilot이 프롬프트를 적절한 스킬과 매칭해 자동으로 적용합니다.*
-**Output**:
+**출력 예시**:
```
-## Code Checklist: books.py
-
-### Code Quality
-- [PASS] All functions have type hints
-- [PASS] No bare except clauses
-- [PASS] No mutable default arguments
-- [PASS] Context managers used for file I/O
-- [PASS] Functions are under 50 lines
-- [PASS] Variable and function names follow PEP 8
-
-### Input Validation
-- [FAIL] User input is not validated - add_book() accepts any year value
-- [FAIL] Edge cases not fully handled - empty strings accepted for title/author
-- [PASS] Error messages are clear and helpful
-
-### Testing
-- [FAIL] No corresponding pytest tests found
-
-### Summary
-3 items need attention before merge
+## 코드 체크리스트: books.py
+
+### 코드 품질
+- [PASS] 모든 함수에 타입 힌트가 있음
+- [PASS] bare except 절이 없음
+- [PASS] mutable 기본 인자가 없음
+- [PASS] 파일 I/O에 컨텍스트 매니저 사용
+- [PASS] 함수가 50줄 이하
+- [PASS] 변수/함수 이름이 PEP 8을 따름
+
+### 입력 검증
+- [FAIL] 사용자 입력이 검증되지 않음 - add_book()이 어떤 연도 값이든 받음
+- [FAIL] 엣지 케이스가 완전히 처리되지 않음 - 제목/저자에 빈 문자열 허용
+- [PASS] 오류 메시지가 명확하고 도움이 됨
+
+### 테스트
+- [FAIL] 해당 pytest 테스트가 없음
+
+### 요약
+병합 전에 3개 항목을 수정해야 함
```
-**The difference**: Your team's standards are applied automatically, every time, without typing them out.
+**차이점**: 팀의 표준이 매번, 자동으로, 프롬프트를 길게 쓰지 않아도 적용됩니다.
---
-
---
-## Consistency at Scale: Team PR Review Skill
+## 규모 있는 일관성: 팀 PR 리뷰 스킬
-Imagine your team has a 10-point PR checklist. Without a skill, every developer must remember all 10 points, and someone always forgets one of them. With a `pr-review` skill, the entire team gets consistent reviews:
+팀에 10개 항목의 PR 체크리스트가 있다고 해봅시다. 스킬이 없다면 모든 개발자가 10개를 외워야 하고, 누군가는 항상 하나를 빼먹습니다. `pr-review` 스킬이 있다면, 팀 전체가 일관된 리뷰를 얻습니다.
```bash
copilot
@@ -229,252 +228,250 @@ copilot
> Can you review this PR?
```
-Copilot automatically loads your team's `pr-review` skill and checks all 10 points:
+Copilot이 팀의 `pr-review` 스킬을 자동으로 로드하고 10개 항목을 모두 점검합니다.
```
-PR Review: feature/user-auth
+PR 리뷰: feature/user-auth
-## Security ✅
-- No hardcoded secrets
-- Input validation present
-- No bare except clauses
+## 보안 ✅
+- 하드코딩된 시크릿 없음
+- 입력 검증 존재
+- bare except 절 없음
-## Code Quality ⚠️
-- [WARN] print statement on line 45 - remove before merge
-- [WARN] TODO on line 78 missing issue reference
-- [WARN] Missing type hints on public functions
+## 코드 품질 ⚠️
+- [WARN] 45행의 print 문 - 병합 전 제거
+- [WARN] 78행의 TODO에 이슈 참조가 없음
+- [WARN] 공개 함수에 타입 힌트 누락
-## Testing ✅
-- New tests added
-- Edge cases covered
+## 테스트 ✅
+- 새 테스트 추가됨
+- 엣지 케이스 포함
-## Documentation ❌
-- [FAIL] Breaking change not documented in CHANGELOG
-- [FAIL] API changes need OpenAPI spec update
+## 문서 ❌
+- [FAIL] BREAKING CHANGE가 CHANGELOG에 기록되지 않음
+- [FAIL] API 변경에 OpenAPI 스펙 업데이트 필요
```
-**The power**: Every team member applies the same standards automatically. New hires don't need to memorize the checklist because the skill handles it.
+**효과**: 모든 팀원이 동일한 기준을 자동으로 적용합니다. 신규 입사자도 체크리스트를 외울 필요가 없습니다. 스킬이 대신해주니까요.
---
-# Creating Custom Skills
+# 커스텀 스킬 만들기
-🎬 See it in action!
+🎬 실제 동작 보기!
 -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 상황에 따라 달라질 수 있습니다. 모델/도구/응답은 예시와 다를 수 있습니다.*
+
-Build your own skills from SKILL.md files.
+`SKILL.md` 파일로 스킬을 직접 만들어봅니다.
---
-## Skill Locations
+## 스킬 위치
-Skills are stored in `.github/skills/` (project-specific) or `~/.copilot/skills/` (user level).
+스킬은 `.github/skills/`(프로젝트 단위) 또는 `~/.copilot/skills/`(사용자 단위)에 저장됩니다.
-### How Copilot Finds Skills
+### Copilot이 스킬을 찾는 방법
-Copilot automatically scans these locations for skills:
+Copilot은 다음 위치를 자동으로 스캔해 스킬을 찾습니다.
-| Location | Scope |
-|----------|-------|
-| `.github/skills/` | Project-specific (shared with team via git) |
-| `~/.copilot/skills/` | User-specific (your personal skills) |
+| 위치 | 범위 |
+|------|------|
+| `.github/skills/` | 프로젝트 단위(깃으로 팀과 공유) |
+| `~/.copilot/skills/` | 사용자 단위(개인 스킬) |
-### Skill Structure
+### 스킬 구조
-Each skill lives in its own folder with a `SKILL.md` file. You can optionally include scripts, examples, or other resources:
+각 스킬은 `SKILL.md` 파일이 들어 있는 독립 폴더에 위치합니다. 선택적으로 스크립트/예제/리소스도 포함할 수 있습니다.
```
.github/skills/
└── my-skill/
- ├── SKILL.md # Required: Skill definition and instructions
- ├── examples/ # Optional: Example files Copilot can reference
+ ├── SKILL.md # 필수: 스킬 정의 및 지침
+ ├── examples/ # 선택: Copilot이 참고할 예제 파일
│ └── sample.py
- └── scripts/ # Optional: Scripts the skill can use
+ └── scripts/ # 선택: 스킬에서 사용할 스크립트
└── validate.sh
```
-> 💡 **Tip**: The directory name should match the `name` in your SKILL.md frontmatter (lowercase with hyphens).
+> 💡 **팁**: 디렉터리 이름은 `SKILL.md`의 `name` 값(하이픈 사용 소문자)과 일치하는 것이 좋습니다.
-### SKILL.md Format
+### SKILL.md 형식
-Skills use a simple markdown format with YAML frontmatter:
+스킬은 YAML 프런트매터가 있는 간단한 마크다운 형식을 사용합니다.
```markdown
---
name: code-checklist
-description: Comprehensive code quality checklist with security, performance, and maintainability checks
+description: 보안, 성능, 유지보수성 점검을 포함한 포괄적인 코드 품질 체크리스트
license: MIT
---
-# Code Checklist
+# 코드 체크리스트
-When checking code, look for:
+코드를 점검할 때 다음을 확인합니다.
-## Security
-- SQL injection vulnerabilities
-- XSS vulnerabilities
-- Authentication/authorization issues
-- Sensitive data exposure
+## 보안
+- SQL 인젝션 취약점
+- XSS 취약점
+- 인증/인가 이슈
+- 민감 데이터 노출
-## Performance
-- N+1 query problems (running one query per item instead of one query for all items)
-- Unnecessary loops or computations
-- Memory leaks
-- Blocking operations
+## 성능
+- N+1 쿼리 문제(항목마다 쿼리 1개가 아니라 전체를 위한 쿼리 1개를 쓰지 않는 경우)
+- 불필요한 루프/계산
+- 메모리 누수
+- 블로킹 작업
-## Maintainability
-- Function length (flag functions > 50 lines)
-- Code duplication
-- Missing error handling
-- Unclear naming
+## 유지보수성
+- 함수 길이(50줄 초과 함수 플래그)
+- 코드 중복
+- 에러 처리 누락
+- 불명확한 네이밍
-## Output Format
-Provide issues as a numbered list with severity:
-- [CRITICAL] - Must fix before merge
-- [HIGH] - Should fix before merge
-- [MEDIUM] - Should address soon
-- [LOW] - Nice to have
+## 출력 형식
+심각도와 함께 번호 매긴 목록으로 이슈를 제공합니다.
+- [CRITICAL] - 병합 전 반드시 수정
+- [HIGH] - 병합 전 수정 권장
+- [MEDIUM] - 곧 처리 필요
+- [LOW] - 있으면 좋은 개선
```
-**YAML Properties:**
+**YAML 속성:**
-| Property | Required | Description |
-|----------|----------|-------------|
-| `name` | **Yes** | Unique identifier (lowercase, hyphens for spaces) |
-| `description` | **Yes** | What the skill does and when Copilot should use it |
-| `license` | No | License that applies to this skill |
+| 속성 | 필수 | 설명 |
+|------|------|------|
+| `name` | **예** | 고유 식별자(소문자, 공백 대신 하이픈) |
+| `description` | **예** | 스킬이 무엇을 하는지, 언제 로드되어야 하는지 |
+| `license` | 아니오 | 이 스킬에 적용되는 라이선스 |
-> 📖 **Official docs**: [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)
+> 📖 **공식 문서**: [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)
-### Creating Your First Skill
+### 첫 스킬 만들기
-Let's build a security audit skill that checks for OWASP Top 10 vulnerabilities:
+OWASP Top 10 취약점을 점검하는 보안 감사 스킬을 만들어봅시다.
```bash
-# Create skill directory
+# 스킬 디렉터리 생성
mkdir -p .github/skills/security-audit
-# Create the SKILL.md file
+# SKILL.md 파일 생성
cat > .github/skills/security-audit/SKILL.md << 'EOF'
---
name: security-audit
-description: Security-focused code review checking OWASP (Open Web Application Security Project) Top 10 vulnerabilities
+description: OWASP(오픈 웹 애플리케이션 보안 프로젝트) Top 10 취약점을 점검하는 보안 중심 코드 리뷰
---
# Security Audit
-Perform a security audit checking for:
-
-## Injection Vulnerabilities
-- SQL injection (string concatenation in queries)
-- Command injection (unsanitized shell commands)
-- LDAP injection
-- XPath injection
-
-## Authentication Issues
-- Hardcoded credentials
-- Weak password requirements
-- Missing rate limiting
-- Session management flaws
-
-## Sensitive Data
-- Plaintext passwords
-- API keys in code
-- Logging sensitive information
-- Missing encryption
-
-## Access Control
-- Missing authorization checks
-- Insecure direct object references
-- Path traversal vulnerabilities
-
-## Output
-For each issue found, provide:
-1. File and line number
-2. Vulnerability type
-3. Severity (CRITICAL/HIGH/MEDIUM/LOW)
-4. Recommended fix
+다음을 확인하는 보안 감사를 수행합니다.
+
+## 인젝션 취약점
+- SQL 인젝션(쿼리에 문자열을 이어붙이는 경우)
+- 커맨드 인젝션(정제되지 않은 쉘 명령)
+- LDAP 인젝션
+- XPath 인젝션
+
+## 인증 이슈
+- 하드코딩된 자격 증명
+- 약한 비밀번호 요구사항
+- 레이트 리밋 미설정
+- 세션 관리 결함
+
+## 민감 데이터
+- 평문 비밀번호
+- 코드 내 API 키
+- 민감 정보를 로깅
+- 암호화 누락
+
+## 접근 제어
+- 인가 체크 누락
+- IDOR(불안전한 직접 객체 참조)
+- 경로 순회 취약점
+
+## 출력
+발견한 각 이슈에 대해 다음을 제공합니다.
+1. 파일과 라인 번호
+2. 취약점 유형
+3. 심각도(CRITICAL/HIGH/MEDIUM/LOW)
+4. 권장 수정 방법
EOF
-# Test your skill (skills load automatically based on your prompt)
+# 스킬 테스트(스킬은 프롬프트에 따라 자동으로 로드됨)
copilot
> @samples/book-app-project/ Check this code for security vulnerabilities
-# Copilot detects "security vulnerabilities" matches your skill
-# and automatically applies its OWASP checklist
+# Copilot이 "security vulnerabilities"가 스킬과 매칭된다고 판단하고
+# OWASP 체크리스트를 자동 적용
```
-**Expected output** (your results will vary):
-
+**예상 출력**(결과는 달라질 수 있음):
```
Security Audit: book-app-project
-[HIGH] Hardcoded file path (book_app.py, line 12)
- File path is hardcoded rather than configurable
- Fix: Use environment variable or config file
+[HIGH] 하드코딩된 파일 경로 (book_app.py, 12행)
+ 파일 경로가 설정 가능하지 않고 하드코딩되어 있음
+ 수정: 환경 변수 또는 설정 파일 사용
-[MEDIUM] No input validation (book_app.py, line 34)
- User input passed directly to function without sanitization
- Fix: Add input validation before processing
+[MEDIUM] 입력 검증 없음 (book_app.py, 34행)
+ 사용자 입력이 정제 없이 함수로 전달됨
+ 수정: 처리 전에 입력 검증 추가
-✅ No SQL injection found
-✅ No hardcoded credentials found
+✅ SQL 인젝션 없음
+✅ 하드코딩된 자격 증명 없음
```
---
-## Writing Good Skill Descriptions
+## 좋은 스킬 설명 작성하기
-The `description` field in your SKILL.md is crucial! It's how Copilot decides whether to load your skill:
+`SKILL.md`의 `description` 필드는 매우 중요합니다. Copilot이 스킬을 로드할지 결정하는 기준이기 때문입니다.
```markdown
---
name: security-audit
-description: Use for security reviews, vulnerability scanning,
- checking for SQL injection, XSS, authentication issues,
- OWASP Top 10 vulnerabilities, and security best practices
+description: 보안 리뷰, 취약점 스캐닝, SQL 인젝션, XSS, 인증 이슈,
+ OWASP Top 10 취약점을 점검하는 보안 모범 사례 점검에 사용
---
```
-> 💡 **Tip**: Include keywords that match how you naturally ask questions. If you say "security review," include "security review" in the description.
+> 💡 **팁**: 평소 질문할 때 쓰는 키워드를 설명에 넣으세요. "security review"라고 자주 말한다면 `description`에도 "security review"를 넣는 식입니다.
-### Combining Skills with Agents
+### 에이전트와 스킬 결합하기
-Skills and agents work together. The agent provides expertise, the skill provides specific instructions:
+스킬과 에이전트는 함께 작동합니다. 에이전트는 전문성을 제공하고, 스킬은 구체적인 지침을 제공합니다.
```bash
-# Start with a code-reviewer agent
+# code-reviewer 에이전트로 시작
copilot --agent code-reviewer
> Check the book app for quality issues
-# code-reviewer agent's expertise combines
-# with your code-checklist skill's checklist
+# code-reviewer 에이전트의 전문성과
+# code-checklist 스킬의 체크리스트가 결합
```
---
-# Managing and Sharing Skills
+# 스킬 관리 및 공유
-Discover installed skills, find community skills, and share your own.
+설치된 스킬을 확인하고, 커뮤니티 스킬을 찾고, 직접 공유하는 방법을 알아봅니다.
-
+
---
-## Managing Skills with the `/skills` Command
+## `/skills` 명령으로 스킬 관리하기
-Use the `/skills` command to manage your installed skills:
+`/skills` 명령을 사용해 설치된 스킬을 관리할 수 있습니다.
-| Command | What It Does |
-|---------|--------------|
-| `/skills list` | Show all installed skills |
-| `/skills info
-
---
-### When to Use `/skills reload`
+### `/skills reload`는 언제 쓰나요?
-After creating or editing a skill's SKILL.md file, run `/skills reload` to pick up the changes without restarting Copilot:
+스킬의 `SKILL.md`를 생성/수정한 뒤에는 Copilot을 재시작하지 않고 변경 사항을 반영하기 위해 `/skills reload`를 실행합니다.
```bash
-# Edit your skill file
-# Then in Copilot:
+# 스킬 파일을 편집한 뒤
+# Copilot에서:
> /skills reload
Skills reloaded successfully.
```
-> 💡 **Good to know**: Skills remain effective even after using `/compact` to summarize your conversation history. No need to reload after compacting.
+> 💡 **참고**: `/compact`로 대화 기록을 요약해도 스킬은 계속 유효합니다. compact 후에 reload 할 필요는 없습니다.
---
-## Finding and Using Community Skills
+## 커뮤니티 스킬 찾기 및 사용하기
-### Using Plugins to Install Skills
+### 플러그인으로 스킬 설치하기
-> 💡 **What are plugins?** Plugins are installable packages that can bundle skills, agents, and MCP server configurations together. Think of them as "app store" extensions for Copilot CLI.
+> 💡 **플러그인이란?** 플러그인은 스킬, 에이전트, MCP 서버 설정을 묶어서 배포할 수 있는 설치 가능한 패키지입니다. Copilot CLI의 “앱 스토어” 확장이라고 생각하면 됩니다.
-The `/plugin` command lets you browse and install these packages:
+`/plugin` 명령으로 패키지를 탐색하고 설치할 수 있습니다.
```bash
copilot
> /plugin list
-# Shows installed plugins
+# 설치된 플러그인 표시
> /plugin marketplace
-# Browse available plugins
+# 사용 가능한 플러그인 탐색
> /plugin install See it in action!
+실제 동작 보기!
 -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 출력은 상황에 따라 달라질 수 있습니다. 모델/도구/응답은 예시와 다를 수 있습니다.*
+
-Apply what you've learned by building and testing your own skills.
+배운 내용을 바탕으로 스킬을 직접 만들고 테스트해봅니다.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 해보기
-### Build More Skills
+### 더 많은 스킬 만들기
-Here are two more skills showing different patterns. Follow the same `mkdir` + `cat` workflow from "Creating Your First Skill" above or copy and paste the skills into the proper location. More examples are available in [.github/skills](../.github/skills).
+아래 두 스킬은 서로 다른 패턴을 보여줍니다. 앞서 "첫 스킬 만들기"에서 했던 `mkdir` + `cat` 워크플로를 그대로 따라 하거나, 스킬을 적절한 위치에 복사/붙여넣기 하세요. 더 많은 예시는 [.github/skills](../.github/skills)에 있습니다.
-### pytest Test Generation Skill
+### pytest 테스트 생성 스킬
-A skill that ensures consistent pytest structure across your codebase:
+코드베이스 전반에서 일관된 pytest 구조를 보장하는 스킬입니다.
```bash
mkdir -p .github/skills/pytest-gen
@@ -595,38 +592,38 @@ mkdir -p .github/skills/pytest-gen
cat > .github/skills/pytest-gen/SKILL.md << 'EOF'
---
name: pytest-gen
-description: Generate comprehensive pytest tests with fixtures and edge cases
+description: 픽스처와 엣지 케이스를 포함한 포괄적인 pytest 테스트를 생성
---
-# pytest Test Generation
+# pytest 테스트 생성
-Generate pytest tests that include:
+다음을 포함하는 pytest 테스트를 생성합니다.
-## Test Structure
-- Use pytest conventions (test_ prefix)
-- One assertion per test when possible
-- Clear test names describing expected behavior
-- Use fixtures for setup/teardown
+## 테스트 구조
+- pytest 규칙 사용(test_ 접두사)
+- 가능하면 테스트당 assertion 1개
+- 기대 동작을 설명하는 명확한 테스트 이름
+- setup/teardown을 위해 fixture 사용
-## Coverage
-- Happy path scenarios
-- Edge cases: None, empty strings, empty lists
-- Boundary values
-- Error scenarios with pytest.raises()
+## 커버리지
+- 정상 시나리오
+- 엣지 케이스: None, 빈 문자열, 빈 리스트
+- 경계값
+- pytest.raises()를 사용한 오류 시나리오
-## Fixtures
-- Use @pytest.fixture for reusable test data
-- Use tmpdir/tmp_path for file operations
-- Mock external dependencies with pytest-mock
+## 픽스처
+- 재사용 가능한 테스트 데이터를 위해 @pytest.fixture 사용
+- 파일 작업에는 tmpdir/tmp_path 사용
+- pytest-mock으로 외부 의존성 모킹
-## Output
-Provide complete, runnable test file with proper imports.
+## 출력
+올바른 import를 포함한, 실행 가능한 전체 테스트 파일을 제공합니다.
EOF
```
-### Team PR Review Skill
+### 팀 PR 리뷰 스킬
-A skill that enforces consistent PR review standards across your team:
+팀 전반에 일관된 PR 리뷰 기준을 적용하는 스킬입니다.
```bash
mkdir -p .github/skills/pr-review
@@ -634,231 +631,231 @@ mkdir -p .github/skills/pr-review
cat > .github/skills/pr-review/SKILL.md << 'EOF'
---
name: pr-review
-description: Team-standard PR review checklist
+description: 팀 표준 PR 리뷰 체크리스트
---
-# PR Review
+# PR 리뷰
-Review code changes against team standards:
+팀 표준에 따라 변경 사항을 리뷰합니다.
-## Security Checklist
-- [ ] No hardcoded secrets or API keys
-- [ ] Input validation on all user data
-- [ ] No bare except clauses
-- [ ] No sensitive data in logs
+## 보안 체크리스트
+- [ ] 하드코딩된 시크릿 또는 API 키 없음
+- [ ] 모든 사용자 데이터에 입력 검증
+- [ ] bare except 절 없음
+- [ ] 로그에 민감 데이터 없음
-## Code Quality
-- [ ] Functions under 50 lines
-- [ ] No print statements in production code
-- [ ] Type hints on public functions
-- [ ] Context managers for file I/O
-- [ ] No TODOs without issue references
+## 코드 품질
+- [ ] 함수 50줄 이하
+- [ ] 프로덕션 코드에 print 문 없음
+- [ ] 공개 함수에 타입 힌트
+- [ ] 파일 I/O에 컨텍스트 매니저 사용
+- [ ] 이슈 참조 없는 TODO 없음
-## Testing
-- [ ] New code has tests
-- [ ] Edge cases covered
-- [ ] No skipped tests without explanation
+## 테스트
+- [ ] 새 코드에 테스트가 있음
+- [ ] 엣지 케이스 포함
+- [ ] 설명 없는 skipped 테스트 없음
-## Documentation
-- [ ] API changes documented
-- [ ] Breaking changes noted
-- [ ] README updated if needed
+## 문서
+- [ ] API 변경 문서화
+- [ ] BREAKING CHANGE 기록
+- [ ] 필요 시 README 업데이트
-## Output Format
-Provide results as:
-- ✅ PASS: Items that look good
-- ⚠️ WARN: Items that could be improved
-- ❌ FAIL: Items that must be fixed before merge
+## 출력 형식
+결과를 다음과 같이 제공합니다.
+- ✅ PASS: 문제가 없어 보이는 항목
+- ⚠️ WARN: 개선 가능 항목
+- ❌ FAIL: 병합 전 반드시 수정해야 하는 항목
EOF
```
-### Go Further
+### 더 해보기
-1. **Skill Creation Challenge**: Create a `quick-review` skill that does a 3-point checklist:
- - Bare except clauses
- - Missing type hints
- - Unclear variable names
+1. **스킬 생성 챌린지**: 3가지 항목만 빠르게 점검하는 `quick-review` 스킬을 만들어보세요.
+ - bare except 절
+ - 타입 힌트 누락
+ - 불명확한 변수 이름
- Test it by asking: "Do a quick review of books.py"
+ "Do a quick review of books.py"라고 요청해 테스트합니다.
-2. **Skill Comparison**: Time yourself writing a detailed security review prompt manually. Then just ask "Check for security issues in this file" and let your security-audit skill load automatically. How much time did the skill save?
+2. **스킬 비교**: 수동으로 상세한 보안 리뷰 프롬프트를 작성하는 데 걸리는 시간을 재보세요. 그 다음 "Check for security issues in this file"이라고만 요청해 `security-audit` 스킬이 자동 로드되게 해보세요. 스킬이 시간을 얼마나 절약해줬나요?
-3. **Team Skill Challenge**: Think about your team's code review checklist. Could you encode it as a skill? Write down 3 things the skill should always check.
+3. **팀 스킬 챌린지**: 팀의 코드 리뷰 체크리스트를 떠올려 보세요. 스킬로 인코딩할 수 있을까요? 스킬이 항상 확인해야 할 3가지 항목을 적어보세요.
-**Self-Check**: You understand skills when you can explain why the `description` field matters (it's how Copilot decides whether to load your skill).
+**셀프 체크**: `description` 필드가 왜 중요한지(스킬 로딩의 기준) 설명할 수 있나요?
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: Build a Book Summary Skill
+### 메인 챌린지: 도서 요약 스킬 만들기
-The examples above created `pytest-gen` and `pr-review` skills. Now practice creating a completely different kind of skill: one for generating formatted output from data.
+앞의 예시는 `pytest-gen`과 `pr-review` 스킬을 만들었습니다. 이제 완전히 다른 종류의 스킬, 즉 데이터로부터 형식화된 출력(포맷)을 만드는 스킬을 연습해봅니다.
-1. List your current skills: Run Copilot and pass it `/skills list`. You can also use `ls .github/skills/` to see project skills or `ls ~/.copilot/skills/` for personal skills.
-2. Create a `book-summary` skill at `.github/skills/book-summary/SKILL.md` that generates a formatted markdown summary of the book collection
-3. Your skill should have:
- - Clear name and description (description is crucial for matching!)
- - Specific formatting rules (e.g., markdown table with title, author, year, read status)
- - Output conventions (e.g., use ✅/❌ for read status, sort by year)
-4. Test the skill: `@samples/book-app-project/data.json Summarize the books in this collection`
-5. Verify the skill auto-triggers by checking `/skills list`
-6. Try invoking it directly with `/book-summary Summarize the books in this collection`
+1. 현재 스킬 목록 보기: Copilot을 실행하고 `/skills list`를 입력하세요. 또는 프로젝트 스킬은 `ls .github/skills/`, 개인 스킬은 `ls ~/.copilot/skills/`로 확인할 수 있습니다.
+2. `.github/skills/book-summary/SKILL.md`에 `book-summary` 스킬을 만들어 도서 컬렉션의 형식화된 마크다운 요약을 생성하세요.
+3. 스킬은 다음을 포함해야 합니다.
+ - 명확한 name과 description(매칭을 위해 description이 매우 중요!)
+ - 구체적인 포맷 규칙(예: 제목/저자/연도/읽음 여부를 포함한 마크다운 테이블)
+ - 출력 규칙(예: 읽음 여부는 ✅/❌ 사용, 연도 기준 정렬)
+4. 스킬 테스트: `@samples/book-app-project/data.json Summarize the books in this collection`
+5. `/skills list`로 스킬 자동 트리거를 확인
+6. `/book-summary Summarize the books in this collection`로 직접 호출도 시도
-**Success criteria**: You have a working `book-summary` skill that Copilot automatically applies when you ask about the book collection.
+**성공 기준**: 도서 컬렉션을 물어볼 때 Copilot이 자동으로 적용하는 `book-summary` 스킬을 만들었다.
-
-### Bonus Challenge: Commit Message Skill
+### 보너스 챌린지: 커밋 메시지 스킬
-1. Create a `commit-message` skill that generates conventional commit messages with a consistent format
-2. Test it by staging a change and asking: "Generate a commit message for my staged changes"
-3. Document your skill and share it on GitHub with the `copilot-skill` topic
+1. conventional commit 메시지를 일관된 형식으로 생성하는 `commit-message` 스킬 만들기
+2. 변경 사항을 stage 한 뒤 "Generate a commit message for my staged changes"로 테스트
+3. 스킬을 문서화하고 `copilot-skill` 토픽으로 GitHub에 공유
---
💡 Hints (click to expand)
+💡 힌트(클릭하여 펼치기)
-**Starter template**: Create `.github/skills/book-summary/SKILL.md`: +**스타터 템플릿**: `.github/skills/book-summary/SKILL.md` 만들기 ```markdown --- name: book-summary -description: Generate a formatted markdown summary of a book collection +description: 도서 컬렉션의 형식화된 마크다운 요약을 생성 --- -# Book Summary Generator +# 도서 요약 생성기 -Generate a summary of the book collection following these rules: +다음 규칙에 따라 도서 컬렉션의 요약을 생성합니다. -1. Output a markdown table with columns: Title, Author, Year, Status -2. Use ✅ for read books and ❌ for unread books -3. Sort by year (oldest first) -4. Include a total count at the bottom -5. Flag any data issues (missing authors, invalid years) +1. Title, Author, Year, Status 컬럼을 가진 마크다운 테이블 출력 +2. 읽은 책은 ✅, 안 읽은 책은 ❌ 사용 +3. 연도 기준 정렬(오래된 순) +4. 마지막에 총 개수 포함 +5. 데이터 문제(저자 누락, 잘못된 연도 등)를 플래그 -Example: +예: | Title | Author | Year | Status | |-------|--------|------|--------| | 1984 | George Orwell | 1949 | ✅ | | Dune | Frank Herbert | 1965 | ❌ | -**Total: 2 books (1 read, 1 unread)** +**총계: 2권(읽음 1, 안 읽음 1)** ``` -**Test it:** +**테스트:** ```bash copilot > @samples/book-app-project/data.json Summarize the books in this collection -# The skill should auto-trigger based on the description match +# description 매칭에 따라 스킬이 자동 트리거되어야 함 ``` -**If it doesn't trigger:** Try `/skills reload` then ask again. +**트리거되지 않으면:** `/skills reload` 후 다시 질문하세요.
-
---
-# Summary
+# 요약
-## 🔑 Key Takeaways
+## 🔑 핵심 정리
-1. **Skills are automatic**: Copilot loads them when your prompt matches the skill's description
-2. **Direct invocation**: You can also invoke skills directly with `/skill-name` as a slash command
-3. **SKILL.md format**: YAML frontmatter (name, description, optional license) plus markdown instructions
-4. **Location matters**: `.github/skills/` for project/team sharing, `~/.copilot/skills/` for personal use
-5. **Description is key**: Write descriptions that match how you naturally ask questions
+1. **스킬은 자동**: 프롬프트가 스킬의 description과 매칭되면 Copilot이 자동 로드
+2. **직접 호출 가능**: `/skill-name`으로 슬래시 명령 호출도 가능
+3. **SKILL.md 형식**: YAML 프런트매터(name, description, optional license) + 마크다운 지침
+4. **위치가 중요**: 팀 공유는 `.github/skills/`, 개인용은 `~/.copilot/skills/`
+5. **description이 핵심**: 자연스럽게 묻는 방식과 맞는 키워드를 description에 포함
-> 📋 **Quick Reference**: See the [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for a complete list of commands and shortcuts.
+> 📋 **빠른 참고**: 전체 명령 및 단축키는 [GitHub Copilot CLI 명령 참조](https://docs.github.com/en/copilot/reference/cli-command-reference)를 참고하세요.
---
-## ➡️ What's Next
+## ➡️ 다음은?
-Skills extend what Copilot can do with auto-loaded instructions. But what about connecting to external services? That's where MCP comes in.
+스킬은 자동 로드 지침으로 Copilot의 능력을 확장합니다. 그렇다면 외부 서비스에 연결하는 것은 어떨까요? 그게 바로 MCP입니다.
-In **[Chapter 06: MCP Servers](../06-mcp-servers/README.md)**, you'll learn:
+**[챕터 06: MCP 서버](../06-mcp-servers/README.md)**에서 다음을 배웁니다.
-- What MCP (Model Context Protocol) is
-- Connecting to GitHub, filesystem, and documentation services
-- Configuring MCP servers
-- Multi-server workflows
+- MCP(Model Context Protocol)가 무엇인지
+- GitHub, 파일 시스템, 문서 서비스 연결
+- MCP 서버 구성
+- 멀티 서버 워크플로
---
-**[← Back to Chapter 04](../04-agents-custom-instructions/README.md)** | **[Continue to Chapter 06 →](../06-mcp-servers/README.md)**
+**[← 챕터 04로 돌아가기](../04-agents-custom-instructions/README.md)** | **[챕터 06으로 계속 →](../06-mcp-servers/README.md)"
\ No newline at end of file
diff --git a/06-mcp-servers/README.md b/06-mcp-servers/README.md
index 5bcddf85..90ef9079 100644
--- a/06-mcp-servers/README.md
+++ b/06-mcp-servers/README.md
@@ -1,67 +1,69 @@
-> **What if Copilot could read your GitHub issues, check your database, and create PRs... all from the terminal?**
+> **만약 Copilot이 터미널에서 GitHub 이슈를 읽고, 데이터베이스를 확인하고, PR을 생성할 수 있다면 어떨까요?**
-So far, Copilot can only work with what you give it directly: files you reference with `@`, conversation history, and its own training data. But what if it could reach out on its own to check your GitHub repository, browse your project files, or look up the latest documentation for a library?
+현재 Copilot은 사용자가 직접 제공하는 데이터, 즉 `@`로 참조하는 파일, 대화 기록, 그리고 자체 학습 데이터만을 활용할 수 있습니다. 하지만 Copilot이 스스로 GitHub 저장소를 확인하고, 프로젝트 파일을 탐색하거나, 라이브러리의 최신 문서를 찾아볼 수 있다면 어떨까요?
-That's what MCP (Model Context Protocol) does. It's a way to connect Copilot to external services so it has access to live, real-world data. Each service Copilot connects to is called an "MCP server." In this chapter, you'll set up a few of these connections and see how they make Copilot dramatically more useful.
+MCP(Model Context Protocol)는 바로 그런 역할을 합니다. MCP를 통해 Copilot은 외부 서비스에 연결하여 실시간 실제 데이터에 접근할 수 있습니다. Copilot이 연결하는 각 서비스를 "MCP 서버"라고 합니다. 이 장에서는 이러한 연결을 몇 가지 설정하고 이를 통해 Copilot의 활용도가 얼마나 크게 향상되는지 살펴보겠습니다.
-> 💡 **Already familiar with MCP?** [Jump to the quick start](#-use-the-built-in-github-mcp) to confirm it's working and start configuring servers.
+> 💡 **MCP를 이미 사용해 보셨나요?** [빠른 시작 가이드](#-github-mcp-서버-내장-기능-시작하기)로 이동하여 작동 여부를 확인하고 서버 구성을 시작하세요.
-## 🎯 Learning Objectives
+## 🎯 학습 목표
-By the end of this chapter, you'll be able to:
+이 장을 마치면 다음을 수행할 수 있게 됩니다.
-- Understand what MCP is and why it matters
-- Manage MCP servers using `/mcp` commands
-- Configure MCP servers for GitHub, filesystem, and documentation
-- Use MCP-powered workflows with the book app project
-- Know when and how to build a custom MCP server (optional)
+- MCP가 무엇이며 왜 중요한지 이해합니다.
+- `/mcp` 명령어를 사용하여 MCP 서버를 관리합니다.
+- GitHub, 파일 시스템 및 문서에 대한 MCP 서버를 구성합니다.
+- 책 앱 프로젝트에서 MCP 기반 워크플로를 사용합니다.
+- 사용자 지정 MCP 서버를 구축해야 하는 시점과 방법을 압니다(선택 사항).
-> ⏱️ **Estimated Time**: ~50 minutes (15 min reading + 35 min hands-on)
+> ⏱️ **예상 소요 시간**: 약 50분 (읽기 15분 + 실습 35분)
---
-## 🧩 Real-World Analogy: Browser Extensions
+## 🧩 실제 사례: 브라우저 확장 프로그램
🔧 Common Mistakes & Troubleshooting (click to expand)
+🔧 자주 하는 실수 & 문제 해결 (클릭하여 펼치기)
-### Common Mistakes +### 흔한 실수 -| Mistake | What Happens | Fix | -|---------|--------------|-----| -| Naming the file something other than `SKILL.md` | Skill won't be recognized | The file must be named exactly `SKILL.md` | -| Vague `description` field | Skill never gets loaded automatically | Description is the PRIMARY discovery mechanism. Use specific trigger words | -| Missing `name` or `description` in frontmatter | Skill fails to load | Add both fields in YAML frontmatter | -| Wrong folder location | Skill not found | Use `.github/skills/skill-name/` (project) or `~/.copilot/skills/skill-name/` (personal) | +| 실수 | 발생하는 일 | 해결 | +|------|------------|------| +| 파일 이름을 `SKILL.md`가 아닌 다른 이름으로 만듦 | 스킬이 인식되지 않음 | 파일 이름은 정확히 `SKILL.md`여야 함 | +| `description`이 모호�� | 자동으로 로드되지 않음 | description은 *주요 발견 메커니즘*. 트리거 키워드를 구체적으로 포함 | +| 프런트매터에 `name` 또는 `description` 누락 | 스킬 로드 실패 | YAML에 둘 다 추가 | +| 폴더 위치가 잘못됨 | 스킬을 찾지 못함 | `.github/skills/skill-name/`(프로젝트) 또는 `~/.copilot/skills/skill-name/`(개인) 사용 | -### Troubleshooting +### 트러블슈팅 -**Skill not being used** - If Copilot isn't using your skill when expected: +**스킬이 사용되지 않을 때** - Copilot이 기대한 스킬을 쓰지 않는다면: -1. **Check the description**: Does it match how you're asking? +1. **description 확인**: 내가 묻는 방식과 매칭되나요? ```markdown - # Bad: Too vague + # 나쁨: 너무 모호함 description: Reviews code - # Good: Includes trigger words + # 좋음: 트리거 키워드 포함 description: Use for code reviews, checking code quality, finding bugs, security issues, and best practice violations ``` -2. **Verify the file location**: +2. **파일 위치 확인**: ```bash - # Project skills + # 프로젝트 스킬 ls .github/skills/ - # User skills + # 개인 스킬 ls ~/.copilot/skills/ ``` -3. **Check SKILL.md format**: Frontmatter is required: +3. **SKILL.md 형식 확인**: 프런트매터는 필수입니다. ```markdown --- name: skill-name description: What the skill does and when to use it --- - + # Instructions here ``` -**Skill not appearing** - Verify the folder structure: +**스킬이 목록에 안 보일 때** - 폴더 구조를 확인하세요. ``` .github/skills/ -└── my-skill/ # Folder name - └── SKILL.md # Must be exactly SKILL.md (case-sensitive) +└── my-skill/ # 폴더 이름 + └── SKILL.md # SKILL.md(대소문자 구분, 정확히) ``` -Run `/skills reload` after creating or editing skills to ensure changes are picked up. +`/skills reload`를 실행해 수정 사항이 반영되게 하세요. -**Testing if a skill loads** - Ask Copilot directly: +**스킬이 로드되는지 테스트하기** - Copilot에게 직접 물어보세요. ```bash > What skills do you have available for checking code quality? -# Copilot will describe relevant skills it found +# Copilot이 찾은 관련 스킬을 설명함 ``` -**How do I know my skill is actually working?** +**스킬이 실제로 작동하는지 어떻게 알까요?** -1. **Check the output format**: If your skill specifies an output format (like `[CRITICAL]` tags), look for that in the response -2. **Ask directly**: After getting a response, ask "Did you use any skills for that?" -3. **Compare with/without**: Try the same prompt with `--no-custom-instructions` to see the difference: +1. **출력 형식 확인**: 스킬이 `[CRITICAL]` 같은 출력 규칙을 지정했다면 응답에 나타나는지 확인 +2. **직접 질문**: 응답 후 "Did you use any skills for that?"라고 질문 +3. **비교 테스트**: 동일한 프롬프트를 `--no-custom-instructions`로 실행해 차이를 확인 ```bash - # With skills + # 스킬 적용 copilot --allow-all -p "Review @file.py for security issues" - # Without skills (baseline comparison) + # 스킬 미적용(베이스라인 비교) copilot --allow-all -p "Review @file.py for security issues" --no-custom-instructions ``` -4. **Check for specific checks**: If your skill includes specific checks (like "functions over 50 lines"), see if those appear in the output +4. **특정 체크 확인**: 예를 들어 "functions over 50 lines" 같은 체크가 응답에 포함되는지 확인
-Think of MCP servers like browser extensions. Your browser on its own can display web pages, but extensions connect it to extra services:
+MCP 서버를 브라우저 확장 프로그램과 비슷하게 생각해 보세요. 브라우저 자체는 웹 페이지를 표시할 수 있지만, 확장 프로그램은 브라우저를 추가 서비스에 연결해 줍니다.
-| Browser Extension | What It Connects To | MCP Equivalent |
-|-------------------|---------------------|----------------|
-| Password manager | Your password vault | **GitHub MCP** → your repos, issues, PRs |
-| Grammarly | Writing analysis service | **Context7 MCP** → library documentation |
-| File manager | Cloud storage | **Filesystem MCP** → local project files |
+| 브라우저 확장 프로그램 | 연결 대상 | MCP와 유사한 기능 |
+|----------------------|-----------|-----------------|
+| 비밀번호 관리자 | 비밀번호 보관소 | **GitHub MCP** → 저장소, 이슈, PR |
+| Grammarly | 글쓰기 분석 서비스 | **Context7 MCP** → 라이브러리 문서 관리 |
+| 파일 관리자 | 클라우드 스토리지 | **파일 시스템 MCP** → 로컬 프로젝트 파일 |
-Without extensions, your browser is still useful, but with them, it becomes a powerhouse. MCP servers do the same for Copilot. They connect it to real, live data sources so it can read your GitHub issues, explore your file system, fetch up-to-date documentation, and more.
+확장 프로그램이 없어도 브라우저는 여전히 유용하지만, 확장 프로그램을 사용하면 강력한 도구로 거듭납니다. MCP 서버는 Copilot에도 똑같은 역할을 합니다. MCP 서버는 Copilot을 실제 데이터 소스에 연결하여 GitHub 이슈를 읽고, 파일 시스템을 탐색하고, 최신 문서를 가져오는 등 다양한 작업을 수행할 수 있도록 지원합니다.
-***MCP servers connect Copilot to the outside world: GitHub, repositories, documentation, and more***
+***MCP 서버는 Copilot을 외부 세계(GitHub, 저장소, 문서 등)에 연결합니다.***
-> 💡 **Key insight**: Without MCP, Copilot can only see files you explicitly share with `@`. With MCP, it can proactively explore your project, check your GitHub repo, and look up documentation, all automatically.
+> 💡 **핵심 정보**: MCP가 없으면 Copilot은 `@`로 명시적으로 공유한 파일만 볼 수 있습니다. MCP를 사용하면 Copilot은 프로젝트를 능동적으로 탐색하고, GitHub 저장소를 확인하고, 문서를 검색하는 등의 모든 작업을 자동으로 수행할 수 있습니다.
---
-# Quick Start: MCP in 30 Seconds
+# 빠른 시작: 30초 만에 MCP 시작하기
-## Get started with the built-in GitHub MCP server
-Let's see MCP in action right now, before configuring anything.
-The GitHub MCP server is included by default. Try this:
+## GitHub MCP 서버 내장 기능 시작하기
+
+설정을 하기 전에 MCP가 어떻게 작동하는지 바로 살펴보겠습니다.
+
+GitHub MCP 서버는 기본적으로 포함되어 있습니다. 다음을 시도해 보세요.
```bash
copilot
-> List the recent commits in this repository
+> 이 저장소의 최근 커밋 목록을 표시합니다.
```
-If Copilot returns real commit data, you've just seen MCP in action. That's the GitHub MCP server reaching out to GitHub on your behalf. But GitHub is just *one* server. This chapter shows you how to add more (filesystem access, up-to-date documentation, and others) so Copilot can do even more.
+Copilot이 실제 커밋 데이터를 반환한다면, MCP가 제대로 작동하는 것을 보신 겁니다. GitHub MCP 서버가 여러분을 대신하여 GitHub에 접속한 것이죠. 하지만 GitHub는 단 하나의 서버일 뿐입니다. 이 장에서는 파일 시스템 접근, 최신 문서 업데이트 등 Copilot이 더 많은 기능을 수행할 수 있도록 서버를 추가하는 방법을 보여줍니다.
---
-## The `/mcp show` Command
+## `/mcp show` 명령어
-Use `/mcp show` to see which MCP servers are configured and whether they're enabled:
+구성된 MCP 서버와 활성화 여부를 확인하려면 `/mcp show` 명령어를 사용하십시오.
```bash
copilot
@@ -73,59 +75,59 @@ MCP Servers:
✓ filesystem (enabled) - File system access
```
-> 💡 **Only seeing the GitHub server?** That's expected! If you haven't added any additional MCP servers yet, GitHub is the only one listed. You'll add more in the next section.
+> 💡 **GitHub 서버만 보이시나요?** 정상입니다! 아직 MCP 서버를 추가하지 않았다면 GitHub만 표시됩니다. 다음 섹션에서 더 많은 서버를 추가할 수 있습니다.
-> 📚 **Want to see all `/mcp` commands?** There are additional commands for adding, editing, enabling, and deleting servers. See the [full command reference](#-additional-mcp-commands) at the end of this chapter.
+> 📚 **모든 `/mcp` 명령어를 보고 싶으신가요?** 서버를 추가, 편집, 활성화 및 삭제하는 추가 명령어가 있습니다. 이 장의 끝에 있는 [전체 명령어 참조](#-추가-mcp-명령어)를 확인하세요.
-
---
-## What Changes with MCP?
+## MCP 도입 시 어떤 변화가 있을까요?
-Here's the difference MCP makes in practice:
+MCP가 실제로 가져오는 차이점은 다음과 같습니다.
-**Without MCP:**
+**MCP 미사용 시:**
```bash
-> What's in GitHub issue #42?
+> GitHub 이슈 #42에는 어떤 내용이 있나요?
-"I don't have access to GitHub. You'll need to copy and paste the issue content."
+"저는 GitHub에 접속할 수 없습니다. 문제 내용을 복사해서 붙여넣어 주셔야 합니다."
```
-**With MCP:**
+**MCP 사용 시:**
```bash
-> What's in GitHub issue #42 of this repository?
+> 이 저장소의 GitHub 이슈 #42에는 어떤 내용이 있나요?
-Issue #42: Login fails with special characters
-Status: Open
-Labels: bug, priority-high
-Description: Users report that passwords containing...
+문제 #42: 특수 문자가 포함된 비밀번호로 로그인 실패
+상태: 열림
+레이블: 버그, 우선순위 높음
+설명: 사용자들이 특수 문자가 포함된 비밀번호로 로그인할 경우 오류가 발생한다고 보고했습니다...
```
-MCP makes Copilot aware of your actual development environment.
+MCP는 사용자의 실제 개발 환경을 Copilot에 알려줍니다.
-> 📚 **Official Documentation**: [About MCP](https://docs.github.com/copilot/concepts/context/mcp) for a deeper look at how MCP works with GitHub Copilot.
+> 📚 **공식 문서**: GitHub Copilot과 MCP의 연동 방식에 대한 자세한 내용은 [MCP 소개](https://docs.github.com/copilot/concepts/context/mcp)를 참조하세요.
---
-# Configuring MCP Servers
+# MCP 서버 구성하기
🎬 See it in action!
+🎬 실제로 작동하는 모습을 확인해 보세요!
 -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 결과는 다를 수 있습니다. 사용하시는 모델, 도구 및 응답은 여기에 표시된 내용과 다를 수 있습니다.*
-Now that you've seen MCP in action, let's set up additional servers. This section covers the configuration file format and how to add new servers.
+MCP가 실제로 동작하는 모습을 보셨으니, 이제 추가 서버를 설정해 봅시다. 이 섹션에서는 구성 파일 형식과 새 서버를 추가하는 방법을 다룹니다.
---
-## MCP Configuration File
+## MCP 구성 파일
-MCP servers are configured in `~/.copilot/mcp-config.json` (user-level, applies to all projects) or `.vscode/mcp.json` (project-level, applies to just the current workspace).
+MCP 서버는 `~/.copilot/mcp-config.json`(사용자 수준, 모든 프로젝트에 적용) 또는 `.vscode/mcp.json`(프로젝트 수준, 현재 작업 공간에만 적용)에서 구성됩니다.
```json
{
@@ -140,44 +142,44 @@ MCP servers are configured in `~/.copilot/mcp-config.json` (user-level, applies
}
```
-*Most MCP servers are distributed as npm packages and run via the `npx` command.*
+*대부분의 MCP 서버는 npm 패키지로 배포되며 `npx` 명령어로 실행됩니다.*
-
---
-## Adding MCP Servers
+## MCP 서버 추가하기
-The GitHub MCP server is built-in and requires no setup. Below are additional servers you can add. **Pick what interests you, or work through them in order.**
+GitHub MCP 서버는 기본 내장되어 있어 별도 설정이 필요 없습니다. 아래는 추가로 설치할 수 있는 서버들입니다. **관심 있는 것을 선택하거나, 순서대로 진행하세요.**
-| I want to... | Jump to |
-|---|---|
-| Let Copilot browse my project files | [Filesystem Server](#filesystem-server) |
-| Get up-to-date library documentation | [Context7 Server](#context7-server-documentation) |
-| Explore optional extras (custom servers, web_fetch) | [Beyond the Basics](#beyond-the-basics) |
+| 원하는 기능 | 이동 |
+|-------------|------|
+| Copilot이 프로젝트 파일을 탐색하도록 허용 | [파일 시스템 서버](#파일-시스템-서버) |
+| 최신 라이브러리 문서 가져오기 | [Context7 서버](#context7-서버-문서) |
+| 선택 사항 추가 기능 탐색 (사용자 지정 서버, web_fetch) | [기본 이상의 기능](#기본-이상의-기능) |
💡 New to JSON? Click here to learn what each field means
- -| Field | What It Means | -|-------|---------------| -| `"mcpServers"` | Container for all your MCP server configurations | -| `"server-name"` | A name you choose (e.g., "github", "filesystem") | -| `"type": "local"` | The server runs on your machine | -| `"command": "npx"` | The program to run (npx runs npm packages) | -| `"args": [...]` | Arguments passed to the command | -| `"tools": ["*"]` | Allow all tools from this server | - -**Important JSON rules:** -- Use double quotes `"` for strings (not single quotes) -- No trailing commas after the last item -- File must be valid JSON (use a [JSON validator](https://jsonlint.com/) if unsure) +💡 JSON이 처음이신가요? 각 필드의 의미를 알아보려면 클릭하세요
+ +| 필드 | 의미 | +|------|------| +| `"mcpServers"` | 모든 MCP 서버 구성을 담는 컨테이너 | +| `"server-name"` | 사용자가 정하는 이름 (예: "github", "filesystem") | +| `"type": "local"` | 서버가 사용자의 로컬 머신에서 실행됨 | +| `"command": "npx"` | 실행할 프로그램 (npx는 npm 패키지를 실행함) | +| `"args": [...]` | 명령어에 전달할 인수 | +| `"tools": ["*"]` | 이 서버의 모든 도구 허용 | + +**JSON 규칙 중요 사항:** +- 문자열에는 큰따옴표 `"` 사용 (작은따옴표 사용 금지) +- 마지막 항목 뒤에 쉼표 없음 +- 파일은 유효한 JSON이어야 합니다 (확실하지 않은 경우 [JSON 유효성 검사기](https://jsonlint.com/) 사용)
-
Filesystem Server - Let Copilot explore your project files
- +파일 시스템 서버 - Copilot이 프로젝트 파일을 탐색하도록 허용
+ -### Filesystem Server +### 파일 시스템 서버 ```json { @@ -192,19 +194,19 @@ The GitHub MCP server is built-in and requires no setup. Below are additional se } ``` -> 💡 **The `.` path**: The `.` means "current directory". Copilot can access files relative to where you launched it. In a Codespace, this is your workspace root. You can also use an absolute path like `/workspaces/copilot-cli-for-beginners` if you prefer. +> 💡 **`.` 경로**: `.`는 "현재 디렉터리"를 의미합니다. Copilot은 실행된 위치를 기준으로 파일에 접근할 수 있습니다. Codespace에서는 워크스페이스 루트가 됩니다. 원하시면 `/workspaces/copilot-cli-for-beginners`와 같은 절대 경로를 사용할 수도 있습니다. -Add this to your `~/.copilot/mcp-config.json` and restart Copilot. +이 내용을 `~/.copilot/mcp-config.json`에 추가하고 Copilot을 재시작하세요.
-
Context7 Server - Get up-to-date library docs
- +Context7 서버 - 최신 라이브러리 문서 가져오기
+ -### Context7 Server (Documentation) +### Context7 서버 (문서) -Context7 gives Copilot access to up-to-date documentation for popular frameworks and libraries. Instead of relying on training data that might be outdated, Copilot fetches the actual current documentation. +Context7은 널리 사용되는 프레임워크 및 라이브러리의 최신 문서에 Copilot이 접근할 수 있게 해줍니다. 오래된 학습 데이터에 의존하는 대신, 실제 최신 문서를 직접 가져옵니다. ```json { @@ -219,33 +221,33 @@ Context7 gives Copilot access to up-to-date documentation for popular frameworks } ``` -- ✅ **No API key required** -- ✅ **No account needed** -- ✅ **Your code stays local** +- ✅ **API 키 불필요** +- ✅ **계정 불필요** +- ✅ **코드는 로컬에 유지됨** -Add this to your `~/.copilot/mcp-config.json` and restart Copilot. +이 내용을 `~/.copilot/mcp-config.json`에 추가하고 Copilot을 재시작하세요.
-
-
+
-### Complete Configuration File
+### 완전한 구성 파일
-Here's a full `mcp-config.json` with filesystem and Context7 servers:
+파일 시스템 및 Context7 서버가 포함된 전체 `mcp-config.json`입니다.
-> 💡 **Note:** GitHub MCP is built-in. You don't need to add it to your config file.
+> 💡 **참고:** GitHub MCP는 내장되어 있습니다. 구성 파일에 추가할 필요가 없습니다.
```json
{
@@ -333,125 +335,125 @@ Here's a full `mcp-config.json` with filesystem and Context7 servers:
}
```
-Save this as `~/.copilot/mcp-config.json` for global access or `.vscode/mcp.json` for project-specific configuration.
+전역 접근을 위해 `~/.copilot/mcp-config.json`으로 저장하거나, 프로젝트별 구성을 위해 `.vscode/mcp.json`으로 저장하세요.
---
-# Using MCP Servers
+# MCP 서버 사용하기
-Now that you have MCP servers configured, let's see what they can do.
+이제 MCP 서버를 구성했으니, 실제로 무엇을 할 수 있는지 살펴봅시다.
Beyond the Basics - Custom servers and web access (optional)
- +기본 이상의 기능 - 사용자 지정 서버 및 웹 접근 (선택 사항)
+ -These are optional extras for when you're comfortable with the core servers above. +위의 핵심 서버에 익숙해지면 사용할 수 있는 선택적 추가 기능입니다. -### Microsoft Learn MCP Server +### Microsoft Learn MCP 서버 -Every MCP server you've seen so far (filesystem, Context7) runs locally on your machine. But MCP servers can also run remotely, meaning you just point Copilot CLI at a URL and it handles the rest. No `npx` or `python`, no local process, no dependencies to install. +지금까지 살펴본 MCP 서버(파일 시스템, Context7)는 모두 로컬 머신에서 실행됩니다. 하지만 MCP 서버는 원격으로도 실행될 수 있습니다. 즉, Copilot CLI에 URL만 알려주면 나머지는 알아서 처리됩니다. `npx`나 `python`도 필요 없고, 로컬 프로세스나 설치해야 할 의존성도 없습니다. -The [Microsoft Learn MCP Server](https://github.com/microsoftdocs/mcp) is a good example. It gives Copilot CLI direct access to official Microsoft documentation (Azure, Microsoft Foundry and other AI topics, .NET, Microsoft 365, and much more) so it can search docs, fetch full pages, and find official code samples instead of relying on a model's training data. +[Microsoft Learn MCP 서버](https://github.com/microsoftdocs/mcp)가 좋은 예입니다. Copilot CLI가 공식 Microsoft 문서(Azure, Microsoft Foundry 및 기타 AI 주제, .NET, Microsoft 365 등)에 직접 접근하여 문서를 검색하고, 전체 페이지를 가져오고, 모델의 학습 데이터에 의존하는 대신 공식 코드 샘플을 찾을 수 있습니다. -- ✅ **No API key required** -- ✅ **No account needed** -- ✅ **No local install required** +- ✅ **API 키 불필요** +- ✅ **계정 불필요** +- ✅ **로컬 설치 불필요** -**Quick install with `/plugin install`:** +**`/plugin install`을 사용한 빠른 설치:** -Instead of editing your JSON config file manually, you can install it in one command: +JSON 구성 파일을 직접 편집하는 대신, 단 한 줄의 명령어로 설치할 수 있습니다. ```bash copilot @@ -253,26 +255,26 @@ copilot > /plugin install microsoftdocs/mcp ``` -This adds the server and its associated agent skills automatically. The skills installed include: +이 명령어는 서버와 관련 에이전트 스킬을 자동으로 추가합니다. 설치되는 스킬은 다음과 같습니다. -- **microsoft-docs**: Concepts, tutorials, and factual lookups -- **microsoft-code-reference**: API lookups, code samples, and troubleshooting -- **microsoft-skill-creator**: A meta-skill for generating custom skills about Microsoft technologies +- **microsoft-docs**: 개념, 튜토리얼, 사실 조회 +- **microsoft-code-reference**: API 조회, 코드 샘플 및 문제 해결 +- **microsoft-skill-creator**: Microsoft 기술에 관한 사용자 지정 스킬을 생성하는 메타 스킬 -**Usage:** +**사용 예:** ```bash copilot -> What's the recommended way to deploy a Python app to Azure App Service? Search Microsoft Learn. +> Python 앱을 Azure App Service에 배포하는 권장 방법은 무엇인가요? Microsoft Learn을 검색해 주세요. ``` -📚 Learn more: [Microsoft Learn MCP Server overview](https://learn.microsoft.com/training/support/mcp-get-started) +📚 자세히 알아보기: [Microsoft Learn MCP 서버 개요](https://learn.microsoft.com/training/support/mcp-get-started) -### Web Access with `web_fetch` +### `web_fetch`를 사용한 웹 접근 -Copilot CLI includes a built-in `web_fetch` tool that can fetch content from any URL. This is useful for pulling in READMEs, API docs, or release notes without leaving your terminal. No MCP server needed. +Copilot CLI에는 모든 URL의 콘텐츠를 가져올 수 있는 내장 `web_fetch` 도구가 있습니다. 터미널을 벗어나지 않고도 README, API 문서, 릴리스 노트 등을 불러올 때 유용합니다. MCP 서버가 따로 필요하지 않습니다. -You can control which URLs are accessible via `~/.copilot/config.json` (general Copilot settings), which is separate from `~/.copilot/mcp-config.json` (MCP server definitions). +`~/.copilot/config.json`(Copilot 일반 설정)을 통해 접근 가능한 URL을 제어할 수 있습니다. 이 파일은 `~/.copilot/mcp-config.json`(MCP 서버 정의)과는 별개입니다. ```json { @@ -289,30 +291,30 @@ You can control which URLs are accessible via `~/.copilot/config.json` (general } ``` -**Usage:** +**사용 예:** ```bash copilot -> Fetch and summarize the README from https://github.com/facebook/react +> https://github.com/facebook/react 의 README를 가져와서 요약해 주세요. ``` -### Building a Custom MCP Server +### 사용자 지정 MCP 서버 구축하기 -Want to connect Copilot to your own APIs, databases, or internal tools? You can build a custom MCP server in Python. This is completely optional since the pre-built servers (GitHub, filesystem, Context7) cover most use cases. +자신만의 API, 데이터베이스, 또는 내부 도구에 Copilot을 연결하고 싶으신가요? Python으로 사용자 지정 MCP 서버를 만들 수 있습니다. 미리 만들어진 서버(GitHub, 파일 시스템, Context7)가 대부분의 사용 사례를 커버하므로 이 작업은 완전히 선택 사항입니다. -📖 See the [Custom MCP Server Guide](mcp-custom-server.md) for a complete walkthrough using the book app as an example. +📖 책 앱을 예제로 사용하는 완전한 안내는 [사용자 지정 MCP 서버 가이드](mcp-custom-server.md)를 참조하세요. -📚 For more background, see the [MCP for Beginners course](https://github.com/microsoft/mcp-for-beginners). +📚 더 많은 배경 정보는 [MCP for Beginners 과정](https://github.com/microsoft/mcp-for-beginners)을 참조하세요.
---
-## Server Usage Examples
+## 서버 사용 예시
-**Pick a server to explore, or work through them in order.**
+**관심 있는 서버를 선택하거나, 순서대로 살펴보세요.**
-| I want to try... | Jump to |
-|---|---|
-| GitHub repos, issues, and PRs | [GitHub Server](#github-server-built-in) |
-| Browsing project files | [Filesystem Server Usage](#filesystem-server-usage) |
-| Library documentation lookup | [Context7 Server Usage](#context7-server-usage) |
-| Custom server, Microsoft Learn MCP and web_fetch usage | [Beyond the Basics Usage](#beyond-the-basics-usage) |
+| 시도하고 싶은 것 | 이동 |
+|----------------|------|
+| GitHub 저장소, 이슈, PR | [GitHub 서버](#github-서버-내장) |
+| 프로젝트 파일 탐색 | [파일 시스템 서버 사용법](#파일-시스템-서버-사용법) |
+| 라이브러리 문서 조회 | [Context7 서버 사용법](#context7-서버-사용법) |
+| 사용자 지정 서버, Microsoft Learn MCP 및 web_fetch 사용 | [기본 이상의 기능 사용법](#기본-이상의-기능-사용법) |
-
GitHub Server (Built-in) - Access repos, issues, PRs, and more
- +GitHub 서버 (내장) - 저장소, 이슈, PR 등에 접근
+ -### GitHub Server (Built-in) +### GitHub 서버 (내장) -The GitHub MCP server is **built-in**. If you logged into Copilot (which you did during initial setup), it already works. No configuration needed! +GitHub MCP 서버는 **내장**되어 있습니다. Copilot에 로그인했다면(초기 설정 시 완료), 이미 작동하고 있습니다. 별도 구성이 필요 없습니다! -> 💡 **Not working?** Run `/login` to re-authenticate with GitHub. +> 💡 **작동하지 않나요?** `/login`을 실행하여 GitHub에 다시 인증하세요.
-
-| Feature | Example |
-|---------|----------|
-| **Repository info** | View commits, branches, contributors |
-| **Issues** | List, create, search, and comment on issues |
-| **Pull requests** | View PRs, diffs, create PRs, check status |
-| **Code search** | Search code across repositories |
-| **Actions** | Query workflow runs and status |
+| 기능 | 예시 |
+|------|------|
+| **저장소 정보** | 커밋, 브랜치, 기여자 보기 |
+| **이슈** | 이슈 목록 조회, 생성, 검색 및 댓글 달기 |
+| **풀 리퀘스트** | PR 보기, 차이 확인, PR 생성, 상태 확인 |
+| **코드 검색** | 저장소 전체에서 코드 검색 |
+| **Actions** | 워크플로 실행 및 상태 쿼리 |
```bash
copilot
-# See recent activity in this repo
-> List the last 5 commits in this repository
+# 이 저장소의 최근 활동 보기
+> 이 저장소의 마지막 커밋 5개를 나열해 주세요.
-Recent commits:
-1. abc1234 - Update chapter 05 skills examples (2 days ago)
-2. def5678 - Add book app test fixtures (3 days ago)
-3. ghi9012 - Fix typo in chapter 03 README (4 days ago)
+최근 커밋:
+1. abc1234 - 5장 스킬 예제 업데이트 (2일 전)
+2. def5678 - 책 앱 테스트 픽스처 추가 (3일 전)
+3. ghi9012 - 3장 README 오타 수정 (4일 전)
...
-# Explore the repo structure
-> What branches exist in this repository?
+# 저장소 구조 탐색
+> 이 저장소에 어떤 브랜치가 있나요?
-Branches:
-- main (default)
-- chapter6 (current)
+브랜치:
+- main (기본)
+- chapter6 (현재)
-# Search for code patterns across the repo
-> Search this repository for files that import pytest
+# 저장소 전체에서 코드 패턴 검색
+> pytest를 임포트하는 파일을 이 저장소에서 검색해 주세요.
-Found 1 file:
+1개 파일 발견:
- samples/book-app-project/tests/test_books.py
```
-> 💡 **Working on your own fork?** If you forked this course repo, you can also try write operations like creating issues and pull requests. We'll practice that in the exercises below.
+> 💡 **자신의 포크에서 작업하시나요?** 이 강의 저장소를 포크했다면 이슈 생성, 풀 리퀘스트 생성 등 쓰기 작업도 시도해 볼 수 있습니다. 아래 연습 문제에서 실습해 보겠습니다.
-> ⚠️ **Don't see results?** The GitHub MCP operates on the repository's remote (on github.com), not just local files. Make sure your repo has a remote: run `git remote -v` to check.
+> ⚠️ **결과가 표시되지 않나요?** GitHub MCP는 로컬 파일이 아닌 저장소의 원격(github.com)에서 작동합니다. 저장소에 원격이 설정되어 있는지 확인하세요: `git remote -v`를 실행하여 확인하세요.
Authentication in Dev Containers
+개발 컨테이너에서의 인증
-- **GitHub Codespaces** (recommended): Authentication is automatic. The `gh` CLI inherits your Codespace token. No action needed. -- **Local dev container (Docker)**: Run `gh auth login` after the container starts, then restart Copilot. +- **GitHub Codespaces** (권장): 인증이 자동으로 이루어집니다. `gh` CLI가 Codespace 토큰을 상속받습니다. 별도 조치가 필요 없습니다. +- **로컬 개발 컨테이너 (Docker)**: 컨테이너 시작 후 `gh auth login`을 실행한 다음 Copilot을 재시작하세요. -**Troubleshooting authentication:** +**인증 문제 해결:** ```bash -# Check if you're authenticated +# 인증 상태 확인 gh auth status -# If not, log in +# 인증되지 않은 경우 로그인 gh auth login -# Verify GitHub MCP is connected +# GitHub MCP 연결 확인 copilot > /mcp show ```
-
Filesystem Server - Browse and analyze project files
- +파일 시스템 서버 - 프로젝트 파일 탐색 및 분석
+ -### Filesystem Server +### 파일 시스템 서버 -Once configured, the filesystem MCP provides tools that Copilot can use automatically: +구성이 완료되면 파일 시스템 MCP는 Copilot이 자동으로 사용할 수 있는 도구를 제공합니다. ```bash copilot -> How many Python files are in the book-app-project directory? +> book-app-project 디렉터리에 Python 파일이 몇 개 있나요? -Found 3 Python files in samples/book-app-project/: +samples/book-app-project/에서 Python 파일 3개 발견: - book_app.py - books.py - utils.py -> What's the total size of the data.json file? +> data.json 파일의 전체 크기는 얼마인가요? samples/book-app-project/data.json: 2.4 KB -> Find all functions that don't have type hints in the book app +> 책 앱에서 타입 힌트가 없는 모든 함수를 찾아주세요. -Found 2 functions without type hints: +타입 힌트가 없는 함수 2개 발견: - samples/book-app-project/utils.py:10 - get_user_choice() - samples/book-app-project/utils.py:14 - get_book_details() ``` @@ -459,19 +461,19 @@ Found 2 functions without type hints:
-
Context7 Server - Look up library documentation
- +Context7 서버 - 라이브러리 문서 조회
+ -### Context7 Server +### Context7 서버 ```bash copilot -> What are the best practices for using pytest fixtures? +> pytest 픽스처 사용의 모범 사례는 무엇인가요? -From pytest Documentation: +pytest 문서에서: -Fixtures - Use fixtures to provide a fixed baseline for tests: +픽스처 - 테스트의 고정 기준을 제공하기 위해 픽스처를 사용하세요: import pytest @@ -483,227 +485,226 @@ Fixtures - Use fixtures to provide a fixed baseline for tests: ] def test_find_by_author(sample_books): - # fixture is automatically passed as argument + # 픽스처는 인수로 자동 전달됩니다 results = [b for b in sample_books if "Orwell" in b["author"]] assert len(results) == 1 -Best practices: -- Use fixtures instead of setup/teardown methods -- Use tmp_path fixture for temporary files -- Use monkeypatch for modifying environment -- Scope fixtures appropriately (function, class, module, session) +모범 사례: +- setup/teardown 메서드 대신 픽스처 사용 +- 임시 파일에는 tmp_path 픽스처 사용 +- 환경 변경에는 monkeypatch 사용 +- 픽스처 범위를 적절히 설정 (function, class, module, session) -> How can I apply this to the book app's test file? +> 이것을 책 앱의 테스트 파일에 어떻게 적용할 수 있나요? -# Copilot now knows the official pytest patterns -# and can apply them to samples/book-app-project/tests/test_books.py +# Copilot은 이제 공식 pytest 패턴을 알고 있으며 +# samples/book-app-project/tests/test_books.py에 적용할 수 있습니다. ```
-
---
-## Multi-Server Workflows
+## 다중 서버 워크플로
-These workflows show why developers say "I never want to work without this again." Each example combines multiple MCP servers in a single session.
+이 워크플로들은 개발자들이 "이것 없이는 다시는 일하고 싶지 않다"고 말하는 이유를 보여줍니다. 각 예시는 단일 세션에서 여러 MCP 서버를 결합합니다.
Beyond the Basics - Custom server and web_fetch usage
- +기본 이상의 기능 - 사용자 지정 서버 및 web_fetch 사용법
+ -### Beyond the Basics +### 기본 이상의 기능 -**Custom MCP Server**: If you built the book-lookup server from the [Custom MCP Server Guide](mcp-custom-server.md), you can query your book collection directly: +**사용자 지정 MCP 서버**: [사용자 지정 MCP 서버 가이드](mcp-custom-server.md)에서 book-lookup 서버를 구축했다면, 책 컬렉션을 직접 쿼리할 수 있습니다. ```bash copilot -> Look up information about "1984" using the book lookup server. Search for books by George Orwell +> book lookup 서버를 사용하여 "1984"에 대한 정보를 조회해 주세요. George Orwell의 책을 검색해 주세요. ``` -**Microsoft Learn MCP**: If you installed the [Microsoft Learn MCP server](#microsoft-learn-mcp-server), you can look up official Microsoft documentation directly: +**Microsoft Learn MCP**: [Microsoft Learn MCP 서버](#microsoft-learn-mcp-서버)를 설치했다면, 공식 Microsoft 문서를 직접 조회할 수 있습니다. ```bash copilot -> How do I configure managed identity for an Azure Function? Search Microsoft Learn. +> Azure Function에 대해 관리형 ID를 구성하는 방법은 무엇인가요? Microsoft Learn을 검색해 주세요. ``` -**Web Fetch**: Use the built-in `web_fetch` tool to pull in content from any URL: +**Web Fetch**: 내장된 `web_fetch` 도구를 사용하여 모든 URL의 콘텐츠를 가져올 수 있습니다. ```bash copilot -> Fetch and summarize the README from https://github.com/facebook/react +> https://github.com/facebook/react 의 README를 가져와서 요약해 주세요. ```
-*Complete MCP workflow: GitHub MCP retrieves repo data, Filesystem MCP finds code, Context7 MCP provides best practices, and Copilot handles analysis*
+*완전한 MCP 워크플로: GitHub MCP가 저장소 데이터를 가져오고, 파일 시스템 MCP가 코드를 찾고, Context7 MCP가 모범 사례를 제공하며, Copilot이 분석을 처리합니다.*
-Each example below is self-contained. **Pick one that interests you, or read them all.**
+아래의 각 예시는 독립적입니다. **관심 있는 것을 선택하거나, 모두 읽어보세요.**
-| I want to see... | Jump to |
-|---|---|
-| Multiple servers working together | [Multi-Server Exploration](#multi-server-exploration) |
-| Going from issue to PR in one session | [Issue-to-PR Workflow](#issue-to-pr-workflow) |
-| A quick project health check | [Health Dashboard](#health-dashboard) |
+| 보고 싶은 것 | 이동 |
+|-------------|------|
+| 여러 서버가 함께 작동하는 모습 | [다중 서버 탐색](#다중-서버-탐색) |
+| 이슈에서 PR까지 한 세션에서 처리 | [이슈-to-PR 워크플로](#이슈-to-pr-워크플로) |
+| 빠른 프로젝트 상태 확인 | [상태 대시보드](#상태-대시보드) |
-
Multi-Server Exploration - Combine filesystem, GitHub, and Context7 in one session
- +다중 서버 탐색 - 파일 시스템, GitHub, Context7을 한 세션에서 결합
+ -#### Exploring the Book App with Multiple MCP Servers +#### 여러 MCP 서버로 책 앱 탐색하기 ```bash copilot -# Step 1: Use filesystem MCP to explore the book app -> List all Python files in samples/book-app-project/ and summarize -> what each file does +# 1단계: 파일 시스템 MCP로 책 앱 탐색 +> samples/book-app-project/의 모든 Python 파일을 나열하고 각 파일이 +> 무엇을 하는지 요약해 주세요. -Found 3 Python files: -- book_app.py: CLI entry point with command routing (list, add, remove, find) -- books.py: BookCollection class with data persistence via JSON -- utils.py: Helper functions for user input and display +Python 파일 3개 발견: +- book_app.py: 명령어 라우팅이 있는 CLI 진입점 (list, add, remove, find) +- books.py: JSON을 통한 데이터 영속성을 갖춘 BookCollection 클래스 +- utils.py: 사용자 입력 및 표시를 위한 헬퍼 함수 -# Step 2: Use GitHub MCP to check recent changes -> What were the last 3 commits that touched files in samples/book-app-project/? +# 2단계: GitHub MCP로 최근 변경 사항 확인 +> samples/book-app-project/의 파일에 영향을 준 마지막 커밋 3개는 무엇인가요? -Recent commits affecting book app: -1. abc1234 - Add test fixtures for BookCollection (2 days ago) -2. def5678 - Add find_by_author method (5 days ago) -3. ghi9012 - Initial book app setup (1 week ago) +책 앱에 영향을 준 최근 커밋: +1. abc1234 - BookCollection에 대한 테스트 픽스처 추가 (2일 전) +2. def5678 - find_by_author 메서드 추가 (5일 전) +3. ghi9012 - 초기 책 앱 설정 (1주일 전) -# Step 3: Use Context7 MCP for best practices -> What are Python best practices for JSON data persistence? +# 3단계: Context7 MCP로 모범 사례 조회 +> JSON 데이터 영속성에 대한 Python 모범 사례는 무엇인가요? -From Python Documentation: -- Use context managers (with statements) for file I/O -- Handle JSONDecodeError for corrupted files -- Use dataclasses for structured data -- Consider atomic writes to prevent data corruption +Python 문서에서: +- 파일 I/O에는 컨텍스트 관리자(with 문) 사용 +- 손상된 파일을 위한 JSONDecodeError 처리 +- 구조화된 데이터에는 데이터클래스 사용 +- 데이터 손상 방지를 위한 원자적 쓰기 고려 -# Step 4: Synthesize a recommendation -> Based on the book app code and these best practices, -> what improvements would you suggest? +# 4단계: 권장 사항 종합 +> 책 앱 코드와 이 모범 사례를 바탕으로 어떤 개선을 제안하시겠습니까? -Suggestions: -1. Add input validation in add_book() for empty strings and invalid years -2. Consider atomic writes in save_books() to prevent data corruption -3. Add type hints to utils.py functions (get_user_choice, get_book_details) +제안: +1. 빈 문자열 및 잘못된 연도에 대한 add_book()의 입력 유효성 검사 추가 +2. 데이터 손상 방지를 위해 save_books()에 원자적 쓰기 고려 +3. utils.py 함수에 타입 힌트 추가 (get_user_choice, get_book_details) ```
-
-**The result**: Code exploration → history review → best practices lookup → improvement plan. **All from one terminal session, using three MCP servers together.**
+**결과**: 코드 탐색 → 히스토리 검토 → 모범 사례 조회 → 개선 계획. **하나의 터미널 세션에서 세 개의 MCP 서버를 함께 사용하여 모두 처리했습니다.**
🎬 See the MCP workflow in action!
+🎬 MCP 워크플로 실제 작동 모습 확인!
 -*Demo output varies. Your model, tools, and responses will differ from what's shown here.* +*데모 결과는 다를 수 있습니다. 사용하시는 모델, 도구 및 응답은 여기에 표시된 내용과 다를 수 있습니다.*
-
Issue-to-PR Workflow - Go from a GitHub issue to a pull request without leaving the terminal
- +이슈-to-PR 워크플로 - 터미널을 떠나지 않고 GitHub 이슈에서 풀 리퀘스트까지
+ -#### The Issue-to-PR Workflow (On Your Own Repo) +#### 이슈-to-PR 워크플로 (자신의 저장소에서) -This works best on your own fork or repository where you have write access: +쓰기 권한이 있는 자신의 포크 또는 저장소에서 가장 잘 작동합니다. -> 💡 **Don't worry if you can't try this right now.** If you're on a read-only clone, you'll practice this in the assignment. For now, just read through to understand the flow. +> 💡 **지금 당장 시도하기 어려우셔도 괜찮습니다.** 읽기 전용 클론에 있다면, 과제에서 이것을 연습할 것입니다. 지금은 흐름을 이해하기 위해 읽어보세요. ```bash copilot -> Get the details of GitHub issue #1 +> GitHub 이슈 #1의 세부 정보를 가져와 주세요. -Issue #1: Add input validation for book year -Status: Open -Description: The add_book function accepts any year value... +이슈 #1: 책 연도 입력 유효성 검사 추가 +상태: 열림 +설명: add_book 함수가 모든 연도 값을 허용합니다... -> @samples/book-app-project/books.py Fix the issue described in issue #1 +> @samples/book-app-project/books.py 이슈 #1에 설명된 문제를 수정해 주세요. -[Copilot implements year validation in add_book()] +[Copilot이 add_book()에 연도 유효성 검사를 구현합니다] -> Run the tests to make sure the fix works +> 수정이 제대로 작동하는지 테스트를 실행해 주세요. -All 8 tests passed ✓ +8개 테스트 모두 통과 ✓ -> Create a pull request titled "Add year validation to book app" +> "책 앱에 연도 유효성 검사 추가"라는 제목으로 풀 리퀘스트를 생성해 주세요. -✓ Created PR #2: Add year validation to book app +✓ PR #2 생성됨: 책 앱에 연도 유효성 검사 추가 ``` -**Zero copy-paste. Zero context switching. One terminal session.** +**복사-붙여넣기 없음. 컨텍스트 전환 없음. 하나의 터미널 세션으로 완료.**
-
---
-# Practice
+# 연습
Health Dashboard - Get a quick project health check using multiple servers
- +상태 대시보드 - 여러 서버를 사용하여 빠른 프로젝트 상태 확인
+ -#### Book App Health Dashboard +#### 책 앱 상태 대시보드 ```bash copilot -> Give me a health report for the book app project: -> 1. List all functions across the Python files in samples/book-app-project/ -> 2. Check which functions have type hints and which don't -> 3. Show what tests exist in samples/book-app-project/tests/ -> 4. Check the recent commit history for this directory - -Book App Health Report -====================== - -📊 Functions Found: -- books.py: 8 methods in BookCollection (all have type hints ✓) -- book_app.py: 6 functions (4 have type hints, 2 missing) -- utils.py: 3 functions (1 has type hints, 2 missing) - -🧪 Test Coverage: -- test_books.py: 8 test functions covering BookCollection -- Missing: no tests for book_app.py CLI functions -- Missing: no tests for utils.py helper functions - -📝 Recent Activity: -- 3 commits in the last week -- Most recent: added test fixtures - -Recommendations: -- Add type hints to utils.py functions -- Add tests for book_app.py CLI handlers -- All files well-sized (<100 lines) - good structure! +> 책 앱 프로젝트에 대한 상태 보고서를 제공해 주세요: +> 1. samples/book-app-project/의 Python 파일 전체에서 모든 함수를 나열해 주세요. +> 2. 타입 힌트가 있는 함수와 없는 함수를 확인해 주세요. +> 3. samples/book-app-project/tests/에 존재하는 테스트를 표시해 주세요. +> 4. 이 디렉터리의 최근 커밋 히스토리를 확인해 주세요. + +책 앱 상태 보고서 +================= + +📊 발견된 함수: +- books.py: BookCollection의 8개 메서드 (모두 타입 힌트 있음 ✓) +- book_app.py: 6개 함수 (4개 타입 힌트 있음, 2개 없음) +- utils.py: 3개 함수 (1개 타입 힌트 있음, 2개 없음) + +🧪 테스트 커버리지: +- test_books.py: BookCollection을 다루는 8개 테스트 함수 +- 누락: book_app.py CLI 함수에 대한 테스트 없음 +- 누락: utils.py 헬퍼 함수에 대한 테스트 없음 + +📝 최근 활동: +- 지난 주 3개 커밋 +- 가장 최근: 테스트 픽스처 추가됨 + +권장 사항: +- utils.py 함수에 타입 힌트 추가 +- book_app.py CLI 핸들러에 대한 테스트 추가 +- 모든 파일이 적절한 크기(<100줄) - 좋은 구조! ``` -**The result**: Multiple data sources aggregated in seconds. Manually, this would mean running grep, counting lines, checking git log, and browsing test files. Easily 15+ minutes of work. +**결과**: 수 초 만에 여러 데이터 소스를 집계합니다. 수동으로는 grep 실행, 줄 수 계산, git log 확인, 테스트 파일 탐색 등 최소 15분 이상 걸리는 작업입니다.
-**🎉 You now know the essentials!** You understand MCP, you've seen how to configure servers, and you've seen real workflows in action. Now it's time to try it yourself.
+**🎉 이제 기본 사항을 모두 이해하셨습니다!** MCP가 무엇인지, 서버를 구성하는 방법, 그리고 실제 워크플로를 살펴보셨습니다. 이제 직접 해볼 시간입니다.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 해보기
-Now it's your turn! Complete these exercises to practice using MCP servers with the book app project.
+이제 여러분의 차례입니다! 책 앱 프로젝트에서 MCP 서버를 사용하는 연습을 위해 이 연습 문제들을 완료하세요.
-### Exercise 1: Check Your MCP Status
+### 연습 1: MCP 상태 확인
-Start by seeing what MCP servers are available:
+사용 가능한 MCP 서버를 확인하는 것부터 시작해 보세요.
```bash
copilot
@@ -711,103 +712,103 @@ copilot
> /mcp show
```
-You should see the GitHub server listed as enabled. If not, run `/login` to authenticate.
+GitHub 서버가 활성화되어 있는 것으로 표시되어야 합니다. 그렇지 않은 경우 `/login`을 실행하여 인증하세요.
---
-### Exercise 2: Explore the Book App with Filesystem MCP
+### 연습 2: 파일 시스템 MCP로 책 앱 탐색
-If you've configured the filesystem server, use it to explore the book app:
+파일 시스템 서버를 구성했다면, 책 앱을 탐색해 보세요.
```bash
copilot
-> How many Python files are in samples/book-app-project/?
-> What functions are defined in each file?
+> samples/book-app-project/에 Python 파일이 몇 개 있나요?
+> 각 파일에 정의된 함수는 무엇인가요?
```
-**Expected result**: Copilot lists `book_app.py`, `books.py`, and `utils.py` with their functions.
+**예상 결과**: Copilot이 `book_app.py`, `books.py`, `utils.py`와 해당 함수들을 나열합니다.
-> 💡 **Don't have filesystem MCP configured yet?** Create the config file from the [Complete Configuration](#complete-configuration-file) section above. Then restart Copilot.
+> 💡 **파일 시스템 MCP를 아직 구성하지 않으셨나요?** 위의 [완전한 구성](#완전한-구성-파일) 섹션에서 구성 파일을 생성하세요. 그런 다음 Copilot을 재시작하세요.
---
-### Exercise 3: Query Repository History with GitHub MCP
+### 연습 3: GitHub MCP로 저장소 히스토리 쿼리
-Use the built-in GitHub MCP to explore this course repository:
+내장된 GitHub MCP를 사용하여 이 강의 저장소를 탐색하세요.
```bash
copilot
-> List the last 5 commits in this repository
+> 이 저장소의 마지막 커밋 5개를 나열해 주세요.
-> What branches exist in this repository?
+> 이 저장소에 어떤 브랜치가 있나요?
```
-**Expected result**: Copilot shows recent commit messages and branch names from the GitHub remote.
+**예상 결과**: Copilot이 GitHub 원격에서 최근 커밋 메시지와 브랜치 이름을 표시합니다.
-> ⚠️ **In a Codespace?** This works automatically. Authentication is inherited. If you're on a local clone, make sure `gh auth status` shows you're logged in.
+> ⚠️ **Codespace에서 작업하시나요?** 이것은 자동으로 작동합니다. 인증이 상속됩니다. 로컬 클론에 있다면 `gh auth status`에서 로그인되어 있는지 확인하세요.
---
-### Exercise 4: Combine Multiple MCP Servers
+### 연습 4: 여러 MCP 서버 결합
-Now combine filesystem and GitHub MCP in a single session:
+이제 파일 시스템과 GitHub MCP를 단일 세션에서 결합해 보세요.
```bash
copilot
-> Read samples/book-app-project/data.json and tell me what books are
-> in the collection. Then check the recent commits to see when this
-> file was last modified.
+> samples/book-app-project/data.json을 읽고 컬렉션에 어떤 책이 있는지
+> 알려주세요. 그런 다음 이 파일이 마지막으로 수정된 시점을 알아보기 위해
+> 최근 커밋을 확인해 주세요.
```
-**Expected result**: Copilot reads the JSON file (filesystem MCP), lists the 5 books including "The Hobbit", "1984", "Dune", "To Kill a Mockingbird", and "Mysterious Book", then queries GitHub for commit history.
+**예상 결과**: Copilot이 JSON 파일을 읽고(파일 시스템 MCP), "The Hobbit", "1984", "Dune", "To Kill a Mockingbird", "Mysterious Book"을 포함한 5권의 책을 나열한 후 GitHub에서 커밋 히스토리를 쿼리합니다.
-**Self-Check**: You understand MCP when you can explain why "Check my repo's commit history" is better than manually running `git log` and pasting the output into your prompt.
+**자가 점검**: "내 저장소의 커밋 히스토리를 확인해 줘"가 수동으로 `git log`를 실행하고 출력을 프롬프트에 붙여넣는 것보다 나은 이유를 설명할 수 있을 때 MCP를 이해한 것입니다.
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: Book App MCP Exploration
+### 주요 과제: 책 앱 MCP 탐색
-Practice using MCP servers together on the book app project. Complete these steps in a single Copilot session:
+책 앱 프로젝트에서 MCP 서버를 함께 사용하는 연습을 하세요. 단일 Copilot 세션에서 이 단계들을 완료하세요.
-1. **Verify MCP is working**: Run `/mcp show` and confirm at least the GitHub server is enabled
-2. **Set up filesystem MCP** (if not already done): Create `~/.copilot/mcp-config.json` with the filesystem server configuration
-3. **Explore the code**: Ask Copilot to use the filesystem server to:
- - List all functions in `samples/book-app-project/books.py`
- - Check which functions in `samples/book-app-project/utils.py` are missing type hints
- - Read `samples/book-app-project/data.json` and identify any data quality issues (hint: look at the last entry)
-4. **Check repository activity**: Ask Copilot to use GitHub MCP to:
- - List recent commits that touched files in `samples/book-app-project/`
- - Check if there are any open issues or pull requests
-5. **Combine servers**: In a single prompt, ask Copilot to:
- - Read the test file at `samples/book-app-project/tests/test_books.py`
- - Compare the tested functions against all functions in `books.py`
- - Summarize what test coverage is missing
+1. **MCP 작동 확인**: `/mcp show`를 실행하고 최소한 GitHub 서버가 활성화되어 있는지 확인하세요.
+2. **파일 시스템 MCP 설정** (아직 완료하지 않은 경우): 파일 시스템 서버 구성으로 `~/.copilot/mcp-config.json`을 생성하세요.
+3. **코드 탐색**: Copilot에게 파일 시스템 서버를 사용하여 다음을 요청하세요.
+ - `samples/book-app-project/books.py`의 모든 함수 나열
+ - `samples/book-app-project/utils.py`에서 타입 힌트가 없는 함수 확인
+ - `samples/book-app-project/data.json`을 읽고 데이터 품질 문제 식별 (힌트: 마지막 항목을 살펴보세요)
+4. **저장소 활동 확인**: Copilot에게 GitHub MCP를 사용하여 다음을 요청하세요.
+ - `samples/book-app-project/`의 파일에 영향을 준 최근 커밋 나열
+ - 열린 이슈 또는 풀 리퀘스트가 있는지 확인
+5. **서버 결합**: 단일 프롬프트에서 Copilot에게 다음을 요청하세요.
+ - `samples/book-app-project/tests/test_books.py`의 테스트 파일 읽기
+ - 테스트된 함수를 `books.py`의 모든 함수와 비교
+ - 누락된 테스트 커버리지 요약
-**Success criteria**: You can seamlessly combine filesystem and GitHub MCP data in a single Copilot session, and you can explain what each MCP server contributed to the response.
+**성공 기준**: 단일 Copilot 세션에서 파일 시스템과 GitHub MCP 데이터를 자연스럽게 결합할 수 있으며, 각 MCP 서버가 응답에 기여한 내용을 설명할 수 있습니다.
-
-### Bonus Challenge: Build a Custom MCP Server
+### 보너스 과제: 사용자 지정 MCP 서버 구축
-Ready to go deeper? Follow the [Custom MCP Server Guide](mcp-custom-server.md) to build your own MCP server in Python that connects to any API.
+더 깊이 파고들 준비가 되셨나요? [사용자 지정 MCP 서버 가이드](mcp-custom-server.md)를 따라 모든 API에 연결할 수 있는 자신만의 MCP 서버를 Python으로 구축해 보세요.
---
💡 Hints (click to expand)
+💡 힌트 (클릭하여 펼치기)
-**Step 1: Verify MCP** +**1단계: MCP 확인** ```bash copilot > /mcp show -# Should show "github" as enabled -# If not, run: /login +# "github"가 활성화된 것으로 표시되어야 합니다. +# 그렇지 않은 경우 실행: /login ``` -**Step 2: Create the config file** +**2단계: 구성 파일 생성** -Use the JSON from the [Complete Configuration](#complete-configuration-file) section above and save it as `~/.copilot/mcp-config.json`. +위의 [완전한 구성](#완전한-구성-파일) 섹션의 JSON을 사용하여 `~/.copilot/mcp-config.json`으로 저장하세요. -**Step 3: Data quality issue to look for** +**3단계: 찾아야 할 데이터 품질 문제** -The last book in `data.json` is: +`data.json`의 마지막 책은 다음과 같습니다. ```json { "title": "Mysterious Book", @@ -816,119 +817,119 @@ The last book in `data.json` is: "read": false } ``` -An empty author and year of 0. That's the data quality issue! +작성자가 비어 있고 연도가 0입니다. 이것이 데이터 품질 문제입니다! -**Step 5: Test coverage comparison** +**5단계: 테스트 커버리지 비교** -The tests in `test_books.py` cover: `add_book`, `mark_as_read`, `remove_book`, `get_unread_books`, and `find_book_by_title`. Functions like `load_books`, `save_books`, and `list_books` don't have direct tests. The CLI functions in `book_app.py` and helpers in `utils.py` have no tests at all. +`test_books.py`의 테스트는 `add_book`, `mark_as_read`, `remove_book`, `get_unread_books`, `find_book_by_title`을 다룹니다. `load_books`, `save_books`, `list_books` 함수에는 직접적인 테스트가 없습니다. `book_app.py`의 CLI 함수와 `utils.py`의 헬퍼에는 테스트가 전혀 없습니다. -**If MCP isn't working:** Restart Copilot after editing the config file. +**MCP가 작동하지 않는 경우:** 구성 파일 편집 후 Copilot을 재시작하세요.
-
---
🔧 Common Mistakes & Troubleshooting (click to expand)
+🔧 일반적인 실수 및 문제 해결 (클릭하여 펼치기)
-### Common Mistakes +### 일반적인 실수 -| Mistake | What Happens | Fix | -|---------|--------------|-----| -| Not knowing GitHub MCP is built-in | Trying to install/configure it manually | GitHub MCP is included by default. Just try: "List the recent commits in this repo" | -| Looking for config in wrong location | Can't find or edit MCP settings | User-level config is in `~/.copilot/mcp-config.json`, project-level is `.vscode/mcp.json` | -| Invalid JSON in config file | MCP servers fail to load | Use `/mcp show` to check configuration; validate JSON syntax | -| Forgetting to authenticate MCP servers | "Authentication failed" errors | Some MCPs need separate auth. Check each server's requirements | +| 실수 | 발생하는 문제 | 해결 방법 | +|------|-------------|-----------| +| GitHub MCP가 내장되어 있다는 것을 모름 | 수동으로 설치/구성 시도 | GitHub MCP는 기본으로 포함됩니다. 다음을 시도해 보세요: "이 저장소의 최근 커밋을 나열해 줘" | +| 잘못된 위치에서 구성 파일 찾기 | MCP 설정을 찾거나 편집할 수 없음 | 사용자 수준 구성은 `~/.copilot/mcp-config.json`에, 프로젝트 수준은 `.vscode/mcp.json`에 있습니다 | +| 구성 파일에 잘못된 JSON | MCP 서버가 로드되지 않음 | `/mcp show`를 사용하여 구성을 확인하고 JSON 구문을 유효성 검사하세요 | +| MCP 서버 인증을 잊음 | "인증 실패" 오류 | 일부 MCP는 별도의 인증이 필요합니다. 각 서버의 요구 사항을 확인하세요 | -### Troubleshooting +### 문제 해결 -**"MCP server not found"** - Check that: -1. The npm package exists: `npm view @modelcontextprotocol/server-github` -2. Your configuration is valid JSON -3. The server name matches your config +**"MCP 서버를 찾을 수 없음"** - 다음을 확인하세요. +1. npm 패키지가 존재하는지: `npm view @modelcontextprotocol/server-github` +2. 구성이 유효한 JSON인지 +3. 서버 이름이 구성과 일치하는지 -Use `/mcp show` to see the current configuration. +현재 구성을 확인하려면 `/mcp show`를 사용하세요. -**"GitHub authentication failed"** - The built-in GitHub MCP uses your `/login` credentials. Try: +**"GitHub 인증 실패"** - 내장 GitHub MCP는 `/login` 자격 증명을 사용합니다. 다음을 시도해 보세요. ```bash copilot > /login ``` -This will re-authenticate you with GitHub. If issues persist, check that your GitHub account has the necessary permissions for the repository you're accessing. +이 명령어로 GitHub에 다시 인증됩니다. 문제가 지속되면 GitHub 계정에 접근하려는 저장소에 대한 필요한 권한이 있는지 확인하세요. -**"MCP server failed to start"** - Check the server logs: +**"MCP 서버 시작 실패"** - 서버 로그를 확인하세요. ```bash -# Run the server command manually to see errors +# 서버 명령어를 수동으로 실행하여 오류 확인 npx -y @modelcontextprotocol/server-github ``` -**MCP tools not available** - Make sure the server is enabled: +**MCP 도구를 사용할 수 없음** - 서버가 활성화되어 있는지 확인하세요. ```bash copilot > /mcp show -# Check if server is listed and enabled +# 서버가 목록에 있고 활성화되어 있는지 확인하세요. ``` -If a server is disabled, see the [additional `/mcp` commands](#-additional-mcp-commands) below for how to re-enable it. +서버가 비활성화된 경우 재활성화 방법은 아래의 [추가 `/mcp` 명령어](#-추가-mcp-명령어)를 참조하세요.
-📚 Additional
-
+📚 추가
+
-Beyond `/mcp show`, there are several other commands for managing your MCP servers:
+`/mcp show` 외에도 MCP 서버를 관리하는 여러 다른 명령어가 있습니다.
-| Command | What It Does |
-|---------|--------------|
-| `/mcp show` | Show all configured MCP servers and their status |
-| `/mcp add` | Interactive setup for adding a new server |
-| `/mcp edit ` | Edit an existing server configuration |
-| `/mcp enable ` | Enable a disabled server |
-| `/mcp disable ` | Temporarily disable a server |
-| `/mcp delete ` | Remove a server permanently |
+| 명령어 | 기능 |
+|--------|------|
+| `/mcp show` | 구성된 모든 MCP 서버와 상태 표시 |
+| `/mcp add` | 새 서버 추가를 위한 대화형 설정 |
+| `/mcp edit ` | 기존 서버 구성 편집 |
+| `/mcp enable ` | 비활성화된 서버 활성화 |
+| `/mcp disable ` | 서버 일시적으로 비활성화 |
+| `/mcp delete ` | 서버 영구적으로 제거 |
-For most of this course, `/mcp show` is all you need. The other commands become useful as you manage more servers over time.
+이 강의의 대부분에서는 `/mcp show`만 있으면 됩니다. 다른 명령어는 시간이 지나면서 더 많은 서버를 관리할 때 유용해집니다.
---
-# Summary
+# 요약
-## 🔑 Key Takeaways
+## 🔑 핵심 요점
-1. **MCP** connects Copilot to external services (GitHub, filesystem, documentation)
-2. **GitHub MCP is built-in** - no configuration needed, just `/login`
-3. **Filesystem and Context7** are configured via `~/.copilot/mcp-config.json`
-4. **Multi-server workflows** combine data from multiple sources in a single session
-5. **Check server status** with `/mcp show` (additional commands available for managing servers)
-6. **Custom servers** let you connect any API (optional, covered in the appendix guide)
+1. **MCP**는 Copilot을 외부 서비스(GitHub, 파일 시스템, 문서)에 연결합니다.
+2. **GitHub MCP는 내장되어 있습니다** - 구성이 필요 없으며 `/login`만 실행하면 됩니다.
+3. **파일 시스템 및 Context7**은 `~/.copilot/mcp-config.json`을 통해 구성됩니다.
+4. **다중 서버 워크플로**는 단일 세션에서 여러 소스의 데이터를 결합합니다.
+5. **서버 상태 확인**은 `/mcp show`로 합니다 (서버 관리를 위한 추가 명령어도 사용 가능합니다).
+6. **사용자 지정 서버**를 사용하면 모든 API에 연결할 수 있습니다 (선택 사항, 부록 가이드에서 다룸).
-> 📋 **Quick Reference**: See the [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for a complete list of commands and shortcuts.
+> 📋 **빠른 참조**: 전체 명령어 및 단축키 목록은 [GitHub Copilot CLI 명령어 참조](https://docs.github.com/en/copilot/reference/cli-command-reference)를 참조하세요.
---
-## ➡️ What's Next
+## ➡️ 다음 단계
-You now have all the building blocks: modes, context, workflows, agents, skills, and MCP. Time to put them all together.
+이제 모든 구성 요소를 갖추셨습니다: 모드, 컨텍스트, 워크플로, 에이전트, 스킬, MCP. 이제 이 모든 것을 함께 사용할 시간입니다.
-In **[Chapter 07: Putting It All Together](../07-putting-it-together/README.md)**, you'll learn:
+**[7장: 모두 합치기](../07-putting-it-together/README.md)**에서는 다음을 배웁니다.
-- Combining agents, skills, and MCP in unified workflows
-- Complete feature development from idea to merged PR
-- Automation with hooks
-- Best practices for team environments
+- 에이전트, 스킬, MCP를 통합 워크플로에서 결합
+- 아이디어에서 병합된 PR까지 완전한 기능 개발
+- 훅을 사용한 자동화
+- 팀 환경을 위한 모범 사례
---
-**[← Back to Chapter 05](../05-skills/README.md)** | **[Continue to Chapter 07 →](../07-putting-it-together/README.md)**
+**[← 5장으로 돌아가기](../05-skills/README.md)** | **[7장으로 계속 →](../07-putting-it-together/README.md)**
diff --git a/06-mcp-servers/mcp-custom-server.md b/06-mcp-servers/mcp-custom-server.md
index 03166f6a..71ea6b49 100644
--- a/06-mcp-servers/mcp-custom-server.md
+++ b/06-mcp-servers/mcp-custom-server.md
@@ -1,19 +1,19 @@
-# Building a Custom MCP Server
+# 사용자 지정 MCP 서버 구축
+
+> ⚠️ **이 내용은 선택 사항입니다.** 미리 구축된 MCP 서버(GitHub, 파일 시스템, Context7)만으로도 Copilot CLI를 충분히 활용할 수 있습니다. 이 가이드는 Copilot을 사용자 지정 내부 API에 연결하려는 개발자를 위한 것입니다. 자세한 내용은 [MCP 초보자 과정](https://github.com/microsoft/mcp-for-beginners)을 참조하세요.
-> ⚠️ **This content is completely optional.** You can be highly productive with Copilot CLI using only the pre-built MCP servers (GitHub, filesystem, Context7). This guide is for developers who want to connect Copilot to custom internal APIs. See the [MCP for Beginners course](https://github.com/microsoft/mcp-for-beginners) for more details.
>
-> **Prerequisites:**
-> - Comfortable with Python
-> - Understanding of `async`/`await` patterns
-> - `pip` available on your system (included in this dev container)
+> **필수 조건:**
+> - Python에 대한 기본적인 이해
+> - `async`/`await` 패턴에 대한 이해
+> - 시스템에 `pip` 설치 (개발 컨테이너에 포함됨)
>
-> **[← Back to Chapter 06: MCP Servers](README.md)**
-
+> **[← 6장: MCP 서버로 돌아가기](README.md)**
---
-Want to connect Copilot to your own APIs? Here's how to build a simple MCP server in Python that looks up book information, tying back to the book app project you've been using throughout this course.
+Copilot을 자체 API에 연결하고 싶으신가요? 이 강좌에서 사용해 온 도서 앱 프로젝트와 연동하여 도서 정보를 조회하는 간단한 MCP 서버를 Python으로 구축하는 방법을 소개합니다.
-## Project Setup
+## 프로젝트 설정
```bash
mkdir book-lookup-mcp-server
@@ -21,11 +21,11 @@ cd book-lookup-mcp-server
pip install mcp
```
-> 💡 **What is the `mcp` package?** It's the official Python SDK for building MCP servers. It handles the protocol details so you can focus on your tools.
+> 💡 **`mcp` 패키지란 무엇인가요?** MCP 서버 구축을 위한 공식 Python SDK입니다. 프로토콜 관련 세부 사항은 패키지에서 처리하므로 개발자는 도구 개발에 집중할 수 있습니다.
-## Server Implementation
+## 서버 구현
-Create a file called `server.py`:
+`server.py`라는 파일을 생성하세요.
```python
# server.py
@@ -96,20 +96,20 @@ if __name__ == "__main__":
mcp.run()
```
-**What's happening here:**
+**여기서 무슨 일이 일어나고 있나요?**
-| Part | What It Does |
+| 파트 | 기능 |
|------|-------------|
-| `FastMCP("book-lookup")` | Creates a server named "book-lookup" |
-| `@mcp.tool()` | Registers a function as a tool Copilot can call |
-| Type hints + docstrings | Tell Copilot what each tool does and what parameters it needs |
-| `mcp.run()` | Starts the server and listens for requests |
+| `FastMCP("book-lookup")` | "book-lookup"이라는 이름의 서버를 생성합니다. |
+| `@mcp.tool()` | Copilot이 호출할 수 있는 도구로 함수를 등록합니다. |
+| 타입 힌트 + 독스트링 | 각 도구의 기능과 필요한 매개변수를 Copilot에 알려줍니다. |
+| `mcp.run()` | 서버를 시작하고 요청을 수신합니다. |
-> 💡 **Why decorators?** The `@mcp.tool()` decorator is all you need. The MCP SDK automatically reads your function's name, type hints, and docstring to generate the tool schema. No manual JSON schema needed!
+> 💡 **데코레이터를 사용하는 이유?** `@mcp.tool()` 데코레이터만 있으면 됩니다. MCP SDK는 함수의 이름, 타입 힌트, 독스트링을 자동으로 읽어 도구 스키마를 생성합니다. 수동으로 JSON 스키마를 작성할 필요가 없습니다!
-## Configuration
+## 설정
-Add to your `~/.copilot/mcp-config.json`:
+`~/.copilot/mcp-config.json` 파일에 다음을 추가하세요.
```json
{
@@ -155,16 +155,16 @@ copilot
[Shows all books in the database with ISBNs]
```
-## Next Steps
+## 다음 단계
-Once you've built a basic server, you can:
+기본 서버 구축이 완료되면 다음 작업을 수행할 수 있습니다.
-1. **Add more tools** - Each `@mcp.tool()` function becomes a tool Copilot can call
-2. **Connect real APIs** - Replace the mock `BOOKS_DB` with actual API calls or database queries
-3. **Add authentication** - Handle API keys and tokens securely
-4. **Share your server** - Publish to PyPI so others can install it with `pip`
+1. **도구 추가** - 각 `@mcp.tool()` 함수는 Copilot에서 호출할 수 있는 도구가 됩니다.
+2. **실제 API 연결** - 모의 `BOOKS_DB`를 실제 API 호출 또는 데이터베이스 쿼리로 교체합니다.
+3. **인증 추가** - API 키와 토큰을 안전하게 관리합니다.
+4. **서버 공유** - 다른 사용자가 `pip`으로 설치할 수 있도록 PyPI에 게시합니다.
-## Resources
+## 리소스
- [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk)
- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
diff --git a/07-putting-it-together/README.md b/07-putting-it-together/README.md
index 2678d647..06ccd7db 100644
--- a/07-putting-it-together/README.md
+++ b/07-putting-it-together/README.md
@@ -1,198 +1,197 @@
-> **Everything you learned combines here. Go from idea to merged PR in a single session.**
+**지금까지 배운 모든 것을 여기서 활용하세요. 아이디어 구상부터 PR 병합까지 단 한 번의 세션으로 완료할 수 있습니다.**
-In this chapter, you'll bring together everything you've learned into complete workflows. You'll build features using multi-agent collaboration, set up pre-commit hooks that catch security issues before they're committed, integrate Copilot into CI/CD pipelines, and go from feature idea to merged PR in a single terminal session. This is where GitHub Copilot CLI becomes a genuine force multiplier.
+이 장에서는 지금까지 배운 모든 내용을 통합하여 완벽한 워크플로우를 구축합니다. 다중 에이전트 협업을 사용하여 기능을 개발하고, 커밋 전에 보안 문제를 감지하는 사전 커밋 훅을 설정하고, Copilot을 CI/CD 파이프라인에 통합하고, 기능 아이디어 구상부터 PR 병합까지 단 한 번의 터미널 세션으로 완료하는 방법을 배웁니다. GitHub Copilot CLI가 진정한 시너지 효과를 발휘하는 부분입니다.
-> 💡 **Note**: This chapter shows how to combine everything you've learned. **You don't need agents, skills, or MCP to be productive (although they can be very helpful).** The core workflow — describe, plan, implement, test, review, ship — works with just the built-in features from Chapters 00-03.
+💡 **참고**: 이 장에서는 지금까지 배운 모든 내용을 통합하는 방법을 보여줍니다. **생산성을 확보하기 위해 에이전트, 스킬 또는 MCP가 반드시 필요한 것은 아닙니다(물론 매우 유용할 수 있습니다).** 핵심 워크플로우(설명, 계획, 구현, 테스트, 검토, 배포)는 0장부터 3장까지의 내장 기능만으로도 작동합니다.
-## 🎯 Learning Objectives
+## 🎯 학습 목표
-By the end of this chapter, you'll be able to:
+이 장을 마치면 다음을 수행할 수 있게 됩니다.
-- Combine agents, skills, and MCP (Model Context Protocol) in unified workflows
-- Build complete features using multi-tool approaches
-- Set up basic automation with hooks
-- Apply best practices for professional development
-
-> ⏱️ **Estimated Time**: ~75 minutes (15 min reading + 60 min hands-on)
+- 에이전트, 스킬 및 MCP(모델 컨텍스트 프로토콜)를 통합 워크플로로 결합
+- 다양한 도구를 활용하여 완벽한 기능 구축
+- 훅을 사용하여 기본적인 자동화 설정
+- 전문성 개발을 위한 모범 사례 적용
+> ⏱️ **예상 소요 시간**: 약 75분 (읽기 15분 + 실습 60분)
---
-## 🧩 Real-World Analogy: The Orchestra
+## 🧩 실제 사례: 오케스트라
+
+📚 Additional /mcp Commands (click to expand)
-
+📚 추가 /mcp 명령어 (클릭하여 펼치기)
+
-Beyond `/mcp show`, there are several other commands for managing your MCP servers:
+`/mcp show` 외에도 MCP 서버를 관리하는 여러 다른 명령어가 있습니다.
-| Command | What It Does |
-|---------|--------------|
-| `/mcp show` | Show all configured MCP servers and their status |
-| `/mcp add` | Interactive setup for adding a new server |
-| `/mcp edit
-
+심포니 오케스트라는 여러 파트로 구성됩니다.
+- **현악기**는 기반을 제공합니다(핵심 워크플로와 유사).
+- **금관악기**는 힘을 더합니다(전문 지식을 갖춘 에이전트와 유사).
+- **목관악기**는 색채를 더합니다(역량을 확장하는 스킬과 유사).
-A symphony orchestra has many sections:
-- **Strings** provide the foundation (like your core workflows)
-- **Brass** adds power (like agents with specialized expertise)
-- **Woodwinds** add color (like skills that extend capabilities)
-- **Percussion** keeps rhythm (like MCP connecting to external systems)
+- **타악기**는 리듬을 유지합니다(MCP가 외부 시스템과 연결되는 것과 유사).
-Individually, each section sounds limited. Together, conducted well, they create something magnificent.
+각 파트는 개별적으로는 한계가 있지만, 잘 지휘될 때 비로소 웅장한 소리를 만들어냅니다.
-**That's what this chapter teaches!**-*Like a conductor with an orchestra, you orchestrate agents, skills, and MCP into unified workflows* +**이 장에서 바로 그 방법을 알려드립니다!**
+*지휘자가 오케스트라를 지휘하듯, 에이전트, 스킬, MCP를 통합 워크플로로 조율합니다.* -Let's start by walking through a scenario that modifies code, generates tests, reviews it, and creates a PR - all in one session. +코드 수정, 테스트 생성, 코드 검토, 그리고 PR 생성까지 모든 작업을 한 번에 수행하는 시나리오를 살펴보면서 시작해 보겠습니다. --- -## Idea to Merged PR in One Session +## 아이디어 구상부터 PR 병합까지 한 번의 세션으로 완료하기 -Instead of switching between your editor, terminal, test runner, and GitHub UI and losing context each time, you can combine all your tools in one terminal session. We'll break down this pattern in the [Integration Pattern](#the-integration-pattern-for-power-users) section below. +편집기, 터미널, 테스트 러너, GitHub UI를 번갈아 가며 사용하고 매번 작업 내용을 잃어버리는 대신, 모든 도구를 하나의 터미널 세션에서 통합하여 사용할 수 있습니다. 이 패턴에 대한 자세한 설명은 아래 [통합 패턴](#the-integration-pattern-for-power-users) 섹션에서 다루겠습니다. ```bash -# Start Copilot in interactive mode +# Copilot을 대화형 모드로 시작 copilot -> I need to add a "list unread" command to the book app that shows only -> books where read is False. What files need to change? +> 읽지 않은 책 목록 보기 기능을 도서 앱에 추가하고 싶습니다. +> 읽은 책이 False인 책만 표시되도록 하려면 어떤 파일을 수정해야 하나요? -# Copilot creates high-level plan... +# Copilot이 상위 수준 계획을 생성합니다... -# SWITCH TO PYTHON-REVIEWER AGENT +# PYTHON-REVIEWER 에이전트로 전환 > /agent -# Select "python-reviewer" +# "python-reviewer" 선택 -> @samples/book-app-project/books.py Design a get_unread_books method. -> What is the best approach? +> @samples/book-app-project/books.py 파일에서 읽지 않은 책 수를 가져오는 get_unread_books 메서드를 설계하세요. +> 가장 좋은 접근 방식은 무엇일까요? -# Python-reviewer agent produces: -# - Method signature and return type -# - Filter implementation using list comprehension -# - Edge case handling for empty collections +# Python-reviewer 에이전트 출력 결과: +# - 메서드 시그니처 및 반환 타입 +# - 리스트 컴프리헨션을 사용한 필터 구현 +# - 빈 컬렉션에 대한 예외 처리 -# SWITCH TO PYTEST-HELPER AGENT +# PYTEST-HELPER 에이전트로 전환 > /agent -# Select "pytest-helper" +# "pytest-helper" 선택 -> @samples/book-app-project/tests/test_books.py Design test cases for -> filtering unread books. +> @samples/book-app-project/tests/test_books.py 읽지 않은 책 필터링에 대한 테스트 케이스를 설계합니다. -# Pytest-helper agent produces: -# - Test cases for empty collections -# - Test cases with mixed read/unread books -# - Test cases with all books read +# Pytest-helper 에이전트는 다음을 생성합니다. +# - 빈 컬렉션에 대한 테스트 케이스 +# - 읽은 책과 읽지 않은 책이 혼합된 경우의 테스트 케이스 +# - 모든 책을 읽은 경우의 테스트 케이스 -# IMPLEMENT -> Add a get_unread_books method to BookCollection in books.py -> Add a "list unread" command option in book_app.py -> Update the help text in the show_help function +# 구현 +> books.py의 BookCollection에 get_unread_books 메서드 추가 +> book_app.py에 "읽지 않은 책 목록 보기" 명령 옵션 추가 +> show_help 함수의 도움말 텍스트 업데이트 -# TEST -> Generate comprehensive tests for the new feature +# 테스트 +> 새 기능에 대한 포괄적인 테스트 생성 -# Multiple tests are generated similar to the following: -# - Happy path (3 tests) — filters correctly, excludes read, includes unread -# - Edge cases (4 tests) — empty collection, all read, none read, single book -# - Parametrized (5 cases) — varying read/unread ratios via @pytest.mark.parametrize -# - Integration (4 tests) — interplay with mark_as_read, remove_book, add_book, and data integrity +# 다음과 유사한 여러 테스트가 생성됩니다. +# - 정상 경로(3개 테스트) — 필터링이 올바르게 작동하고, 읽은 책은 제외하고, 읽지 않은 책은 포함합니다. +# - 예외 상황(4개 테스트) — 빈 컬렉션, 모든 책 읽음, 읽지 않은 책 없음, 책 한 권만 있는 경우 +# - 매개변수화된 경우(5개 테스트) — @pytest.mark.parametrize를 통해 읽은 책과 읽지 않은 책의 비율을 변경합니다. +# - 통합 테스트(4개 테스트) — mark_as_read, remove_book, add_book 및 데이터 무결성과의 상호 작용 -# Review the changes +# 변경 사항 검토 > /review -# If review passes, use /pr to operate on the pull request for the current branch -> /pr [view|create|fix|auto] +# 검토가 통과되면 /pr을 사용하여 제출하세요. 현재 브랜치에 대한 풀 리퀘스트를 작업합니다. +> /pr [보기|생성|수정|자동] -# Or ask naturally if you want Copilot to draft it from the terminal -> Create a pull request titled "Feature: Add list unread books command" +# 또는 Copilot이 터미널에서 풀 리퀘스트를 생성하도록 하려면 자연스럽게 요청할 수도 있습니다. +> "Feature: Add list unread books command"라는 제목의 풀 리퀘스트를 생성합니다. ``` -**Traditional approach**: Switching between editor, terminal, test runner, docs, and GitHub UI. Each switch causes context loss and friction. +**기존 방식**: 에디터, 터미널, 테스트 러너, 문서, GitHub UI 사이를 계속 전환해야 했습니다. 전환할 때마다 맥락을 놓치고 불편함을 느꼈습니다. -**The key insight**: You directed specialists like an architect. They handled the details. You handled the vision. +**핵심 통찰**: 마치 건축가처럼 전문가들을 이끌었습니다. 그들은 세부 사항을 처리했고, 당신은 비전을 제시했습니다. -> 💡 **Going further**: For large multi-step plans like this, try `/fleet` to let Copilot run independent subtasks in parallel. See the [official docs](https://docs.github.com/copilot/concepts/agents/copilot-cli/fleet) for details. +> 💡 **더 나아가** 이와 같은 대규모 다단계 계획의 경우, Copilot이 독립적인 하위 작업을 병렬로 실행할 수 있도록 `/fleet`을 사용해 보세요. 자세한 내용은 [공식 문서](https://docs.github.com/copilot/concepts/agents/copilot-cli/fleet)를 참조하십시오. --- -# Additional Workflows +# 추가 워크플로
-For power users who completed Chapters 04-06, these workflows show how agents, skills, and MCP multiply your effectiveness.
+4장부터 6장까지 완료한 고급 사용자라면, 이 워크플로를 통해 Agent, 스킬, 그리고 MCP가 어떻게 업무 효율성을 극대화하는지 확인할 수 있습니다.
-## The Integration Pattern
+## 통합 패턴
-Here's the mental model for combining everything:
+모든 것을 결합하는 개념적 모델은 다음과 같습니다.
---
-## Workflow 1: Bug Investigation and Fix
+## 워크플로 1: 버그 조사 및 수정
-Real-world bug fixing with full tool integration:
+실제 환경에서 버그를 수정하고 모든 도구를 통합적으로 활용합니다.
```bash
copilot
-# PHASE 1: Understand the bug from GitHub (MCP provides this)
-> Get the details of issue #1
+# 1단계: GitHub에서 버그 파악 (MCP 제공)
+> 이슈 #1의 세부 정보 가져오기
-# Learn: "find_by_author doesn't work with partial names"
+# 학습 내용: "find_by_author 함수가 부분 이름 일치에 문제가 있습니다"
-# PHASE 2: Research best practice (deep research with web + GitHub sources)
-> /research Best practices for Python case-insensitive string matching
+# 2단계: 모범 사례 조사 (웹 및 GitHub 자료를 활용한 심층 조사)
+> /research Python 대소문자 구분 없는 문자열 일치 모범 사례
-# PHASE 3: Find related code
-> @samples/book-app-project/books.py Show me the find_by_author method
+# 3단계: 관련 코드 찾기
+> @samples/book-app-project/books.py find_by_author 메서드 표시
-# PHASE 4: Get expert analysis
+# 4단계: 전문가 분석 받기
> /agent
-# Select "python-reviewer"
+# "python-reviewer" 선택
-> Analyze this method for issues with partial name matching
+> 부분 이름 일치 관련 문제 분석
-# Agent identifies: Method uses exact equality instead of substring matching
+# 에이전트 분석 결과: 메서드가 부분 문자열 일치 대신 정확한 동일성 비교를 사용합니다
-# PHASE 5: Fix with agent guidance
-> Implement the fix using lowercase comparison and 'in' operator
+# 5단계: 에이전트의 안내에 따라 수정
+> 소문자 비교 및 'in' 연산자를 사용하여 수정 구현
-# PHASE 6: Generate tests
+# 6단계: 테스트 생성
> /agent
-# Select "pytest-helper"
+# "pytest-helper" 선택
-> Generate pytest tests for find_by_author with partial matches
-> Include test cases: partial name, case variations, no matches
+> 생성 pytest에서 find_by_author 함수에 대한 부분 일치 테스트 수행
+> 테스트 케이스 추가: 부분 이름, 대소문자 변형, 일치 항목 없음
-# PHASE 7: Commit and PR
-> Generate a commit message for this fix
+# 7단계: 커밋 및 풀 리퀘스트 생성
+> 이 수정 사항에 대한 커밋 메시지 생성
-> Create a pull request linking to issue #1
+> 이슈 #1에 연결되는 풀 리퀘스트 생성
```
---
-## Workflow 2: Code Review Automation (Optional)
+## 워크플로 2: 코드 검토 자동화 (선택 사항)
-> 💡 **This section is optional.** Pre-commit hooks are useful for teams but not required to be productive. Skip this if you're just getting started.
->
-> ⚠️ **Performance note**: This hook calls `copilot -p` for each staged file, which takes several seconds per file. For large commits, consider limiting to critical files or running reviews manually with `/review` instead.
+> 💡 **이 섹션은 선택 사항입니다.** 커밋 전 훅은 팀 작업에 유용하지만 생산성을 위해 필수적인 것은 아닙니다. 처음 시작하는 경우 이 부분을 건너뛰세요.
-A **git hook** is a script that Git runs automatically at certain points, For example, right before a commit. You can use this to run automated checks on your code. Here's how to set up an automated Copilot review on your commits:
+> ⚠️ **성능 참고**: 이 훅은 스테이징된 각 파일에 대해 `copilot -p`를 호출하며, 파일당 몇 초가 소요됩니다. 대규모 커밋의 경우 중요한 파일에만 적용하거나 `/review`를 사용하여 수동으로 리뷰를 실행하는 것을 고려해 보세요.
+
+**Git 훅**은 Git이 특정 시점(예: 커밋 직전)에 자동으로 실행하는 스크립트입니다. 이를 통해 코드에 대한 자동화된 검사를 실행할 수 있습니다. 다음은 커밋에 대한 Copilot 자동 리뷰를 설정하는 방법입니다.
```bash
-# Create a pre-commit hook
+# 사전 커밋 훅 생성
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
-# Get staged files (Python files only)
+# 스테이징된 파일 가져오기 (파이썬 파일만 해당)
STAGED=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.py$')
if [ -n "$STAGED" ]; then
- echo "Running Copilot review on staged files..."
+ echo "스테이징된 파일에 대해 Copilot 검토를 실행 중입니다..."
for file in $STAGED; do
echo "Reviewing $file..."
- # Use timeout to prevent hanging (60 seconds per file)
- # --allow-all auto-approves file reads/writes so the hook can run unattended.
- # Only use this in automated scripts. In interactive sessions, let Copilot ask for permission.
- REVIEW=$(timeout 60 copilot --allow-all -p "Quick security review of @$file - critical issues only" 2>/dev/null)
-
- # Check if timeout occurred
+ # 멈춤 현상을 방지하기 위해 타임아웃을 사용합니다(파일당 60초).
+ # --allow-all 옵션은 파일 읽기/쓰기 권한을 자동으로 승인하여 후크가 자동으로 실행되도록 합니다.
+ # 자동화된 스크립트에서만 사용하십시오. 대화형 세션에서는 Copilot이 권한을 요청하도록 하십시오.
+ REVIEW=$(timeout 60 copilot --allow-all -p "Quick security review of @$file - critical issues only" 2>/dev/null)
+
+ # 타임아웃 발생 여부 확인
if [ $? -eq 124 ]; then
echo "Warning: Review timed out for $file (skipping)"
continue
@@ -205,24 +204,25 @@ if [ -n "$STAGED" ]; then
fi
done
- echo "Review passed"
+ echo "검토 통과"
fi
EOF
chmod +x .git/hooks/pre-commit
```
-> ⚠️ **macOS users**: The `timeout` command is not included by default on macOS. Install it with `brew install coreutils` or replace `timeout 60` with a simple invocation without a timeout guard.
+> ⚠️ **macOS 사용자**: `timeout` 명령어는 macOS에 기본적으로 포함되어 있지 않습니다. `brew install coreutils` 명령어로 설치하거나, `timeout 60` 대신 타임아웃 가드가 없는 간단한 명령어를 사용하세요.
+
+> 📚 **공식 문서**: 전체 훅 API에 대한 자세한 내용은 [훅 사용 방법](https://docs.github.com/copilot/how-tos/copilot-cli/use-hooks) 및 [훅 구성 참조](https://docs.github.com/copilot/reference/hooks-configuration)를 참조하세요.
-> 📚 **Official Documentation**: [Use hooks](https://docs.github.com/copilot/how-tos/copilot-cli/use-hooks) and [Hooks configuration reference](https://docs.github.com/copilot/reference/hooks-configuration) for the complete hooks API.
>
-> 💡 **Built-in alternative**: Copilot CLI also has a built-in hooks system (`copilot hooks`) that can run automatically on events like pre-commit. The manual git hook above gives you full control, while the built-in system is simpler to configure. See the docs above to decide which approach fits your workflow.
+> 💡 **내장 대안**: Copilot CLI에는 pre-commit과 같은 이벤트에서 자동으로 실행되는 내장 훅 시스템(`copilot hooks`)도 있습니다. 위의 수동 Git 훅은 완벽한 제어를 제공하는 반면, 내장 시스템은 구성이 더 간단합니다. 어떤 방식이 워크플로에 적합한지 위의 문서를 참조하세요.
-Now every commit gets a quick security review:
+이제 모든 커밋은 빠른 보안 검토를 거칩니다.
```bash
git add samples/book-app-project/books.py
-git commit -m "Update book collection methods"
+git commit -m "도서 수집 방법을 업데이트합니다"
# Output:
# Running Copilot review on staged files...
@@ -235,122 +235,122 @@ git commit -m "Update book collection methods"
---
-## Workflow 3: Onboarding to a New Codebase
+## 워크플로 3: 새로운 코드베이스 온보딩
-When joining a new project, combine context, agents, and MCP to ramp up fast:
+새로운 프로젝트에 참여할 때는 컨텍스트, 에이전트 및 MCP를 결합하여 빠르게 적응하세요.
```bash
-# Start Copilot in interactive mode
+# Copilot을 대화형 모드로 시작하세요
copilot
-# PHASE 1: Get the big picture with context
-> @samples/book-app-project/ Explain the high-level architecture of this codebase
+# PHASE 1: 맥락을 고려하여 전체적인 상황을 파악하세요.
+> @samples/book-app-project/ 이 코드베이스의 상위 수준 아키텍처를 설명하십시오.
-# PHASE 2: Understand a specific flow
-> @samples/book-app-project/book_app.py Walk me through what happens
-> when a user runs "python book_app.py add"
+# PHASE 2: 특정 흐름을 이해하세요
+> @samples/book-app-project/book_app.py 어떤 일이 발생하는지 설명해 주세요.
+> 사용자가 "python book_app.py add"를 실행할 때
-# PHASE 3: Get expert analysis with an agent
+# PHASE 3: Agent와 전문가 분석을 받으세요
> /agent
-# Select "python-reviewer"
+# "python-reviewer"를 선택하세요
-> @samples/book-app-project/books.py Are there any design issues,
-> missing error handling, or improvements you would recommend?
+> @samples/book-app-project/books.py 파일에 디자인 문제,
+> 누락된 오류 처리 또는 권장할 만한 개선 사항이 있습니까?
-# PHASE 4: Find something to work on (MCP provides GitHub access)
-> List open issues labeled "good first issue"
+# PHASE 4: 작업할 주제를 찾아보세요 (MCP는 GitHub 접근 권한을 제공합니다)
+> "첫 번째 이슈로 적합"이라고 표시된 미해결 이슈 목록을 확인하세요
-# PHASE 5: Start contributing
-> Pick the simplest open issue and outline a plan to fix it
+# PHASE 5: 기여를 시작하세요
+> 가장 간단한 미해결 문제를 선택하고 해결 계획을 세우세요
```
-This workflow combines `@` context, agents, and MCP into a single onboarding session, exactly the integration pattern from earlier in this chapter.
+이 워크플로는 `@` 컨텍스트, 에이전트 및 MCP를 단일 온보딩 세션으로 결합하며, 이는 이 장 앞부분에서 설명한 통합 패턴과 정확히 일치합니다.
---
-# Best Practices & Automation
+# 모범 사례 및 자동화
-Patterns and habits that make your workflows more effective.
+업무 효율성을 높이는 패턴과 습관.
---
-## Best Practices
+## 모범 사례
-### 1. Start with Context Before Analysis
+### 1. 분석에 앞서 맥락 파악부터 시작하세요
-Always gather context before asking for analysis:
+분석을 요청하기 전에 항상 맥락을 파악하세요.
```bash
# Good
-> Get the details of issue #42
+> 42번 이슈의 자세한 내용을 확인하세요
> /agent
-# Select python-reviewer
-> Analyze this issue
+# 파이썬 리뷰어를 선택하세요
+> 이 문제를 분석하세요
-# Less effective
+# 효과가 떨어짐
> /agent
-# Select python-reviewer
-> Fix login bug
-# Agent doesn't have issue context
+# 파이썬 리뷰어를 선택하세요
+> 로그인 버그 수정
+# Agent에 문제 컨텍스트가 없습니다.
```
-### 2. Know the Difference: Agents, Skills, and Custom Instructions
+### 2. 차이점을 알아두세요: 에이전트, 스킬, 그리고 사용자 지정 지침
-Each tool has a sweet spot:
+각 도구에는 최적의 사용 지점이 있습니다.
```bash
-# Agents: Specialized personas you explicitly activate
+# Agents: 사용자가 명시적으로 활성화하는 특수 페르소나
> /agent
-# Select python-reviewer
-> Review this authentication code for security issues
+# 파이썬 리뷰어를 선택
+> 이 인증 코드의 보안 문제를 검토하십시오.
-# Skills: Modular capabilities that auto-activate when your prompt
-# matches the skill's description (you must create them first — see Ch 05)
-> Generate comprehensive tests for this code
-# If you have a testing skill configured, it activates automatically
+# Skills: 사용자의 요청에 따라 자동으로 활성화되는 모듈형 기능
+# 스킬 설명과 일치해야 합니다(먼저 생성해야 합니다. 5장을 참조하세요).
+> 이 코드에 대한 포괄적인 테스트를 생성하세요.
+# 테스트 스킬이 구성되어 있으면 자동으로 활성화됩니다.
-# Custom instructions (.github/copilot-instructions.md): Always-on
-# guidance that applies to every session without switching or triggering
+# 사용자 지정 지침(.github/copilot-instructions.md): 항상 켜짐
+# 세션 전환이나 트리거 없이 모든 세션에 적용되는 지침입니다.
```
-> 💡 **Key point**: Agents and skills can both analyze AND generate code. The real difference is **how they activate** — agents are explicit (`/agent`), skills are automatic (prompt-matched), and custom instructions are always on.
+> 💡 **핵심 요점**: 에이전트와 스킬 모두 코드를 분석하고 생성할 수 있습니다. 진정한 차이점은 **활성화 방식**에 있습니다. 에이전트는 명시적 실행(`/agent`)을 통해 작동하고, 스킬은 자동 실행(프롬프트 일치)을 통해 작동하며, 사용자 지정 지침은 항상 활성화되어 있습니다.
-### 3. Keep Sessions Focused
+### 3. Session의 초점을 유지하세요
-Use `/rename` to label your session (makes it easy to find in history) and `/exit` to end it cleanly:
+세션에 이름을 지정하려면 `/rename` 명령어를 사용하고(이렇게 하면 기록에서 쉽게 찾을 수 있습니다), 깔끔하게 종료하려면 `/exit` 명령어를 사용하세요.
```bash
-# Good: One feature per session
+# Good: 세션당 하나의 기능만 사용 가능
> /rename list-unread-feature
-# Work on list unread
+# 읽지 않은 목록 작업
> /exit
copilot
> /rename export-csv-feature
-# Work on CSV export
+# CSV 내보내기 작업
> /exit
-# Less effective: Everything in one long session
+# 효과가 떨어지는 방식: 모든 것을 한 번의 긴 시간에 끝내는 것
```
-### 4. Make Workflows Reusable with Copilot
+### 4. Copilot을 사용하여 워크플로우를 재사용 가능하게 만드세요
-Instead of just documenting workflows in a wiki, encode them directly in your repo where Copilot can use them:
+워크플로를 위키에 문서화하는 대신, Copilot이 사용할 수 있도록 저장소에 직접 인코딩하세요.
-- **Custom instructions** (`.github/copilot-instructions.md`): Always-on guidance for coding standards, architecture rules, and build/test/deploy steps. Every session follows them automatically.
-- **Prompt files** (`.github/prompts/`): Reusable, parameterized prompts your team can share — like templates for code reviews, component generation, or PR descriptions.
-- **Custom agents** (`.github/agents/`): Encode specialized personas (e.g., a security reviewer or a docs writer) that anyone on the team can activate with `/agent`.
-- **Custom skills** (`.github/skills/`): Package step-by-step workflow instructions that auto-activate when relevant.
+- **Custom instructions** (`.github/copilot-instructions.md`): 코딩 표준, 아키텍처 규칙, 빌드/테스트/배포 단계에 대한 항상 연결된 안내를 제공합니다. 모든 세션은 자동으로 그들을 따라갑니다.
+- **Prompt files** (`.github/prompts/`): 코드 리뷰, 컴포넌트 생성, PR 설명 템플릿 등 재사용 가능한 매개변수화된 프롬프트를 팀이 공유할 수 있습니다.
+- **Custom agents** (`.github/agents/`): 팀 내 누구나 '/agent'로 활성화할 수 있는 전문 페르소나(예: 보안 리뷰어나 문서 작성자)를 인코딩합니다.
+- **Custom skills** (`.github/skills/`): 관련 사항이 있을 때 자동으로 활성화되는 단계별 워크플로우 지침을 패키지로 구성하세요.
-> 💡 **The payoff**: New team members get your workflows for free — they're built into the repo, not locked in someone's head.
+> 💡 **결점**: 새로운 팀 구성원은 워크플로를 무료로 이용할 수 있습니다. 워크플로는 저장소에 구축되어 있으므로 누군가의 머릿속에만 갇혀 있지 않습니다.
---
-## Bonus: Production Patterns
+## 보너스: 제작 패턴
-These patterns are optional but valuable for professional environments.
+이 패턴들은 선택 사항이지만, 전문적인 환경에서 유용합니다.
-### PR Description Generator
+### 보도자료 설명 생성기
```bash
# Generate comprehensive PR descriptions
@@ -365,7 +365,7 @@ $COMMITS
Include: Summary, Changes Made, Testing Done, Screenshots Needed"
```
-### CI/CD Integration
+### CI/CD 통합
For teams with existing CI/CD pipelines, you can automate Copilot reviews on every pull request using GitHub Actions. This includes posting review comments automatically and filtering for critical issues.
@@ -373,7 +373,7 @@ For teams with existing CI/CD pipelines, you can automate Copilot reviews on eve
---
-# Practice
+# 관행
@@ -381,132 +381,130 @@ Put the complete workflow into practice.
---
-## ▶️ Try It Yourself
+## ▶️ 직접 시도해 보세요
-After completing the demos, try these variations:
+데모를 완료한 후 다음 변형들을 시도해 보세요:
-1. **End-to-End Challenge**: Pick a small feature (e.g., "list unread books" or "export to CSV"). Use the full workflow:
- - Plan with `/plan`
- - Design with agents (python-reviewer, pytest-helper)
+1. **종합 구현 과제**: 작은 기능 하나를 선택하세요(예: "읽지 않은 책 목록 보기" 또는 "CSV 파일로 내보내기"). 전체 워크플로를 활용해 보세요.
+ - `/plan` 명령어를 사용하여 계획을 세우세요.
+ - 에이전트를 활용한 설계 (python-reviewer, pytest-helper)
- Implement
- - Generate tests
- - Create PR
+ - 테스트 생성
+ - PR 만들기
-2. **Automation Challenge**: Set up the pre-commit hook from the Code Review Automation workflow. Make a commit with an intentional file path vulnerability. Does it get blocked?
+2. **자동화 챌린지**: 코드 검토 자동화 워크플로에서 사전 커밋 훅을 설정합니다. 의도적으로 파일 경로 취약점을 포함한 커밋을 생성합니다. 이 커밋이 차단됩니까?
-3. **Your Production Workflow**: Design your own workflow for a common task you do. Write it down as a checklist. What parts could be automated with skills, agents, or hooks?
+3. **귀사의 생산 워크플로우**: 자주 하는 작업에 대한 워크플로우를 직접 설계해 보세요. 체크리스트 형태로 작성해 보고, 스킬, 에이전트 또는 훅을 활용하여 자동화할 수 있는 부분은 무엇인지 생각해 보세요.
-**Self-Check**: You've completed the course when you can explain to a colleague how agents, skills, and MCP work together - and when to use each.
+**셀프 체크**: 에이전트, 스킬, MCP가 어떻게 상호 작용하는지, 그리고 각각을 언제 사용해야 하는지 동료에게 설명할 수 있게 되면 과정을 완료한 것입니다.
---
-## 📝 Assignment
+## 📝 과제
-### Main Challenge: End-to-End Feature
+### 주요 과제: 엔드 투 엔드 기능 구현
-The hands-on examples walked through building a "list unread books" feature. Now practice the full workflow on a different feature: **search books by year range**:
+실습 예제를 통해 "읽지 않은 책 목록" 기능을 구축하는 과정을 단계별로 안내했습니다. 이제 다른 기능인 **연도 범위로 책 검색**에 전체 워크플로를 적용해 보겠습니다.
-1. Start Copilot and gather context: `@samples/book-app-project/books.py`
-2. Plan with `/plan Add a "search by year" command that lets users find books published between two years`
-3. Implement a `find_by_year_range(start_year, end_year)` method in `BookCollection`
-4. Add a `handle_search_year()` function in `book_app.py` that prompts the user for start and end years
-5. Generate tests: `@samples/book-app-project/books.py @samples/book-app-project/tests/test_books.py Generate tests for find_by_year_range() including edge cases like invalid years, reversed range, and no results.`
-6. Review with `/review`
-7. Update the README: `@samples/book-app-project/README.md Add documentation for the new "search by year" command.`
-8. Generate a commit message
+1. Copilot을 시작하고 컨텍스트를 수집합니다. `@samples/book-app-project/books.py`
+2. `/plan` 명령으로 계획을 세웁니다. 사용자가 두 해 사이에 출판된 책을 찾을 수 있는 "연도별 검색" 명령을 추가합니다.
+3. `BookCollection` 클래스에 `find_by_year_range(start_year, end_year)` 메서드를 구현합니다.
+4. `book_app.py` 파일에 시작 연도와 종료 연도를 입력받는 `handle_search_year()` 함수를 추가합니다.
+5. 테스트를 생성합니다. `@samples/book-app-project/books.py @samples/book-app-project/tests/test_books.py `잘못된 연도, 범위 반전, 검색 결과 없음과 같은 예외 상황을 포함하여 `find_by_year_range()` 함수에 대한 테스트를 생성합니다.`
+6. `/review` 명령으로 검토합니다.
+7. README 파일을 업데이트합니다. `@samples/book-app-project/README.md`에 다음 내용을 추가합니다. 새로운 "연도별 검색" 명령에 대한 문서를 작성합니다.
+8. 커밋 메시지를 생성합니다.
-Document your workflow as you go.
+진행 과정을 문서화하세요.
-**Success criteria**: You've completed the feature from idea to commit using Copilot CLI, including planning, implementation, tests, documentation, and review.
+**성공 기준**: Copilot CLI를 사용하여 아이디어 구상부터 커밋까지(계획, 구현, 테스트, 문서화 및 검토 포함) 기능을 완료했습니다.
-> 💡 **Bonus**: If you have agents set up from Chapter 04, try creating and using custom agents. For example, an error-handler agent for implementation review and a doc-writer agent for the README update.
+> 💡 **보너스**: 4장에서 에이전트를 설정했다면, 사용자 지정 에이전트를 만들어 사용해 보세요. 예를 들어, 구현 검토를 위한 오류 처리 에이전트와 README 업데이트를 위한 문서 작성 에이전트를 만들 수 있습니다.
-
-
---
💡 Hints (click to expand)
+<세부 정보> +<요약>💡 힌트 (클릭하여 펼치기) -**Follow the pattern from the ["Idea to Merged PR"](#idea-to-merged-pr-in-one-session) example** at the top of this chapter. The key steps are: +**이 장 상단의 ["아이디어에서 병합된 PR까지"](#idea-to-merged-pr-in-one-session) 예제의 패턴을 따르세요.** 주요 단계는 다음과 같습니다. -1. Gather context with `@samples/book-app-project/books.py` -2. Plan with `/plan Add a "search by year" command` -3. Implement the method and command handler -4. Generate tests with edge cases (invalid input, empty results, reversed range) -5. Review with `/review` -6. Update README with `@samples/book-app-project/README.md` -7. Generate commit message with `-p` +1. `@samples/book-app-project/books.py`를 사용하여 컨텍스트를 수집합니다. +2. `/plan Add a “search by year” command`를 사용하여 계획을 수립합니다. +3. 메서드와 명령 핸들러를 구현합니다. +4. 예외 상황(잘못된 입력, 빈 결과, 역순 범위)을 고려한 테스트를 생성합니다. +5. `/review`를 사용하여 검토합니다. +6. `@samples/book-app-project/README.md`를 사용하여 README를 업데이트합니다. +7. `-p` 옵션을 사용하여 커밋 메시지를 생성합니다. -**Edge cases to think about:** -- What if the user enters "2000" and "1990" (reversed range)? -- What if no books match the range? -- What if the user enters non-numeric input? +**고려해야 할 예외 상황:** +- 사용자가 "2000"과 "1990"을 입력하는 경우(역순 범위)는 어떻게 처리할까요? +- 범위에 맞는 책이 없는 경우는 어떻게 처리할까요? +- 사용자가 숫자가 아닌 값을 입력하는 경우는 어떻게 처리할까요? -**The key is practicing the full workflow** from idea → context → plan → implement → test → document → commit. +**핵심은 아이디어 → 컨텍스트 → 계획 → 구현 → 테스트 → 문서화 → 커밋의 전체 워크플로를 연습하는 것입니다.**
-
---
-# Summary
+# 요약
-## 🔑 Key Takeaways
+## 🔑 핵심 요점
-1. **Integration > Isolation**: Combine tools for maximum impact
-2. **Context first**: Always gather required context before analysis
-3. **Agents analyze, Skills execute**: Use the right tool for the job
-4. **Automate repetition**: Hooks and scripts multiply your effectiveness
-5. **Document workflows**: Shareable patterns benefit the whole team
-
-> 📋 **Quick Reference**: See the [GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference) for a complete list of commands and shortcuts.
+1. **통합 > 분리**: 최대 효과를 위해 도구를 결합하세요.
+2. **맥락 우선**: 분석 전에 항상 필요한 맥락을 수집하세요.
+3. **에이전트는 분석, 스킬은 실행**: 작업에 맞는 도구를 사용하세요.
+4. **반복 작업 자동화**: 훅과 스크립트를 활용하여 효율성을 높이세요.
+5. **워크플로우 문서화**: 공유 가능한 패턴은 팀 전체에 도움이 됩니다.
+> 📋 **빠른 참조**: 전체 명령 및 단축키 목록은 [GitHub Copilot CLI 명령 참조](https://docs.github.com/en/copilot/reference/cli-command-reference)를 참조하세요.
---
-## 🎓 Course Complete!
-
-Congratulations! You've learned:
+## 🎓 과정 완료!
-| Chapter | What You Learned |
-|---------|-------------------|
-| 00 | Copilot CLI installation and Quick Start |
-| 01 | Three modes of interaction |
-| 02 | Context management with @ syntax |
-| 03 | Development workflows |
-| 04 | Specialized agents |
-| 05 | Extensible skills |
-| 06 | External connections with MCP |
-| 07 | Unified production workflows |
+축하합니다! 다음 내용을 학습하셨습니다.
-You're now equipped to use GitHub Copilot CLI as a genuine force multiplier in your development workflow.
+| 챕터 | 학습 내용 |
+---------|-------------------|
+| 00 | Copilot CLI 설치 및 빠른 시작 |
+| 01 | 세 가지 상호 작용 모드 |
+| 02 | @ 구문을 사용한 컨텍스트 관리 |
+| 03 | 개발 워크플로 |
+| 04 | 특수 에이전트 |
+| 05 | 확장 가능한 스킬 |
+| 06 | MCP를 사용한 외부 연결 |
+| 07 | 통합 프로덕션 워크플로 |
-## ➡️ What's Next
+이제 GitHub Copilot CLI를 개발 워크플로에서 진정한 시너지 효과를 내는 도구로 활용할 준비가 되었습니다.
-Your learning doesn't stop here:
+## ➡️ 다음 단계
-1. **Practice daily**: Use Copilot CLI for real work
-2. **Build custom tools**: Create agents and skills for your specific needs
-3. **Share knowledge**: Help your team adopt these workflows
-4. **Stay updated**: Follow GitHub Copilot updates for new features
+학습은 여기서 끝나지 않습니다.
-### Resources
+1. **매일 연습하세요**: Copilot CLI를 사용하여 실제 업무를 수행하세요.
+2. **맞춤형 도구를 만드세요**: 특정 요구 사항에 맞는 에이전트와 스킬을 제작하세요.
+3. **지식을 공유하세요**: 팀원들이 이러한 워크플로를 도입하도록 지원하세요.
+4. **최신 정보를 확인하세요**: GitHub Copilot 업데이트를 팔로우하여 새로운 기능을 확인하세요.
+### 자료
- [GitHub Copilot CLI Documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli)
- [MCP Server Registry](https://github.com/modelcontextprotocol/servers)
- [Community Skills](https://github.com/topics/copilot-skill)
---
-**Great job! Now go build something amazing.**
+정말 잘했어요! 이제 멋진 작품을 만들어 보세요.
**[← Back to Chapter 06](../06-mcp-servers/README.md)** | **[Return to Course Home →](../README.md)**
diff --git a/AGENTS.md b/AGENTS.md
index 649a9469..15e012b9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,38 +1,38 @@
# AGENTS.md
-Beginner-friendly course teaching GitHub Copilot CLI. Educational content, not software.
+GitHub Copilot CLI를 배우는 초보자 친화적인 강좌입니다. 소프트웨어가 아닌 교육 콘텐츠입니다.
-## Structure
+## 구조
-| Path | Purpose |
+| 경로 | 목적 |
|------|---------|
-| `00-07/` | Chapters: analogy → concepts → hands-on → assignment → next |
-| `samples/book-app-project/` | **Primary sample**: Python CLI book collection app used throughout all chapters |
-| `samples/book-app-project-cs/` | C# version of the book collection app |
-| `samples/book-app-project-js/` | JavaScript version of the book collection app |
-| `samples/book-app-buggy/` | **Intentional bugs** for debugging exercises (Ch 03) |
-| `samples/agents/` | Agent template examples (python-reviewer, pytest-helper, hello-world) |
-| `samples/skills/` | Skill template examples (code-checklist, pytest-gen, commit-message, hello-world) |
-| `samples/mcp-configs/` | MCP server configuration examples |
-| `samples/buggy-code/` | **Optional extra**: Security-focused buggy code (JS and Python) |
-| `samples/src/` | **Optional extra**: Legacy JS/React samples from earlier course version |
-| `appendices/` | Supplementary reference material |
-
-## Do
-
-- Keep explanations beginner-friendly; explain AI/ML jargon when used
-- Ensure bash examples are copy-paste ready
-- Tone: friendly, encouraging, practical
-- Use `samples/book-app-project/` paths in all primary examples
-- Use Python/pytest context for code examples
-
-## Don't
-
-- Fix bugs in `samples/book-app-buggy/` or `samples/buggy-code/` — they're intentional
-- Add chapters without updating README.md course table
-- Assume readers know AI/ML terminology
-
-## Build
+| `00-07/` | 목차: 비유 → 개념 → 실습 → 과제 → 다음 단계 |
+| `samples/book-app-project/` | **주요 예제**: 모든 장에서 사용되는 Python CLI 기반 도서 수집 앱 |
+| `samples/book-app-project-cs/` | 도서 수집 앱의 C# 버전 |
+| `samples/book-app-project-js/` | 도서 수집 앱의 JavaScript 버전 |
+| `samples/book-app-buggy/` | 디버깅 연습을 위한 **의도적인 버그** (3장) |
+| `samples/agents/` | 에이전트 템플릿 예제 (python-reviewer, pytest-helper, hello-world) |
+| `samples/skills/` | 스킬 템플릿 예제 (코드 체크리스트, pytest 생성, 커밋 메시지, hello-world) |
+| `samples/mcp-configs/` | MCP 서버 구성 예제 |
+| `samples/buggy-code/` | **선택 사항**: 보안에 초점을 맞춘 버그 코드 (JS 및 Python) |
+| `samples/src/` | **선택 사항**: 이전 강좌 버전의 레거시 JS/React 샘플 |
+| `appendices/` | 추가 참고 자료 |
+
+## 해야 할 일
+
+- 설명은 초보자가 이해하기 쉽게 작성하세요. AI/ML 용어 사용 시 설명
+- bash 예제는 복사 붙여넣기 가능하도록 작성
+- 어조: 친근하고, 격려적이며, 실용적
+- 모든 주요 예제에 `samples/book-app-project/` 경로 사용
+- 코드 예제에 Python/pytest 컨텍스트 사용
+
+## 하지 말아야 할 것
+
+- `samples/book-app-buggy/` 또는 `samples/buggy-code/`의 버그 수정 - 의도적인 버그입니다
+- README.md의 코스 표를 업데이트하지 않고 챕터 추가
+- 독자가 AI/ML 용어를 알고 있다고 가정
+
+## 빌드
```bash
npm install && npm run release
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index bf19a5e4..6c554e12 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,128 +1,101 @@
-# Contributor Covenant Code of Conduct
+# 기여자 서약 행동 강령
-## Our Pledge
+## 우리의 약속
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
+회원, 기여자, 그리고 리더로서 우리는 모든 사람이 나이, 체형,
+장애(유형 또는 비가시적), 인종, 성별, 성 정체성 및 표현, 경험 수준, 교육 수준, 사회경제적 지위,
+국적, 외모, 인종, 종교 또는 성적 정체성 및 성적 지향에 관계없이 괴롭힘 없는 환경에서 커뮤니티에 참여할 수 있도록 최선을 다할 것을 약속합니다.
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
+우리는 개방적이고, 포용적이며, 다양하고, 포용적이며, 건강한 커뮤니티를 만드는 데 기여하는 방식으로 행동하고 소통할 것을 약속합니다.
-## Our Standards
+## 우리의 기준
-Examples of behavior that contributes to a positive environment for our
-community include:
+긍정적인 커뮤니티 환경 조성에 기여하는 행동의 예는 다음과 같습니다.
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
- and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
- overall community
+* 다른 사람에 대한 공감과 친절을 보여주는 것
+* 서로 다른 의견, 관점, 경험을 존중하는 것
+* 건설적인 피드백을 주고받고 겸허하게 수용하는 것
+* 자신의 실수로 피해를 입은 사람들에게 책임을 인정하고 사과하며,
+그 경험에서 배우는 것
+* 개인뿐 아니라 커뮤니티 전체를 위해 최선을 다하는 것
-Examples of unacceptable behavior include:
+용납할 수 없는 행동의 예는 다음과 같습니다.
-* The use of sexualized language or imagery, and sexual attention or
- advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
- address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
+* 성적인 언어나 이미지 사용, 성적인 관심이나
+접근 시도
+* 트롤링, 모욕적이거나 비하적인 댓글, 개인적 또는 정치적 공격
+* 공개적 또는 사적인 괴롭힘
+* 타인의 개인 정보(예: 실명 또는 이메일 주소)를 명시적인 허가 없이 공개하는 것
+* 전문적인 환경에서 부적절하다고 합리적으로 간주될 수 있는 기타 행동
-## Enforcement Responsibilities
+## 시행 책임
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
+커뮤니티 리더는 다음 사항을 명확히 하고 시행할 책임이 있습니다. 저희는 허용 가능한 행동 기준을 정하고 있으며, 부적절하거나, 위협적이거나, 모욕적이거나, 유해하다고 판단되는 모든 행동에 대해 적절하고 공정한 시정 조치를 취할 것입니다.
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
+커뮤니티 리더는 본 행동 강령에 부합하지 않는 댓글, 커밋, 코드, 위키 편집, 이슈 및 기타 기여물을 삭제, 수정 또는 거부할 권리와 책임이 있으며, 적절한 경우 중재 결정 사유를 공지할 것입니다.
-## Scope
+## 적용 범위
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
+본 행동 강령은 모든 커뮤니티 공간에 적용되며, 개인이 공식적으로 커뮤니티를 대표하는 경우에도 적용됩니다.
-## Enforcement
+커뮤니티를 대표하는 예로는 공식 이메일 주소 사용, 공식 소셜 미디어 계정 게시, 온라인 또는 오프라인 행사에서 임명된 대표자 활동 등이 있습니다.
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-GitHub.
-All complaints will be reviewed and investigated promptly and fairly.
+## 시행
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
+남용, 괴롭힘 또는 기타 용납할 수 없는 행동은 GitHub의 시행 담당 커뮤니티 리더에게 신고할 수 있습니다.
-## Enforcement Guidelines
+모든 신고는 신속하고 공정하게 검토 및 조사됩니다.
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
+모든 커뮤니티 리더는 사건 신고자의 사생활과 보안을 존중할 의무가 있습니다.
-### 1. Correction
+## 시행 지침
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
+커뮤니티 리더는 다음 커뮤니티 영향 지침을 따라 본 행동 강령을 위반하는 행위에 대한 결과를 결정합니다.
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
+### 1. 시정
-### 2. Warning
+**커뮤니티 영향**: 부적절한 언어 사용 또는 커뮤니티에서 전문적이지 않거나 바람직하지 않다고 여겨지는 기타 행동.
-**Community Impact**: A violation through a single incident or series
-of actions.
+**결과**: 커뮤니티 리더가 위반 행위의 성격과 해당 행동이 부적절했던 이유를 명확히 설명하는 비공개 서면 경고를 발송합니다.
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
+공개 사과를 요청할 수 있습니다.
-### 3. Temporary Ban
+### 2. 경고
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
+**커뮤니티 영향**: 단일 사건 또는 일련의 행동을 통한 위반.
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
+**결과**: 경고와 함께, 위반 행위가 지속될 경우 그에 따른 결과가 부과됩니다. 지정된 기간 동안 관련자들과의 모든 상호 작용이 금지됩니다. 여기에는 행동 강령을 집행하는 사람과의 원치 않는 상호 작용도 포함됩니다.
+이는 커뮤니티 공간뿐 아니라 소셜 미디어와 같은 외부 채널에서의 상호 작용도 금지하는 것을 의미합니다.
+이러한 조건을 위반할 경우 일시적 또는 영구적 차단 조치가 취해질 수 있습니다.
-### 4. Permanent Ban
+### 3. 일시적 차단
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior, harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
+**커뮤니티 영향**: 커뮤니티 기준을 심각하게 위반한 경우(지속적인 부적절한 행동 포함)
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
+**결과**: 지정된 기간 동안 커뮤니티와의 모든 종류의 상호 작용 또는 공개적인 소통이 일시적으로 금지됩니다.
+이 기간 동안 관련자들과의 공개적 또는 비공개적 상호 작용은 허용되지 않으며, 행동 강령을 집행하는 사람과의 원치 않는 상호 작용도 포함됩니다.
-## Attribution
+이러한 조건을 위반할 경우 영구적 차단 조치가 취해질 수 있습니다.
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+### 4. 영구 차단
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
+**커뮤니티 영향**: 커뮤니티 기준을 반복적으로 위반하는 경우,
+부적절한 행동 지속, 개인에 대한 괴롭힘,
+또는 특정 집단에 대한 공격이나 비방 등이 포함됩니다.
-[homepage]: https://www.contributor-covenant.org
+**결과**: 커뮤니티 내 모든 공개적인 활동에 대한 영구 차단
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.
\ No newline at end of file
+
+## 출처
+
+본 행동 강령은 [기여자 규약][홈페이지],
+버전 2.0(https://www.contributor-covenant.org/version/2/0/code_of_conduct.html)을 기반으로 작성되었습니다.
+
+커뮤니티 영향 가이드라인은 [모질라 행동 강령
+시행 단계](https://github.com/mozilla/diversity)에서 영감을 받았습니다.
+
+[홈페이지]: https://www.contributor-covenant.org/version/2/0/code_of_conduct.html
+
+본 행동 강령에 대한 일반적인 질문에 대한 답변은 FAQ에서 확인하실 수 있습니다.
+https://www.contributor-covenant.org/faq. 번역본은 다음 링크에서 확인하실 수 있습니다.
+https://www.contributor-covenant.org/translations.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 65d17bab..7877b0de 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +1,10 @@
-## Contributing
+## 기여하기
-[fork]: https://github.com/github/REPO/fork
-[pr]: https://github.com/github/REPO/compare
+[포크]: https://github.com/github/REPO/fork
+[프러포]: https://github.com/github/REPO/compare
-Hi there! We're thrilled that you'd like to contribute to this project. Your help is essential for keeping it great.
+안녕하세요! 이 프로젝트에 기여해 주셔서 정말 기쁩니다. 여러분의 도움은 이 프로젝트를 훌륭하게 유지하는 데 매우 중요합니다.
-Contributions to this project are [released](https://help.github.com/articles/github-terms-of-service/#6-contributions-under-repository-license) to the public under the [project's open source license](LICENSE.txt).
+이 프로젝트에 대한 기여는 [프로젝트의 오픈 소스 라이선스](LICENSE.txt)에 따라 공개적으로 배포됩니다.
-Please note that this project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
+이 프로젝트는 [기여자 행동 강령](CODE_OF_CONDUCT.md)과 함께 배포됩니다. 이 프로젝트에 참여함으로써 여러분은 해당 강령의 조항을 준수하는 데 동의하는 것입니다.
diff --git a/README.md b/README.md
index 1d9ae0d9..5648efd1 100644
--- a/README.md
+++ b/README.md
@@ -7,19 +7,19 @@
🎯 [What You'll Learn](#what-youll-learn) ✅ [Prerequisites](#prerequisites) 🤖 [Copilot Family](#understanding-the-github-copilot-family) 📚 [Course Structure](#course-structure) 📋 [Command Reference](#-github-copilot-cli-command-reference)
-# GitHub Copilot CLI for Beginners
+# GitHub Copilot CLI 초보자용
-> **✨ Learn to supercharge your development workflow with AI-powered command-line assistance.**
+> **✨ AI 기반 명령줄 지원으로 개발 워크플로우를 강화하는 방법을 배워보세요.**
-GitHub Copilot CLI brings AI assistance directly to your terminal. Instead of switching to a browser or code editor, you can ask questions, generate full-featured applications, review code, generate tests, and debug issues without leaving your command line.
+GitHub Copilot CLI는 AI 지원 기능을 터미널에서 바로 사용할 수 있도록 해줍니다. 브라우저나 코드 편집기로 전환할 필요 없이 명령줄에서 바로 질문하고, 모든 기능을 갖춘 애플리케이션을 생성하고, 코드를 검토하고, 테스트를 생성하고, 문제를 디버깅할 수 있습니다.
-Think of it as having a knowledgeable colleague available 24/7 who can read your code, explain confusing patterns, and help you work faster!
+마치 24시간 내내 코드를 분석하고, 복잡한 패턴을 설명해주고, 작업 속도를 높여줄 수 있는 지식이 풍부한 동료가 있는 것과 같다고 생각하시면 됩니다!
-This course is designed for:
+이 과정은 다음을 위해 설계되었습니다.:
-- **Software Developers** who want to use AI from the command line
-- **Terminal users** who prefer keyboard-driven workflows over IDE integrations
-- **Teams looking to standardize** AI-assisted code review and development practices
+- 명령줄에서 AI를 사용하려는 **소프트웨어 개발자**
+- IDE 통합보다 키보드 기반 워크플로를 선호하는 **터미널 사용자**
+- **AI 기반 코드 검토 및 개발 방식을 표준화하려는 팀**
🔧 Common Mistakes (click to expand)
+🔧 흔히 저지르는 실수 (클릭하여 펼치기)
-| Mistake | What Happens | Fix | +| 실수 | 발생 원인 | 해결 방법 | |---------|--------------|-----| -| Jumping straight to implementation | Miss design issues that are costly to fix later | Use `/plan` first to think through the approach | -| Using one tool when multiple would help | Slower, less thorough results | Combine: Agent for analysis → Skill for execution → MCP for integration | -| Not reviewing before committing | Security issues or bugs slip through | Always run `/review` or use a [pre-commit hook](#workflow-2-code-review-automation-optional) | -| Forgetting to share workflows with team | Each person reinvents the wheel | Document patterns in shared agents, skills, and instructions | +| 바로 구현으로 넘어감 | 나중에 수정하는 데 비용이 많이 드는 설계 문제를 놓침 | 먼저 `/plan`을 사용하여 접근 방식을 구상함 | +| 여러 도구를 활용할 수 있는데도 하나의 도구만 사용함 | 속도가 느리고 결과가 불완전함 | 조합: 분석용 에이전트 → 실행용 스킬 → 통합용 MCP | +| 커밋 전에 검토하지 않음 | 보안 문제나 버그가 발생함 | 항상 `/review`를 실행하거나 [pre-commit hook](#workflow-2-code-review-automation-optional)을 사용함 | +| 팀과 워크플로를 공유하는 것을 잊음 | 각자 바퀴를 다시 발명함 | 공유 에이전트, 스킬 및 지침에 패턴을 문서화함 |-- **GitHub Copilot access**: [Free offering](https://github.com/features/copilot/plans), [Monthly subscription](https://github.com/features/copilot/plans), or [Free for students/teachers](https://education.github.com/pack)
-- **Terminal basics**: Comfortable with `cd`, `ls`, running commands +- **GitHub 계정**: [Create one free](https://github.com/signup)
+- **GitHub Copilot 접근 권한**: [Free offering](https://github.com/features/copilot/plans), [Monthly subscription](https://github.com/features/copilot/plans), or [Free for students/teachers](https://education.github.com/pack)
+- **터미널 기본 사용법**: `cd`, `ls` 명령어 사용 및 명령 실행에 익숙해야 함 -## 🤖 Understanding the GitHub Copilot Family +## 🤖 GitHub Copilot 가족 이해하기 -GitHub Copilot has evolved into a family of AI-powered tools. Here's where each one lives: +GitHub Copilot은 이제 AI 기반 도구 모음으로 발전했습니다. 각 도구의 위치는 다음과 같습니다.: -| Product | Where It Runs | Description | +| 제품 | 실행 환경 | 설명 | |---------|---------------|----------| -| [**GitHub Copilot CLI**](https://docs.github.com/copilot/how-tos/copilot-cli/cli-getting-started)
(this course) | Your terminal | Terminal-native AI coding assistant | -| [**GitHub Copilot**](https://docs.github.com/copilot) | VS Code, Visual Studio, JetBrains, etc. | Agent mode, chat, inline suggestions | -| [**Copilot on GitHub.com**](https://github.com/copilot) | GitHub | Immersive chat about your repos, create agents, and more | -| [**GitHub Copilot coding agent**](https://docs.github.com/copilot/using-github-copilot/using-copilot-coding-agent-to-work-on-tasks) | GitHub | Assign issues to agents, get PRs back | +| [**GitHub Copilot CLI**](https://docs.github.com/copilot/how-tos/copilot-cli/cli-getting-started)
(this course) | Your terminal | 터미널 네이티브 AI 코딩 어시스턴트 | +| [**GitHub Copilot**](https://docs.github.com/copilot) | VS Code, Visual Studio, JetBrains, etc. | 에이전트 모드, 채팅, 인라인 제안 | +| [**Copilot on GitHub.com**](https://github.com/copilot) | GitHub | 저장소에 대한 몰입감 있는 대화, 에이전트 생성 등 | +| [**GitHub Copilot coding agent**](https://docs.github.com/copilot/using-github-copilot/using-copilot-coding-agent-to-work-on-tasks) | GitHub | 이슈를 에이전트에게 할당하고, PR을 되찾으세요 | -This course focuses on **GitHub Copilot CLI**, bringing AI assistance directly to your terminal. +이 과정은 **GitHub Copilot CLI**에 중점을 두어 AI 지원을 직접 터미널로 제공합니다. -## 📚 Course Structure +## 📚 과정 구조  -| Chapter | Title | What You'll Build | +| 챕터 | 제목 | 만들게 될 것 | |:-------:|-------|-------------------| -| 00 | 🚀 [Quick Start](./00-quick-start/README.md) | Installation and verification | -| 01 | 👋 [First Steps](./01-setup-and-first-steps/README.md) | Live demos + three interaction modes | -| 02 | 🔍 [Context and Conversations](./02-context-conversations/README.md) | Multi-file project analysis | -| 03 | ⚡ [Development Workflows](./03-development-workflows/README.md) | Code review, debug, test generation | -| 04 | 🤖 [Create Specialized AI Assistants](./04-agents-custom-instructions/README.md) | Custom agents for your workflow | -| 05 | 🛠️ [Automate Repetitive Tasks](./05-skills/README.md) | Skills that load automatically | -| 06 | 🔌 [Connect to GitHub, Databases & APIs](./06-mcp-servers/README.md) | MCP server integration | -| 07 | 🎯 [Putting It All Together](./07-putting-it-together/README.md) | Complete feature workflows | +| 00 | 🚀 [Quick Start](./00-quick-start/README.md) | 설치 및 검증 | +| 01 | 👋 [First Steps](./01-setup-and-first-steps/README.md) | 라이브 데모 + 세 가지 상호작용 모드 | +| 02 | 🔍 [Context and Conversations](./02-context-conversations/README.md) | 다중 파일 프로젝트 분석 | +| 03 | ⚡ [Development Workflows](./03-development-workflows/README.md) | 코드 리뷰, 디버그, 테스트 생성| +| 04 | 🤖 [Create Specialized AI Assistants](./04-agents-custom-instructions/README.md) | 워크플로우에 맞는 맞춤 에이전트 | +| 05 | 🛠️ [Automate Repetitive Tasks](./05-skills/README.md) | 자동으로 로드되는 스킬들 | +| 06 | 🔌 [Connect to GitHub, Databases & APIs](./06-mcp-servers/README.md) | MCP 서버 통합 | +| 07 | 🎯 [Putting It All Together](./07-putting-it-together/README.md) | 완전한 기능 워크플로우 | -## 📖 How This Course Works +## 📖 이 과정의 작동 방식 -Each chapter follows the same pattern: +각 장은 같은 패턴을 따릅니다: -1. **Real-World Analogy**: Understand the concept through familiar comparisons -2. **Core Concepts**: Learn the essential knowledge -3. **Hands-On Examples**: Run actual commands and see results -4. **Assignment**: Practice what you learned -5. **What's Next**: Preview of the following chapter +1. **Real-World Analogy**: 친숙한 비교를 통해 개념을 이해하세요 +2. **Core Concepts**: 필수 지식을 배우세요 +3. **Hands-On Examples**: 실제 명령을 실행해 보고 결과를 확인하세요 +4. **Assignment**: 배운 것을 연습하세요 +5. **What's Next**: 다음 장 미리보기 -**Code examples are runnable.** Every copilot text block in this course can be copied and run in your terminal. +**코드 예제는 실행 가능합니다.** 이 강좌의 모든 Copilot 텍스트 블록은 복사하여 터미널에서 실행할 수 있습니다. -## 📋 GitHub Copilot CLI Command Reference +## 📋 GitHub Copilot CLI 명령어 참조 -The **[GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference)** helps you find commands and keyboard shortcuts to help you use Copilot CLI effectively. +**[GitHub Copilot CLI 명령어 참조](https://docs.github.com/en/copilot/reference/cli-command-reference)**는 Copilot CLI를 효과적으로 사용하는 데 도움이 되는 명령어와 단축키를 찾는 데 유용합니다. -## 🙋 Getting Help +## 🙋 도움 요청 -- 🐛 **Found a bug?** [Open an Issue](https://github.com/github/copilot-cli-for-beginners/issues) -- 🤝 **Want to contribute?** PRs welcome! -- 📚 **Official Docs:** [GitHub Copilot CLI Documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) +- 🐛 **버그를 발견하셨나요?** [이슈 제출](https://github.com/github/copilot-cli-for-beginners/issues) +- 🤝 **기여하고 싶으신가요?** PR을 환영합니다! -## License +- 📚 **공식 문서:** [GitHub Copilot CLI 문서](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) -This project is licensed under the terms of the MIT open source license. Please refer to the [LICENSE](./LICENSE) file for the full terms. +## 라이선스 + +이 프로젝트는 MIT 오픈 소스 라이선스 조건에 따라 배포됩니다. 전체 조건은 [LICENSE](./LICENSE) 파일을 참조하십시오. diff --git a/SECURITY.md b/SECURITY.md index 4279c87f..b70d73b7 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -1,31 +1,38 @@ -Thanks for helping make GitHub safe for everyone. +모두를 위한 안전한 GitHub 환경 조성에 도움을 주셔서 감사합니다. -# Security +# 보안 -GitHub takes the security of our software products and services seriously, including all of the open source code repositories managed through our GitHub organizations, such as [GitHub](https://github.com/GitHub). +GitHub는 GitHub 조직을 통해 관리되는 모든 오픈 소스 코드 저장소(예: [GitHub](https://github.com/GitHub))를 포함하여 소프트웨어 제품 및 서비스의 보안을 중요하게 생각합니다. -Even though [open source repositories are outside of the scope of our bug bounty program](https://bounty.github.com/index.html#scope) and therefore not eligible for bounty rewards, we will ensure that your finding gets passed along to the appropriate maintainers for remediation. +[오픈 소스 저장소는 버그 바운티 프로그램](https://bounty.github.com/index.html#scope)의 적용 범위에 포함되지 않으므로 바운티 보상 대상은 아니지만, 발견하신 내용은 해당 저장소 관리자에게 전달하여 수정 조치를 취하도록 하겠습니다. -## Reporting Security Issues +## 보안 문제 보고 -If you believe you have found a security vulnerability in any GitHub-owned repository, please report it to us through coordinated disclosure. +GitHub 소유 저장소에서 보안 취약점을 발견했다고 생각되면, 협력적 공개 방식을 통해 보고해 주세요. -**Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.** +**공개 GitHub 이슈, 토론 또는 풀 리퀘스트를 통해 보안 취약점을 보고하지 마세요.** -Instead, please send an email to opensource-security[@]github.com. +대신 opensource-security[@]github.com으로 이메일을 보내주세요. -Please include as much of the information listed below as you can to help us better understand and resolve the issue: - * The type of issue (e.g., buffer overflow, SQL injection, or cross-site scripting) - * Full paths of source file(s) related to the manifestation of the issue - * The location of the affected source code (tag/branch/commit or direct URL) - * Any special configuration required to reproduce the issue - * Step-by-step instructions to reproduce the issue - * Proof-of-concept or exploit code (if possible) - * Impact of the issue, including how an attacker might exploit the issue +문제를 더 잘 이해하고 해결하는 데 도움이 되도록 아래 정보를 최대한 자세히 포함해 주세요. -This information will help us triage your report more quickly. +* 문제 유형 (예: 버퍼 오버플로, SQL 인젝션, 크로스 사이트 스크립팅) -## Policy +* 문제 발생과 관련된 소스 파일의 전체 경로 -See [GitHub's Safe Harbor Policy](https://docs.github.com/en/site-policy/security-policies/github-bug-bounty-program-legal-safe-harbor#1-safe-harbor-terms) \ No newline at end of file +* 영향을 받는 소스 코드 위치 (태그/브랜치/커밋 또는 직접 URL) + +* 문제를 재현하는 데 필요한 특별 구성 + +* 문제 재현 단계별 지침 + +* 개념 증명 또는 익스플로잇 코드 (가능한 경우) + +* 공격자가 문제를 악용할 수 있는 방법을 포함한 문제의 영향 + +이러한 정보는 보고서를 더 신속하게 분류하는 데 도움이 됩니다. + +## 정책 + +[GitHub의 세이프 하버 정책](https://docs.github.com/en/site-policy/security-policies/github-bug-bounty-program-legal-safe-harbor#1-safe-harbor-terms)을 참조하세요. diff --git a/SUPPORT.md b/SUPPORT.md index aab64d4d..458e1bd6 100644 --- a/SUPPORT.md +++ b/SUPPORT.md @@ -1,11 +1,11 @@ -# Support +# 지원 -## How to file issues and get help +## 문제 보고 및 도움 요청 방법 -This project uses GitHub issues to track bugs and feature requests. Please search the existing issues before filing new issues to avoid duplicates. For new issues, file your bug or feature request as a new issue. +이 프로젝트는 버그 및 기능 요청을 추적하기 위해 GitHub 이슈를 사용합니다. 중복을 방지하기 위해 새 이슈를 제출하기 전에 기존 이슈를 검색해 주세요. 새로운 이슈를 제출할 때는 버그 또는 기능 요청을 새 이슈로 등록해 주세요. -For help or questions about using this project, please file an issue. +이 프로젝트 사용에 대한 도움이나 질문이 있는 경우 이슈를 등록해 주세요. -## GitHub Support Policy +## GitHub 지원 정책 -Support for this project is limited to the resources listed above. \ No newline at end of file +이 프로젝트에 대한 지원은 위에 명시된 리소스로 제한됩니다.