클로드 코드를 단계별로 배워보자!!

 

GitHub - Njengah/claude-code-cheat-sheet: Ultimate collection of Claude Code tips, tricks, hacks, and workflows that you can use

 

Claude Code는 터미널에서 직접 AI 코딩 어시스턴트를 활용할 수 있는 강력한 도구입니다. 이 가이드는 초보자부터 전문가까지, 단계별로 Claude Code를 마스터할 수 있도록 구성되었습니다.

목차

• 시작하기
• 레벨 1: 기본 명령어
• 레벨 2: 중급 명령어
• 레벨 3: 고급 명령어
• 레벨 4: 전문가 명령어
• 레벨 5: 파워 유저 명령어
• 레벨 6: 마스터 명령어

---

시작하기

설치 방법

macOS/Linux 사용자

# Claude Code 설치
curl -sL https://install.anthropic.com | sh

Windows 사용자

# WSL 실행
wsl

# npm으로 설치
npm install -g @anthropic-ai/claude-code

설치 확인

# 버전 확인
claude --version

# 설치 상태 점검
claude /doctor

실행 예제:

$ claude --version
claude-code version 1.2.3

$ claude /doctor
✓ Claude Code installation is healthy
✓ All dependencies are installed
✓ API connection successful

---

레벨 1: 기본 명령어 🟢

1.1 Claude Code 실행하기

대화형 REPL 모드로 시작

# 기본 실행
claude

# 초기 프롬프트와 함께 시작
claude "이 프로젝트를 요약해줘"

실제 사용 예제:

$ claude "이 디렉토리의 구조를 분석해줘"

Claude가 현재 디렉토리를 분석하고 다음과 같이 응답합니다:
프로젝트 구조 분석:
- src/ : 소스 코드
- tests/ : 테스트 파일
- package.json : 의존성 관리
...

1.2 기본 REPL 명령어

도움말 및 종료

/help    # 도움말 표시
/exit    # 종료
/clear   # 대화 기록 삭제

설정 및 점검

/config  # 설정 패널 열기
/doctor  # 설치 상태 점검

실습 예제:

$ claude
> /help
사용 가능한 명령어:
  /help - 도움말 표시
  /exit - Claude Code 종료
  /clear - 대화 기록 삭제
  ...

> /doctor
✓ 설치 상태: 정상
✓ API 연결: 성공
✓ 권한 설정: 정상

1.3 단일 명령 실행 (Print Mode)

# SDK 모드로 실행 후 종료
claude -p "이 함수를 설명해줘"

# 파이프로 콘텐츠 전달
cat logs.txt | claude -p "로그를 분석해줘"

실전 활용 예제:

# 에러 로그 분석
$ cat error.log | claude -p "이 에러의 원인을 찾아줘"

분석 결과:
1. NullPointerException 발생
2. 원인: user 객체가 null인 상태에서 메서드 호출
3. 해결방법: user != null 체크 추가 필요

# Git diff 설명
$ git diff | claude -p "이 변경사항을 요약해줘"

변경사항 요약:
- login() 함수에 에러 핸들링 추가
- 사용자 인증 로직 개선
- 테스트 케이스 3개 추가

1.4 대화 재개하기

# 최근 대화 이어가기
claude -c

# SDK 모드로 이어가기
claude -c -p "타입 에러를 체크해줘"

# 세션 ID로 재개
claude -r "abc123" "이 PR을 완성해줘"

실습 시나리오:

# Day 1: 프로젝트 분석 시작
$ claude "이 React 프로젝트를 분석해줘"
[세션 ID: xyz789로 저장됨]

# Day 2: 같은 세션으로 돌아가기
$ claude -r "xyz789" "상태 관리를 Redux로 변경해줘"
[이전 컨텍스트를 기억하며 작업 진행]

---

레벨 2: 중급 명령어 🟡

2.1 모델 선택 및 설정

다양한 모델 사용하기

# Sonnet 모델 사용 (빠르고 효율적)
claude --model sonnet

# Opus 모델 사용 (더 강력함)
claude --model opus

# 특정 버전 지정
claude --model claude-sonnet-4-20250514

모델별 특징:

• Sonnet: 일상적인 코딩 작업에 최적, 빠른 응답
• Opus: 복잡한 리팩토링이나 아키텍처 설계에 적합

실전 예제:

# 빠른 버그 수정에는 Sonnet
$ claude --model sonnet "이 버그를 고쳐줘"

# 복잡한 시스템 설계에는 Opus
$ claude --model opus "마이크로서비스 아키텍처를 설계해줘"

