[이제와서 시작하는 Claude AI 마스터하기 #16] 팀 협업과 보안 거버넌스

AI와 함께 일하는 팀은 어떻게 다를까요? 팀 설정 공유, 보안 거버넌스, 코드 리뷰 프로세스까지 - AI 시대의 개발 문화를 함께 만들어봅시다.

완독 시간: 30분

이번에 배울 것

• AI as Mediator: 새로운 역할 정의
• 팀을 위한 설정 관리
• 보안 거버넌스
• AI 시대의 코드 리뷰
• 팀 베스트 프랙티스
• 팀 협업 플랫폼 구축
• AI와 개발자의 역할 분담
• Human-AI Symbiosis

---

The New Role: AI as a “Mediator” (중재자)

지금까지의 코드 리뷰는 “선배가 후배를 가르치는 시간”이거나 “동료 간의 자존심 싸움”이 되기 쉬웠습니다. Claude Code가 도입된 팀에서는 이 역학 관계가 바뀝니다.

AI-First Code Review Process

1. Before PR: 개발자는 반드시 Claude에게 1차 리뷰를 받습니다. (claude review .)
   • Lint, Type Error, 보안 취약점은 여기서 100% 걸러집니다.
2. During PR: 인간 리뷰어는 오직 “설계의 의도”와 “비즈니스 임팩트”만 봅니다.
   • “여기 변수명 왜 이래요?” 같은 소모적인 댓글이 사라집니다.
3. Conflict: 의견 대립 시 Claude를 중재자로 활용합니다.
   • “A안(상속)과 B안(조합) 중 장단점을 분석해서 리포트해줘.” -> 감정 없는 객관적 데이터로 합의.

---

팀을 위한 설정 관리

설정 스코프 이해하기

Claude Code는 계층적 설정 시스템을 사용합니다:

flowchart TD
    A[Managed<br>IT 관리자 배포] --> B[User<br>개인 전역 설정]
    B --> C[Project<br>팀 공유 설정]
    C --> D[Local<br>개인 로컬 설정]

    style A fill:#ff6b6b
    style B fill:#4ecdc4
    style C fill:#45b7d1
    style D fill:#96ceb4

스코프	위치	적용 대상	팀 공유?
Managed	시스템 레벨	머신의 모든 사용자	IT 배포
User	~/.claude/	나, 모든 프로젝트	X
Project	.claude/	이 저장소 모든 협업자	Git 커밋
Local	.claude/*.local.*	나, 이 저장소만	X

우선순위 규칙

Managed > Command line > Local > Project > User

높은 우선순위가 낮은 것을 덮어씁니다.

팀 공유 설정 예제

.claude/settings.json (Git에 커밋):

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)",
      "Bash(git diff *)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(curl *)"
    ]
  },
  "companyAnnouncements": [
    "코드 가이드라인: docs.company.com 참조",
    "모든 PR에는 테스트가 필요합니다"
  ]
}

개인 로컬 설정 예제

.claude/settings.local.json (Git 무시됨):

{
  "permissions": {
    "allow": [
      "Bash(npm run dev)"
    ]
  },
  "env": {
    "DEBUG": "true"
  }
}

---

보안 거버넌스

Managed Settings (기업용)

IT 관리자가 조직 전체 정책을 배포할 수 있습니다.

배포 위치:

• macOS: /Library/Application Support/ClaudeCode/managed-settings.json
• Linux/WSL: /etc/claude-code/managed-settings.json
• Windows: C:\Program Files\ClaudeCode\managed-settings.json

{
  "permissions": {
    "allow": ["Bash(npm run *)"],
    "deny": ["Bash(curl *)", "Read(./.env)"]
  },
  "allowManagedHooksOnly": true,
  "allowManagedPermissionRulesOnly": true,
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverUrl": "https://mcp.company.com/*" }
  ],
  "disableBypassPermissionsMode": true
}

주요 보안 설정

설정	설명
allowManagedHooksOnly	관리자 Hook만 허용
allowManagedPermissionRulesOnly	관리자 권한 규칙만 적용
disableBypassPermissionsMode	--dangerously-skip-permissions 비활성화
allowedMcpServers	허용된 MCP 서버만 사용 가능
deniedMcpServers	특정 MCP 서버 차단

보안 등급별 가이드라인

기업 환경에서 AI 도입의 가장 큰 장벽은 보안입니다. 리더는 명확한 가이드라인을 세워야 합니다.

1급: 절대 유출 불가 (Red Zone)

• User Personal Info (개인정보)
• AWS Secret Keys, DB Passwords
• –> Solution: .claudeignore에 해당 파일 경로 등록 + .env 파일 접근 차단.

2급: 제한적 허용 (Yellow Zone)

• 비즈니스 로직 코드, 사내 API 스펙
• –> Solution: Enterprise Plan 사용 (학습 데이터로 사용되지 않음 보장).

3급: 적극 활용 (Green Zone)

• UI 컴포넌트, 유틸리티 함수, 테스트 코드
• –> Solution: 오픈소스 라이브러리 수준으로 적극적으로 AI에게 맡김.

권한 관리 베스트 프랙티스

팀 공유 권한 (.claude/settings.json):

{
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)",
      "Bash(npm run build)",
      "Bash(git status)",
      "Bash(git diff *)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Read(./**/credentials*)",
      "Bash(curl *)",
      "Bash(wget *)",
      "Bash(rm -rf *)"
    ]
  }
}