2.2 작업 디렉토리 추가

# 여러 디렉토리 접근 권한 부여
claude --add-dir ../apps ../lib

# 경로 유효성 검증
claude --add-dir /path/to/project

모노레포 프로젝트 예제:

# 모노레포 전체 분석
$ claude --add-dir ../frontend ../backend ../shared \
  "전체 프로젝트의 의존성을 분석해줘"

분석 결과:
- frontend → shared (types, utils 사용)
- backend → shared (models, validators 사용)
- 순환 참조 없음 ✓

2.3 출력 형식 지정

# JSON 형식으로 출력
claude -p "쿼리" --output-format json

# 텍스트 형식
claude -p "쿼리" --output-format text

# 스트리밍 JSON
claude -p "쿼리" --output-format stream-json

자동화 스크립트 예제:

# 코드 분석을 JSON으로 저장
$ claude -p "코드베이스를 분석해줘" --output-format json > analysis.json

# 결과 파싱
$ cat analysis.json | jq '.issues[] | select(.severity == "high")'
{
  "file": "src/auth.js",
  "line": 42,
  "issue": "SQL Injection 취약점",
  "severity": "high"
}

2.4 대화 턴 제한

# 대화 턴 수 제한 (빠른 응답용)
claude -p --max-turns 3 "쿼리"

성능 최적화 예제:

# 빠른 질문-응답
$ claude -p --max-turns 1 "이 함수의 시간 복잡도는?"
O(n²) - 중첩된 루프 때문입니다.

# 제한 없이 실행 (더 상세한 분석)
$ claude -p "이 함수를 최적화해줘"
[여러 턴에 걸쳐 상세한 최적화 진행]

2.5 세션 비용 확인

/cos  # 총 비용과 소요 시간 표시

비용 관리 예제:

> /cos
세션 정보:
- 소요 시간: 15분 32초
- 총 토큰: 45,231
- 예상 비용: $0.23
- 턴 수: 12

---

레벨 3: 고급 명령어 🟠

3.1 도구 권한 관리

허용된 도구 지정

# Git 명령어만 허용
claude --allowedTools "Bash(git log:*)" "Bash(git diff:*)" "Write"

# 특정 도구 차단
claude --disallowedTools "Bash(rm:*)" "Bash(sudo:*)"

보안 중심 작업 예제:

# 안전한 코드 리뷰 설정
$ claude --allowedTools "Read" "Write" \
         --disallowedTools "Bash(rm:*)" "Bash(sudo:*)" "Bash(chmod:*)" \
  "이 PR을 리뷰해줘"

[Claude는 파일 읽기/쓰기만 가능하고, 위험한 시스템 명령은 실행 불가]

3.2 도구 권한 프롬프트

# 특정 도구 사용 전 권한 요청
claude -p --permission-prompt-tool mcp_auth_tool "쿼리"

# 모든 권한 프롬프트 건너뛰기 (주의!)
claude --dangerously-skip-permissions

실전 시나리오:

$ claude "데이터베이스에 연결해줘"

⚠️  Claude가 다음 도구를 사용하려고 합니다:
   - Bash(mysql:*)
   
   허용하시겠습니까? [y/N]: y

[연결 진행...]

3.3 대화 압축 및 관리

# 대화 압축 (요약)
/compact [지시사항]

# 대화 기록 완전 삭제
/clear

긴 세션 관리 예제:

# 50턴 이상의 긴 대화 후
> /compact "중요한 결정사항과 코드 변경사항만 남겨줘"

압축 완료:
- 이전 턴: 52개
- 압축 후: 8개 (주요 내용만 유지)
- 절약된 토큰: ~35,000

# 새로운 작업 시작
> /clear
대화 기록이 삭제되었습니다. 새로 시작합니다.

3.4 복잡한 파이프 작업

# Git 로그 요약
git log --oneline | claude -p "이 커밋들을 요약해줘"

# 에러 로그 원인 분석
cat error.log | claude -p "근본 원인을 찾아줘"

# 디렉토리 구조 설명
ls -la | claude -p "이 디렉토리 구조를 설명해줘"

CI/CD 통합 예제:

#!/bin/bash
# 자동 PR 리뷰 스크립트

# 1. 변경사항 분석
git diff HEAD~1 | claude -p "보안 이슈를 검토해줘" > security_review.md

# 2. 성능 체크
git diff HEAD~1 | claude -p "성능 문제를 체크해줘" > performance_review.md