민감한 파일 보호

{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.local)",
      "Read(./.env.production)",
      "Read(./secrets/**)",
      "Read(./**/api-keys*)",
      "Read(./**/credentials*)",
      "Write(./.github/workflows/*)"
    ]
  }
}

---

AI 시대의 코드 리뷰

Claude와 인간의 역할 분담

flowchart LR
    A[PR 생성] --> B[Claude 자동 리뷰]
    B --> C[스타일/버그 체크]
    B --> D[보안 취약점 검사]
    B --> E[테스트 커버리지]

    C --> F[인간 리뷰어]
    D --> F
    E --> F

    F --> G[비즈니스 로직 검토]
    F --> H[아키텍처 결정]
    F --> I[최종 승인]

Claude가 잘하는 리뷰

영역	Claude의 역할
코드 스타일	일관성 체크, 포맷팅
버그 탐지	잠재적 버그, edge case
보안	일반적인 취약점, OWASP
성능	명백한 비효율성
테스트	커버리지, 누락된 케이스
문서화	주석, JSDoc 완성도

인간이 잘하는 리뷰

영역	인간의 역할
비즈니스 로직	요구사항 충족 여부
아키텍처	장기적 설계 결정
팀 컨벤션	암묵적 규칙
도메인 지식	산업 특화 로직
UX/UI	사용자 경험 판단
전략적 결정	기술 부채 수용 여부

GitHub Actions로 자동 리뷰 설정

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: $
          prompt: |
            이 PR을 리뷰해주세요:
            1. 보안 취약점
            2. 성능 문제
            3. 테스트 커버리지
            4. 코드 스타일

            CLAUDE.md의 가이드라인을 따라주세요.
          claude_args: "--max-turns 5"

---

팀 베스트 프랙티스

1. CLAUDE.md 표준화

CLAUDE.md는 AI와 팀원 모두의 기준점입니다. 새로운 팀원이 올 때마다 “저희 컨벤션은요…“라고 말으로 설명할 필요가 없어집니다. 이 파일 하나가 수십 장의 위키 문서보다 강력합니다.

팀 전체가 공유하는 CLAUDE.md:

# 팀 개발 가이드

## 코드 스타일
- TypeScript 사용
- ESLint + Prettier 적용
- 함수명은 camelCase

## 커밋 메시지
- Conventional Commits 사용
- 한글로 작성
- 예: `feat: 로그인 기능 추가`

## PR 규칙
- 제목 50자 이내
- 본문에 변경 이유 포함
- 최소 1명 승인 필요

## 테스트
- 새 기능은 테스트 필수
- 커버리지 80% 이상 유지

## 금지 사항
- .env 파일 커밋 금지
- console.log 프로덕션 코드에 금지
- any 타입 사용 최소화

2. 공유 Skills 만들기

.claude/skills/team-review/SKILL.md:

# Team Review Skill

## 설명
팀 코드 리뷰 체크리스트를 적용합니다.

## 프롬프트
다음 체크리스트로 코드를 검토해주세요:

### 보안
- [ ] SQL 인젝션 취약점 없음
- [ ] XSS 취약점 없음
- [ ] 민감정보 하드코딩 없음

### 성능
- [ ] N+1 쿼리 없음
- [ ] 불필요한 리렌더링 없음

### 품질
- [ ] 테스트 작성됨
- [ ] 타입 정의 완료
- [ ] 에러 핸들링 적절함

3. MCP 서버 통합 관리

.mcp.json (팀 공유):

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "jira": {
      "type": "http",
      "url": "${JIRA_MCP_URL}",
      "headers": {
        "Authorization": "Bearer ${JIRA_TOKEN}"
      }
    }
  }
}

4. Hooks로 품질 게이트 설정

.claude/settings.json:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint -- --fix ${file}"
          }
        ]
      }
    ]
  }
}

5. Plugins로 팀 도구 패키징 & 배포

Plugins는 Skills, Hooks, MCP 서버, 에이전트를 하나의 패키지로 묶어 팀에 배포할 수 있는 시스템입니다.

팀 Plugin 구조 예시:

our-team-plugin/
├── plugin.toml          # 플러그인 메타데이터
├── skills/
│   ├── review.md        # 팀 코드리뷰 스킬
│   └── deploy.md        # 배포 자동화 스킬
├── hooks/
│   └── quality-gate.sh  # 품질 게이트 스크립트
└── agents/
    └── reviewer.md      # 리뷰어 에이전트

plugin.toml:

[plugin]
name = "our-team-plugin"
version = "1.0.0"
description = "우리 팀 개발 표준 도구 모음"

[skills]
review = "skills/review.md"
deploy = "skills/deploy.md"

[hooks.PostToolUse]
matcher = "Edit|Write"
command = "hooks/quality-gate.sh"

팀원 설치:

# Git 저장소에서 플러그인 설치
claude plugin install github:our-org/our-team-plugin

# 설치된 플러그인의 스킬 사용
claude> /our-team-plugin:review   # 네임스페이스 형식
claude> /our-team-plugin:deploy

Plugins vs Skills vs Hooks 비교:

항목	Skills	Hooks	Plugins
범위	단일 프롬프트	이벤트 반응	통합 패키지
배포	파일 복사	settings.json	plugin install
구성요소	마크다운 1개	스크립트 1개	Skills + Hooks + MCP + Agents
팀 공유	수동	수동	Git 저장소로 자동화

---

팀 협업 플랫폼 구축

중앙화된 AI 허브

// 팀을 위한 Claude 협업 플랫폼
class TeamAIHub {
  private workspaces: Map<string, Workspace> = new Map();
  private permissions: PermissionManager;
  private usage: UsageTracker;
  private knowledge: KnowledgeBase;
  
  async createWorkspace(config: WorkspaceConfig): Promise<Workspace> {
    const workspace = new Workspace({
      id: generateId(),
      name: config.name,
      team: config.team,
      settings: {
        defaultModel: 'claude-opus-4-6',
        sharedPrompts: true,
        knowledgeSharing: true,
        usageLimit: config.plan.limits
      }
    });
    
    // 팀 지식 베이스 초기화
    await this.initializeKnowledgeBase(workspace);
    
    // 역할 기반 접근 제어 설정
    await this.setupPermissions(workspace, config.members);
    
    this.workspaces.set(workspace.id, workspace);
    return workspace;
  }
  
  // 공유 프롬프트 라이브러리
  async createSharedPrompt(
    workspaceId: string,
    prompt: PromptTemplate
  ): Promise<SharedPrompt> {
    const workspace = this.getWorkspace(workspaceId);
    
    // 프롬프트 최적화
    const optimized = await this.optimizePrompt(prompt);
    
    // 버전 관리
    const versioned = await this.versionControl.add(optimized);
    
    // 팀 라이브러리에 추가
    workspace.promptLibrary.add(versioned);
    
    // 사용 통계 추적
    this.usage.trackPromptCreation(workspaceId, versioned.id);
    
    return versioned;
  }
  