# 3. 개선사항 제안
git diff HEAD~1 | claude -p "개선사항을 제안해줘" > improvements.md

echo "PR 리뷰 완료!"

3.5 MCP (Model Context Protocol) 설정

# MCP 서버 구성
claude --mcp

# REPL에서 MCP 접근
/mcp

MCP 활용 예제:

> /mcp
사용 가능한 MCP 서버:
1. github-mcp (GitHub API 연동)
2. slack-mcp (Slack 연동)
3. database-mcp (DB 쿼리)

> 선택: 1
GitHub MCP 활성화됨

> "최근 이슈 5개를 가져와줘"
[GitHub API를 통해 이슈 조회]

---

레벨 4: 전문가 명령어 🔴

4.1 사용자 정의 명령어 생성

.claude/commands/ 디렉토리에 커스텀 명령어를 생성할 수 있습니다.

디버그 명령어 예제:

.claude/commands/debug.md 파일 생성:

# Debug Command

현재 코드의 디버깅을 수행합니다.

## 실행 순서
1. 최근 변경사항 확인
2. 에러 로그 분석
3. 잠재적 버그 식별
4. 수정 방안 제시

사용법:

$ claude
> /debug

[커스텀 디버그 워크플로우 실행]
1. Git diff 분석 중...
2. 에러 로그 3개 발견
3. 버그 2개 식별:
   - auth.js:42 - null 체크 누락
   - api.js:128 - 비동기 처리 오류
4. 수정 방안 제시 중...

테스트 명령어 예제:

.claude/commands/test.md:

# Test Command

포괄적인 테스트를 생성하고 실행합니다.

## 작업 내용
1. 기존 테스트 분석
2. 커버리지 부족 영역 식별
3. 새 테스트 케이스 생성
4. 엣지 케이스 확인

> /test

테스트 분석 시작...
- 현재 커버리지: 67%
- 미테스트 함수: 12개
- 생성할 테스트: 24개

테스트 케이스 생성 중...
✓ login.test.js 생성
✓ auth.test.js 생성
...

4.2 고급 도구 권한 설정

# 복합 권한 설정
claude --allowedTools "Bash(git:*)" "Write" "Read" \
       --disallowedTools "Bash(rm:*)" "Bash(sudo:*)"

팀 협업 설정 예제:

# 주니어 개발자용 안전 설정
$ claude --allowedTools "Read" "Write" "Bash(git log:*)" \
         --disallowedTools "Bash(rm:*)" "Bash(git push:*)" \
  "코드를 리뷰하고 개선해줘"

# 시니어 개발자용 전체 권한
$ claude --allowedTools "*" \
  "데이터베이스 마이그레이션을 실행해줘"

4.3 다중 디렉토리 접근

# 모노레포 전체 접근
claude --add-dir ../frontend ../backend ../shared

마이크로서비스 분석 예제:

$ claude --add-dir ../user-service ../order-service ../payment-service \
  "모든 서비스의 API 엔드포인트를 문서화해줘"

분석 중...
1. user-service
   - POST /api/users/register
   - GET /api/users/:id
   - PUT /api/users/:id

2. order-service
   - POST /api/orders
   - GET /api/orders/:id
   - PUT /api/orders/:id/status

3. payment-service
   - POST /api/payments/process
   - GET /api/payments/:id
   
[전체 API 문서 생성 완료]

4.4 컨텍스트 최적화

# 제한된 컨텍스트로 성능 향상
claude -p --max-turns 5 "집중된 쿼리"

# 작업 간 컨텍스트 삭제
/clear

# 중요한 부분만 유지
/compact "핵심 내용만 남겨줘"

대규모 프로젝트 최적화:

# 초기 분석
$ claude "전체 프로젝트 구조를 분석해줘"
[50,000 토큰 사용]

# 컨텍스트 압축
> /compact "프로젝트 구조와 주요 패턴만 유지"
[15,000 토큰으로 압축]

# 특정 작업에 집중
$ claude -p --max-turns 3 "login 함수만 리팩토링해줘"
[효율적인 토큰 사용]

---

레벨 5: 파워 유저 명령어 🔵

5.1 복합 설정 실행

# 모든 옵션을 조합한 실행
claude --model claude-sonnet-4-20250514 \
       --add-dir ../apps ../lib ../tools \
       --allowedTools "Bash(git:*)" "Write" "Read" \
       --verbose \
       --output-format json

프로덕션 분석 워크플로우:

$ claude --model opus \
         --add-dir ../src ../tests ../config \
         --allowedTools "Read" "Bash(git:*)" \
         --disallowedTools "Bash(rm:*)" "Write" \
         --verbose \
         --output-format json \
  "프로덕션 배포 전 최종 검증" > deploy-check.json

[상세 로그 출력]
✓ 의존성 체크 완료
✓ 보안 스캔 완료
✓ 성능 테스트 완료
✓ 배포 준비 완료

$ cat deploy-check.json | jq '.status'
"ready_for_deployment"

5.2 자동화 스크립트

멀티 스텝 분석 스크립트:

analyze-project.sh:

#!/bin/bash

echo "프로젝트 분석 시작..."

# 1단계: 구조 분석
echo "1. 프로젝트 구조 분석..."
claude -p "프로젝트 구조를 분석해줘" --output-format json > structure.json

# 2단계: 코드 품질 체크
echo "2. 코드 품질 체크..."
claude -p "코드 품질을 평가해줘" --output-format json > quality.json

# 3단계: 보안 스캔
echo "3. 보안 스캔..."
claude -p "보안 취약점을 찾아줘" --output-format json > security.json

# 4단계: 종합 리포트 생성
echo "4. 종합 리포트 생성..."
claude -p "위 분석 결과들을 종합해서 리포트를 만들어줘" \
       --output-format text > final-report.md

echo "✓ 분석 완료! final-report.md를 확인하세요."

실행:

$ chmod +x analyze-project.sh
$ ./analyze-project.sh

프로젝트 분석 시작...
1. 프로젝트 구조 분석...
2. 코드 품질 체크...
3. 보안 스캔...
4. 종합 리포트 생성...
✓ 분석 완료! final-report.md를 확인하세요.

5.3 세션 ID 관리

# 세션 저장 및 재개
SESSION_ID=$(claude -p "분석 시작" --output-format json | jq -r '.session_id')
claude -r "$SESSION_ID" "분석 계속"

장기 프로젝트 관리:

#!/bin/bash
# long-term-project.sh

# 프로젝트 초기 설정
SESSION_ID=$(claude "새로운 React 프로젝트를 시작하자" \
             --output-format json | jq -r '.session_id')

echo "Session ID: $SESSION_ID" > .claude-session
echo "세션 저장됨. 나중에 계속할 수 있습니다."

# 다음날 작업 재개
SESSION_ID=$(cat .claude-session | cut -d' ' -f3)
claude -r "$SESSION_ID" "상태 관리를 추가하자"

5.4 파이프라인 자동화

# 멀티 스텝 파이프라인
claude -p "프로젝트 구조 분석" | \
claude -p "개선사항 제안" | \
claude -p "구현 계획 작성"

CI/CD 통합 예제:

.github/workflows/claude-review.yml:

name: Claude Code Review

on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
      
      - name: Security Review
        run: |
          git diff HEAD~1 | \
          claude -p "보안 이슈를 체크해줘" \
          --output-format text > security-review.txt
      
      - name: Performance Review
        run: |
          git diff HEAD~1 | \
          claude -p "성능 문제를 체크해줘" \
          --output-format text > performance-review.txt
      
      - name: Upload Reviews
        uses: actions/upload-artifact@v2
        with:
          name: reviews
          path: |
            security-review.txt
            performance-review.txt

5.5 파일 배치 처리

# 모든 JavaScript 파일 분석
find . -name "*.js" -exec claude -p "이 파일의 버그를 분석해줘: {}" \; > bug-report.txt