  // 협업 세션
  async startCollaborationSession(
    config: CollaborationConfig
  ): Promise<CollaborationSession> {
    const session = new CollaborationSession({
      participants: config.participants,
      objective: config.objective,
      timeLimit: config.timeLimit
    });
    
    // 실시간 동기화 설정
    session.on('userInput', async (input) => {
      await this.broadcastToParticipants(session, input);
    });
    
    // AI 어시스턴트 설정
    session.assistant = new CollaborativeAI({
      context: await this.gatherTeamContext(config.participants),
      objective: config.objective,
      facilitationStyle: config.style || 'balanced'
    });
    
    return session;
  }
}

역할 기반 AI 어시스턴트

// 팀 역할별 맞춤형 AI 어시스턴트
interface TeamRole {
  name: string;
  permissions: Permission[];
  prompts: PromptTemplate[];
  workflows: WorkflowAccess[];
}

class RoleBasedAssistant {
  private roles: Map<string, TeamRole> = new Map();
  
  constructor() {
    this.initializeDefaultRoles();
  }
  
  private initializeDefaultRoles() {
    // 개발자 역할
    this.roles.set('developer', {
      name: 'Developer',
      permissions: ['code.write', 'code.review', 'docs.read'],
      prompts: [
        {
          id: 'code-review',
          template: `Review this code for:
- Bugs and security issues
- Performance optimizations
- Best practices
- Test coverage`,
          category: 'development'
        },
        {
          id: 'debug-assistant',
          template: `Help debug this issue:
Error: 
Context: 
Stack trace: `,
          category: 'debugging'
        }
      ],
      workflows: ['code-review', 'bug-fix', 'refactoring']
    });
    
    // 프로덕트 매니저 역할
    this.roles.set('product-manager', {
      name: 'Product Manager',
      permissions: ['specs.write', 'analytics.read', 'roadmap.manage'],
      prompts: [
        {
          id: 'feature-spec',
          template: `Create a detailed feature specification:
Feature: 
User Story: 
Acceptance Criteria: `,
          category: 'planning'
        }
      ],
      workflows: ['feature-planning', 'user-research', 'roadmap-update']
    });
    
    // 디자이너 역할
    this.roles.set('designer', {
      name: 'Designer',
      permissions: ['design.create', 'feedback.give', 'prototype.build'],
      prompts: [
        {
          id: 'design-critique',
          template: `Provide design feedback on:
- Visual hierarchy
- User flow
- Accessibility
- Brand consistency`,
          category: 'review'
        }
      ],
      workflows: ['design-review', 'user-testing', 'style-guide']
    });
  }
  
  async getAssistantForUser(userId: string): Promise<PersonalizedAssistant> {
    const user = await this.getUserProfile(userId);
    const role = this.roles.get(user.role);
    
    return new PersonalizedAssistant({
      userId,
      role,
      preferences: user.preferences,
      history: await this.getUserHistory(userId),
      teamContext: await this.getTeamContext(user.teamId)
    });
  }
}

실시간 브레인스토밍 도구

// 실시간 브레인스토밍 도구
class AIBrainstormingTool {
  private sessions: Map<string, BrainstormSession> = new Map();
  private io: Server;
  
  async createSession(config: SessionConfig): Promise<BrainstormSession> {
    const session = new BrainstormSession({
      id: generateId(),
      topic: config.topic,
      participants: config.participants,
      duration: config.duration,
      rules: config.rules || this.getDefaultRules()
    });
    
    // AI 퍼실리테이터 설정
    session.facilitator = new AIFacilitator({
      style: config.facilitationStyle,
      techniques: ['mind-mapping', 'scamper', 'six-thinking-hats']
    });
    
    // 실시간 이벤트 처리
    this.setupRealtimeHandlers(session);
    
    this.sessions.set(session.id, session);
    return session;
  }
  
  private setupRealtimeHandlers(session: BrainstormSession) {
    const room = `session:${session.id}`;
    
    // 새 아이디어 제출
    this.io.on('idea:submit', async (data) => {
      const idea = await this.processIdea(data);
      
      // AI가 아이디어 확장
      const expanded = await session.facilitator.expandIdea(idea);
      
      // 모든 참가자에게 브로드캐스트
      this.io.to(room).emit('idea:new', {
        original: idea,
        expanded,
        author: data.userId,
        timestamp: new Date()
      });
      
      // 관련 아이디어 제안
      const related = await session.facilitator.findRelatedIdeas(idea);
      this.io.to(room).emit('ideas:related', related);
    });
    
    // 아이디어 클러스터링
    this.io.on('cluster:request', async () => {
      const clusters = await session.facilitator.clusterIdeas(session.ideas);
      this.io.to(room).emit('cluster:result', {
        clusters,
        visualization: this.generateClusterViz(clusters)
      });
    });
  }
}

---

지식 공유 시스템

팀 지식 베이스

// AI 강화 지식 관리 시스템
class TeamKnowledgeBase {
  private documents: DocumentStore;
  private graph: KnowledgeGraph;
  private search: SemanticSearch;
  
  async addKnowledge(
    content: string,
    metadata: KnowledgeMetadata
  ): Promise<KnowledgeItem> {
    // 내용 분석 및 구조화
    const structured = await this.structureContent(content);
    
    // 자동 태깅
    const tags = await this.generateTags(structured);
    
    // 관련 지식 연결
    const connections = await this.findConnections(structured);
    
    // 지식 그래프 업데이트
    const item = await this.graph.addNode({
      content: structured,
      metadata,
      tags,
      connections
    });
    
    // 팀 알림
    await this.notifyRelevantMembers(item);
    
    return item;
  }
  
  async queryKnowledge(
    query: string,
    context: QueryContext
  ): Promise<KnowledgeResponse> {
    // 의미 기반 검색
    const results = await this.search.semanticSearch(query);
    
    // 컨텍스트 필터링
    const filtered = this.filterByContext(results, context);
    
    // AI 답변 생성
    const answer = await this.generateAnswer(query, filtered);
    
    // 출처 표시
    const sources = this.extractSources(filtered);
    
    return {
      answer,
      sources,
      relatedTopics: await this.findRelatedTopics(query),
      experts: await this.findSubjectExperts(query)
    };
  }
}

스탠드업 미팅 도우미

// AI 기반 스탠드업 도우미
class StandupAssistant {
  async prepareStandup(teamId: string): Promise<StandupSummary> {
    const team = await this.getTeam(teamId);
    
    // 각 팀원의 활동 수집
    const activities = await Promise.all(
      team.members.map(member => this.collectMemberActivity(member))
    );
    
    // 주요 이슈 및 블로커 식별
    const issues = await this.identifyIssues(activities);
    
    // 팀 목표 대비 진행상황
    const progress = await this.assessProgress(team.sprint);
    
    // AI 생성 요약
    const summary = await this.generateStandupSummary({
      activities,
      issues,
      progress
    });
    
    return {
      summary,
      memberUpdates: activities,
      blockers: issues.blockers,
      risks: issues.risks,
      celebrations: this.findWins(activities),
      focusAreas: await this.suggestFocusAreas(team)
    };
  }
}

신규 팀원 온보딩

// 신규 팀원 온보딩 AI
class OnboardingAssistant {
  async createPersonalizedOnboarding(
    newMember: TeamMember
  ): Promise<OnboardingPlan> {
    // 역할 기반 커리큘럼
    const curriculum = await this.generateCurriculum(newMember.role);
    
    // 팀 문화 가이드
    const cultureGuide = await this.createCultureGuide(newMember.team);
    
    // 멘토 매칭
    const mentor = await this.matchMentor(newMember);
    
    // 30일 계획
    const plan = await this.create30DayPlan({
      member: newMember,
      curriculum,
      mentor
    });
    
    return {
      plan,
      resources: await this.gatherResources(newMember.role),
      checkpoints: this.defineCheckpoints(plan),
      buddy: mentor,
      slackChannels: await this.recommendChannels(newMember)
    };
  }
}

팀 건강도 모니터링

// 팀 웰빙 모니터
class TeamHealthMonitor {
  async assessTeamHealth(teamId: string): Promise<HealthReport> {
    const metrics = await this.collectMetrics(teamId);
    
    const analysis = await claude.createMessage({
      system: 'Analyze team health indicators and provide insights.',
      messages: [{
        role: 'user',
        content: JSON.stringify(metrics)
      }]
    });
    
    return {
      score: metrics.overall,
      areas: {
        collaboration: metrics.collaboration,
        productivity: metrics.productivity,
        satisfaction: metrics.satisfaction,
        growth: metrics.growth
      },
      recommendations: JSON.parse(analysis.content[0].text),
      trends: await this.analyzeTrends(teamId)
    };
  }
}