# Python 파일 문서화
for file in src/*.py; do
  claude -p "이 파일에 docstring을 생성해줘: $file" --output-format text >> docs.md
done

대규모 리팩토링 예제:

#!/bin/bash
# refactor-all.sh

echo "대규모 리팩토링 시작..."

# 1. 모든 컴포넌트 파일 찾기
COMPONENTS=$(find src/components -name "*.jsx")

# 2. 각 컴포넌트 리팩토링
for component in $COMPONENTS; do
  echo "처리 중: $component"
  
  claude -p "이 컴포넌트를 함수형으로 리팩토링해줘: $component" \
         --output-format text > "${component}.new"
  
  # 백업 생성
  cp "$component" "${component}.backup"
  
  # 새 버전으로 교체
  mv "${component}.new" "$component"
done

echo "✓ 리팩토링 완료!"
echo "백업 파일: *.backup"

---

레벨 6: 마스터 명령어 🟣

6.1 IDE 통합

# VS Code 통합 설정
/ide vscode

# IDE 설정
/ide configure

# IDE 모드 명령
claude --ide-mode "선택된 코드를 설명해줘"
claude --ide-mode "이 함수를 리팩토링해줘"

VS Code 워크플로우 예제:

# .vscode/tasks.json
{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Claude: Explain Code",
      "type": "shell",
      "command": "claude --ide-mode 'explain selected code'"
    },
    {
      "label": "Claude: Refactor",
      "type": "shell",
      "command": "claude --ide-mode 'refactor this function'"
    },
    {
      "label": "Claude: Add Tests",
      "type": "shell",
      "command": "claude --ide-mode 'generate tests for this code'"
    }
  ]
}

6.2 Git Hooks 통합

Pre-commit Hook:

.git/hooks/pre-commit:

#!/bin/bash

echo "Claude Code로 커밋 검증 중..."

# 변경사항 분석
CHANGES=$(git diff --cached)

# Claude로 검증
RESULT=$(echo "$CHANGES" | claude -p "이 변경사항에 문제가 있나요? 있으면 'FAIL:', 없으면 'PASS'로 시작해서 답변해줘" --output-format text)

if echo "$RESULT" | grep -q "^FAIL"; then
  echo "❌ 커밋 거부됨:"
  echo "$RESULT"
  exit 1
else
  echo "✓ 검증 통과"
  echo "$RESULT"
  exit 0
fi

실행 예제:

$ git commit -m "Add login feature"

Claude Code로 커밋 검증 중...
✓ 검증 통과
PASS: 변경사항이 좋습니다.
- 적절한 에러 핸들링
- 보안 검증 포함
- 테스트 코드 존재

[main abc1234] Add login feature
 3 files changed, 145 insertions(+)

6.3 고급 Git 작업

# 커밋 로그로 변경 로그 생성
git log --oneline -10 | claude -p "이 커밋들로 변경 로그를 만들어줘"

# 변경 파일 설명
git diff --name-only | claude -p "이 커밋에서 무엇이 바뀌었는지 설명해줘"

릴리즈 노트 자동 생성:

#!/bin/bash
# generate-release-notes.sh

VERSION=$1

if [ -z "$VERSION" ]; then
  echo "사용법: $0 <version>"
  exit 1
fi

echo "릴리즈 노트 생성 중: v$VERSION"

# 이전 태그부터 현재까지의 커밋
COMMITS=$(git log $(git describe --tags --abbrev=0)..HEAD --oneline)

# Claude로 릴리즈 노트 생성
echo "$COMMITS" | claude -p "이 커밋들을 기반으로 릴리즈 노트를 작성해줘. 버전: v$VERSION" \
  --output-format text > RELEASE_NOTES_$VERSION.md

echo "✓ 생성 완료: RELEASE_NOTES_$VERSION.md"

$ ./generate-release-notes.sh 2.1.0

릴리즈 노트 생성 중: v2.1.0
✓ 생성 완료: RELEASE_NOTES_2.1.0.md

$ cat RELEASE_NOTES_2.1.0.md

# Release v2.1.0

## 새로운 기능
- 사용자 인증 시스템 개선
- 실시간 알림 기능 추가
- 다크 모드 지원

## 버그 수정
- 로그인 페이지 성능 개선
- 메모리 누수 문제 해결

## 기술 부채
- 레거시 코드 리팩토링
- 테스트 커버리지 85%로 향상

6.4 데이터베이스 통합

# 데이터베이스 구조 분석
mysql -e "SHOW TABLES" | claude -p "데이터베이스 구조를 분석해줘"

# 쿼리 최적화
mysql -e "EXPLAIN SELECT * FROM users WHERE email LIKE '%@gmail.com'" | \
  claude -p "이 쿼리를 최적화해줘"

DB 마이그레이션 검증:

#!/bin/bash
# validate-migration.sh

MIGRATION_FILE=$1

echo "마이그레이션 검증 중: $MIGRATION_FILE"

# 마이그레이션 SQL 분석
claude -p "이 SQL 마이그레이션을 검토해줘: $(cat $MIGRATION_FILE)" \
       --output-format text > migration-review.txt

echo "✓ 검토 완료: migration-review.txt"

# 위험 요소 확인
if grep -qi "DROP\|DELETE\|TRUNCATE" $MIGRATION_FILE; then
  echo "⚠️  경고: 데이터 손실 가능성이 있는 작업 포함"
  echo "계속하시겠습니까? [y/N]"
  read -r response
  if [[ ! "$response" =~ ^[Yy]$ ]]; then
    echo "취소됨"
    exit 1
  fi
fi

echo "✓ 마이그레이션 안전 확인"

6.5 Docker 통합

# 실행 중인 컨테이너 분석
docker ps | claude -p "실행 중인 컨테이너를 분석해줘"

# 로그 에러 찾기
docker logs container_name | claude -p "로그에서 에러를 찾아줘"

컨테이너 최적화 예제:

#!/bin/bash
# optimize-dockerfile.sh

DOCKERFILE=$1

echo "Dockerfile 최적화 중..."

# Claude로 분석 및 최적화
claude -p "이 Dockerfile을 최적화해줘: $(cat $DOCKERFILE)" \
       --output-format text > Dockerfile.optimized

echo "✓ 최적화 완료"
echo ""
echo "원본 크기:"
docker build -f $DOCKERFILE -t original . 2>&1 | grep "Size"

echo ""
echo "최적화 후 크기:"
docker build -f Dockerfile.optimized -t optimized . 2>&1 | grep "Size"

echo ""
echo "개선사항을 Dockerfile.optimized에서 확인하세요."

6.6 프로덕션 환경 설정

# 프로덕션 모드
claude --production-mode \
       --security-enabled \
       --audit-logging \
       --max-turns 10 \
       "프로덕션 분석"

보안 중심 코드 리뷰:

# secure-review.sh
#!/bin/bash

echo "보안 코드 리뷰 시작..."

claude --disallowedTools "Bash(rm:*)" "Bash(sudo:*)" "Bash(chmod:*)" \
       --audit-mode \
       --no-external-calls \
       --audit-log /var/log/claude-audit.log \
       "이 PR의 보안을 검토해줘" > security-audit.md

# 감사 로그 확인
echo ""
echo "감사 로그:"
tail -n 20 /var/log/claude-audit.log

echo ""
echo "✓ 보안 리뷰 완료: security-audit.md"

6.7 성능 최적화 및 모니터링

# 메모리 사용 최적화
claude -p --max-turns 1 "빠른 분석"

# 캐싱 활용
claude --cache-results "반복적인 작업"

# 병렬 처리
claude -p "작업 1" & claude -p "작업 2" & wait

대규모 코드베이스 효율적 처리:

#!/bin/bash
# efficient-large-project.sh

echo "대규모 프로젝트 분석 (최적화 모드)"

# 1단계: 스트림 출력으로 초기 분석
echo "1. 초기 스캔..."
claude --add-dir . --max-context 50000 \
       --stream-output "프로젝트 전체 스캔" | head -100 > initial-scan.txt

# 2단계: 컨텍스트 압축
echo "2. 컨텍스트 최적화..."
SESSION_ID=$(cat initial-scan.txt | grep "Session:" | cut -d: -f2)
claude -r "$SESSION_ID" "/compact '핵심 정보만 유지'"

# 3단계: 타겟팅된 분석
echo "3. 상세 분석..."
claude -r "$SESSION_ID" --max-turns 5 "중요한 파일들만 상세 분석"

# 4단계: 비용 확인
echo "4. 비용 확인..."
claude -r "$SESSION_ID" "/cos"

echo "✓ 분석 완료"

6.8 팀 협업 설정

공유 팀 설정:

team-config.json:

{
  "model": "claude-sonnet-4-20250514",
  "allowedTools": [
    "Read",
    "Write",
    "Bash(git:*)",
    "Bash(npm:*)",
    "Bash(yarn:*)"
  ],
  "disallowedTools": [
    "Bash(rm:*)",
    "Bash(sudo:*)",
    "Bash(chmod:*)"
  ],
  "maxTurns": 10,
  "outputFormat": "text"
}

사용:

# 팀 설정으로 실행
$ claude --config-file team-config.json "표준화된 코드 리뷰"

# 팀 세션 공유
$ claude -r "team-session-id" "팀 토론 계속"

6.9 컴플라이언스 및 감사

# 컴플라이언스 체크
claude --audit-log /var/log/claude-audit.log "컴플라이언스 체크"

# 컴플라이언스 모드
claude --compliance-mode "보안 컴플라이언스를 분석해줘"

GDPR 컴플라이언스 체크:

#!/bin/bash
# gdpr-check.sh

echo "GDPR 컴플라이언스 체크..."

claude --compliance-mode \
       --audit-log /var/log/gdpr-audit.log \
       "이 코드베이스에서 GDPR 위반 가능성을 찾아줘:
       - 개인정보 암호화
       - 데이터 보관 기간
       - 사용자 동의
       - 데이터 삭제 권한" > gdpr-report.md

echo "✓ GDPR 리포트 생성: gdpr-report.md"
echo "✓ 감사 로그: /var/log/gdpr-audit.log"

---

실전 활용 시나리오

시나리오 1: 새 프로젝트 빠른 시작

#!/bin/bash
# quick-start-project.sh

PROJECT_NAME=$1

echo "새 프로젝트 생성: $PROJECT_NAME"

# 1. 프로젝트 초기화
claude "Next.js 14 프로젝트를 생성하고 다음 설정으로 구성해줘:
- TypeScript
- Tailwind CSS
- ESLint + Prettier
- 프로젝트명: $PROJECT_NAME" > setup-log.txt

# 2. Git 초기화
cd $PROJECT_NAME
git init
git add .
git commit -m "Initial commit"

# 3. README 생성
claude -p "이 프로젝트를 위한 README.md를 작성해줘" > README.md

# 4. 개발 환경 설정 문서
claude -p "개발 환경 설정 가이드를 작성해줘" > SETUP.md

echo "✓ 프로젝트 생성 완료!"

시나리오 2: 레거시 코드 현대화

#!/bin/bash
# modernize-legacy.sh

echo "레거시 코드 현대화 프로젝트"

# 1. 현재 상태 분석
echo "1. 코드베이스 분석 중..."
claude "이 레거시 프로젝트를 분석해줘:
- 사용 기술 스택
- 코드 품질
- 기술 부채
- 개선 우선순위" > analysis.md

# 2. 마이그레이션 계획
echo "2. 마이그레이션 계획 수립..."
claude "분석을 바탕으로 현대화 로드맵을 만들어줘:
- 단계별 계획
- 리스크 평가
- 예상 소요 시간" > roadmap.md

# 3. 의존성 업데이트
echo "3. 의존성 분석..."
claude -p "package.json을 분석하고 안전하게 업데이트할 수 있는 패키지 목록을 제공해줘" \
       > dependency-update.md

# 4. 테스트 전략
echo "4. 테스트 전략 수립..."
claude "현대화 과정의 테스트 전략을 만들어줘:
- 회귀 테스트
- 통합 테스트
- E2E 테스트" > test-strategy.md

echo "✓ 현대화 계획 완료!"
echo "생성된 문서:"
echo "  - analysis.md"
echo "  - roadmap.md"
echo "  - dependency-update.md"
echo "  - test-strategy.md"

시나리오 3: 버그 헌팅 및 수정

#!/bin/bash
# bug-hunting.sh

echo "버그 헌팅 시작..."

# 1. 에러 로그 수집
echo "1. 에러 로그 분석..."
tail -n 1000 /var/log/app.log | \
  claude -p "이 로그에서 패턴을 분석하고 주요 버그를 찾아줘" \
  > bug-patterns.md

# 2. 코드 정적 분석
echo "2. 코드 정적 분석..."
find src -name "*.js" | head -20 | while read file; do
  echo "분석 중: $file"
  claude -p "이 파일에서 잠재적 버그를 찾아줘: $(cat $file)" \
    >> potential-bugs.md
done

# 3. 테스트 실패 분석
echo "3. 테스트 실패 분석..."
npm test 2>&1 | claude -p "테스트 실패 원인을 분석해줘" \
  > test-failures.md

# 4. 수정 계획 생성
echo "4. 수정 계획 수립..."
claude "발견된 버그들의 수정 계획을 만들어줘:
$(cat bug-patterns.md potential-bugs.md test-failures.md)" \
  > fix-plan.md

echo "✓ 버그 헌팅 완료!"
echo "결과:"
echo "  - bug-patterns.md"
echo "  - potential-bugs.md"
echo "  - test-failures.md"
echo "  - fix-plan.md"

시나리오 4: 성능 최적화

#!/bin/bash
# performance-optimization.sh

echo "성능 최적화 프로젝트"

# 1. 번들 크기 분석
echo "1. 번들 크기 분석..."
npm run build
claude -p "빌드 결과를 분석하고 번들 크기를 줄일 방법을 제안해줘:
$(cat build/stats.json)" > bundle-optimization.md

# 2. 런타임 성능 분석
echo "2. 런타임 성능 프로파일링..."
claude "다음 컴포넌트들의 렌더링 성능을 최적화해줘:
- 불필요한 리렌더링 방지
- 메모이제이션 적용
- lazy loading 구현" > runtime-optimization.md

# 3. 네트워크 최적화
echo "3. 네트워크 요청 최적화..."
claude -p "API 호출 패턴을 분석하고 최적화 방안을 제시해줘" \
  > network-optimization.md

# 4. 데이터베이스 쿼리 최적화
echo "4. 데이터베이스 쿼리 최적화..."
mysql slow-query.log | \
  claude -p "느린 쿼리들을 분석하고 최적화해줘" \
  > db-optimization.md

echo "✓ 성능 최적화 분석 완료!"

---

문제 해결 가이드

설치 문제

# 설치 상태 확인
claude --version
claude /doctor

# 재설치
npm uninstall -g @anthropic-ai/claude-code
npm install -g @anthropic-ai/claude-code

성능 문제

# 컨텍스트 정리
/clear

# 컨텍스트 크기 제한
claude -p --max-turns 3 "집중된 쿼리"

# 압축 모드 사용
/compact "핵심만 유지"

권한 문제

# 현재 권한 확인
claude --list-permissions

# 권한 초기화
claude --reset-permissions

# 특정 권한 설정
claude --allowedTools "Bash(git:*)" \
       --disallowedTools "Bash(rm:*)"

---

베스트 프랙티스

1. 보안

✅ 좋은 예:

# 안전한 도구만 허용
claude --allowedTools "Read" "Write" "Bash(git:*)" \
       --disallowedTools "Bash(rm:*)" "Bash(sudo:*)"

❌ 나쁜 예:

# 모든 권한 건너뛰기 (위험!)
claude --dangerously-skip-permissions

2. 성능

✅ 좋은 예:

# 작업 간 컨텍스트 정리
/clear

# 필요한 만큼만 턴 사용
claude -p --max-turns 3 "빠른 분석"

❌ 나쁜 예:

# 무한정 대화 이어가기 (토큰 낭비)
claude -c "또 다른 질문..."

3. 자동화

✅ 좋은 예:

# JSON 출력으로 파싱 가능하게
claude -p "분석" --output-format json | jq '.results'

❌ 나쁜 예:

# 텍스트 출력을 파싱하려고 시도
claude -p "분석" | grep "result"

4. 팀 협업

✅ 좋은 예:

# 표준화된 설정 사용
claude --config-file team-config.json

# 세션 공유
claude -r "team-session-id" "토론 계속"

❌ 나쁜 예:

# 각자 다른 설정 사용
claude --model sonnet  # A 개발자
claude --model opus    # B 개발자

---

주요 팁 정리

초보자를 위한 팁

1. 단계별 학습: 레벨 1부터 차근차근 시작
2. 도움말 활용: /help 자주 사용
3. 간단한 질문: 복잡한 요청 전에 단순한 작업으로 연습
4. 컨텍스트 관리: 작업 간 /clear 사용

중급자를 위한 팁

1. 도구 권한 마스터: 보안을 위한 권한 설정
2. JSON 출력 활용: 자동화 스크립트에 통합
3. MCP 학습: 고급 통합 기능 익히기
4. 커스텀 명령어: 반복 작업 자동화

고급 사용자를 위한 팁

1. 엔터프라이즈 기능: 팀 협업 및 감사 로깅
2. 성능 최적화: 리소스 사용 모니터링
3. CI/CD 통합: 파이프라인에 Claude 통합
4. 보안 Best Practice: 프로덕션 환경 설정

---

빠른 참조 카드

자주 사용하는 명령어

# 기본
claude                          # REPL 시작
claude -p "쿼리"                 # 실행 후 종료
claude -c                       # 대화 계속

# 설정
claude --model sonnet           # 모델 선택
claude --add-dir ../other       # 디렉토리 추가
claude --output-format json     # JSON 출력

# REPL 명령
/help                           # 도움말
/clear                          # 컨텍스트 삭제
/compact                        # 압축
/cos                            # 비용 확인
/exit                           # 종료

단축키

Ctrl+C    취소
Ctrl+D    종료
Tab       자동완성
↑/↓       명령 기록

---

추가 리소스

• 공식 Claude Code 문서
• Claude Code GitHub
• Anthropic API 문서
• MCP 문서

---

마무리

Claude Code는 강력한 AI 코딩 어시스턴트로, 올바르게 사용하면 개발 생산성을 크게 향상시킬 수 있습니다. 이 가이드를 따라 단계적으로 학습하면 초보자도 빠르게 전문가 수준으로 성장할 수 있습니다.

기억하세요:

• 보안을 항상 최우선으로
• 작업 간 컨텍스트 관리
• 자동화로 반복 작업 제거
• 팀과 베스트 프랙티스 공유

행운을 빕니다! 🚀

 

CodeDeck - 개발자를 위한 코드 학습 카드 뉴스