---

AI와 개발자의 역할 분담

AI의 강점 활용

pie title Claude가 시간을 절약해주는 영역
    "보일러플레이트 코드" : 30
    "테스트 작성" : 25
    "리팩토링" : 20
    "문서화" : 15
    "버그 수정" : 10

Claude에게 맡기면 좋은 작업:

• 반복적인 코드 작성
• 테스트 케이스 생성
• 코드 변환/마이그레이션
• 문서 업데이트
• 간단한 버그 수정

개발자가 집중해야 할 영역

인간이 더 잘하는 것:

• 요구사항 이해와 명확화
• 아키텍처 설계 결정
• 비즈니스 로직 검증
• 사용자 경험 판단
• 팀 커뮤니케이션
• 기술 부채 관리

효과적인 협업 패턴

1. 개발자: 요구사항 정의
   |
2. Claude: 초기 구현
   |
3. 개발자: 검토 및 피드백
   |
4. Claude: 수정 및 개선
   |
5. 개발자: 최종 검토 및 커밋

---

사용량 모니터링

OpenTelemetry 통합

Claude Code 사용량을 추적할 수 있습니다:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "https://your-collector.com"
  }
}

추적 가능한 메트릭

• 세션 수
• 토큰 사용량
• 도구 호출 빈도
• 오류율

팀 AI 활용 대시보드

interface TeamAIDashboard {
  usage: {
    activeUsers: number;
    promptsPerDay: number;
    averageResponseTime: number;
    mostUsedFeatures: Feature[];
  };
  
  impact: {
    timeSaved: number;
    tasksAutomated: number;
    qualityImprovement: number;
    knowledgeShared: number;
  };
  
  roi: {
    costSavings: number;
    productivityGain: number;
    innovationMetrics: Innovation[];
  };
}

---

보안 체크리스트

팀 온보딩 시

• CLAUDE.md 가이드라인 공유
• 권한 설정 설명
• 민감 파일 목록 공유
• MCP 서버 사용법 교육
• 팀 Plugin 설치 안내

정기 감사

• 권한 설정 검토 (/permissions)
• MCP 서버 목록 확인 (/mcp)
• CLAUDE.md 업데이트 여부
• 사용량 메트릭 분석

인시던트 대응

의심스러운 동작 발견 시:

1. /bug로 신고
2. 해당 세션 중단
3. 권한 설정 검토
4. 팀에 공유

---

Human-AI Symbiosis

우리는 이제 선택해야 합니다. AI를 “내 일자리를 위협하는 경쟁자”로 볼 것인가, 아니면 “나를 슈퍼 개발자로 만들어줄 파트너”로 볼 것인가.

정답은 명확합니다. 도구를 지배하는 자가 미래를 만듭니다.

Park Labs는 여러분이 단순 코더에서 아키텍트이자 디렉터로 성장하는 여정을 응원합니다.

---

오늘 배운 것 정리

• 설정 스코프: Managed > User > Project > Local 계층 구조

• 팀 설정: .claude/settings.json으로 권한, Hook, 공지사항 공유

• 보안 거버넌스: Managed Settings로 조직 정책 강제, Red/Yellow/Green Zone으로 분류

• 코드 리뷰: Claude는 자동화, 인간은 비즈니스 로직과 최종 결정

• AI as Mediator: 의견 대립 시 AI를 중재자로 활용

• Plugins: Skills, Hooks, MCP를 하나로 패키징해 팀 배포

• 팀 협업 플랫폼: 역할 기반 어시스턴트, 브레인스토밍, 지식 공유

• 역할 분담: AI는 반복 작업, 인간은 창의적/전략적 작업

• 모니터링: OpenTelemetry로 사용량 추적

---

참고 자료

• Claude Code Security
• Settings Reference
• Permissions
• Monitoring Usage
• Anthropic Trust Center

---

“이제와서 시작하는 Claude AI 마스터하기” 시리즈는 AI 개발 도구를 처음 접하는 분들을 위한 실전 가이드입니다.