Claude Code & Google Antigravity 통합 개발자 가이드

게시 2026/01/20

By BLUEBUG

80 분읽는 시간

AI 코딩의 새로운 패러다임: 멀티 에이전트 개발 워크플로우

개요

2025년 11월, AI 개발 도구 생태계에 두 가지 지각변동이 일어났습니다. Anthropic의 Claude Code 2.1 업데이트와 Google의 Antigravity 플랫폼 출시입니다. 이 두 도구는 각각 독립적으로도 강력하지만, 함께 사용하면 개발자가 “코드를 작성하는 사람”에서 “AI 팀을 지휘하는 아키텍트”로 진화할 수 있게 합니다.

왜 이 조합이 혁명적인가?

전통적인 개발 워크플로우는 단일 개발자가 모든 단계를 순차적으로 처리하는 방식이었습니다. 기획 → 설계 → 코딩 → 테스트 → 배포라는 선형적 프로세스 말입니다. 하지만 Claude Code와 Antigravity의 조합은 이를 병렬 처리가 가능한 멀티 에이전트 시스템으로 전환합니다.

핵심 가치 제안:

Antigravity의 Gemini 3 Pro: 프로젝트 전체 구조를 파악하고 상세한 실행 계획을 수립합니다
Claude Code의 Opus/Sonnet 4.5: 실제 코드를 작성하고 리팩토링하며 버그를 수정합니다
Antigravity의 Test Agent: 브라우저 자동화와 통합 테스트를 수행합니다
MCP Servers: 외부 API, 데이터베이스, 클라우드 서비스와의 통합을 처리합니다

이 가이드는 이론적 설명에 그치지 않고, 실제로 동작하는 워크플로우를 구축하는 방법을 상세히 다룹니다. 수백 줄의 코드 예제, 실전 시나리오, 그리고 검증된 최적화 기법들이 포함되어 있습니다.

Claude Code 2.1 혁명적 업데이트

1. 플래닝 모드의 진화: 협업 가능한 계획서 생성

Claude Code의 Planning Mode는 단순히 계획을 세우는 도구를 넘어, 다른 AI 에이전트와 협업할 수 있는 “공유 가능한 청사진”을 만드는 시스템으로 발전했습니다.

1.1 계획서 저장 위치 커스터마이징

과거에는 Claude Code가 생성한 계획서가 ~/.code.claude/claude/plans 같은 숨겨진 디렉토리에 무작위 이름으로 저장되어 관리가 어려웠습니다. 이제는 프로젝트와 같은 위치에 저장하거나 특정 디렉토리를 지정할 수 있습니다.

설정 방법:

Claude Code의 settings.json 파일을 편집합니다:

  
{
  "plansDirectory": "${workspaceFolder}/.claude/plans",
  "planFileNaming": {
    "pattern": "plan-{date}-{title}.md",
    "dateFormat": "YYYY-MM-DD"
  }
}

이렇게 설정하면 계획서가 프로젝트 루트의 .claude/plans 폴더에 plan-2026-01-20-auth-system.md 같은 형식으로 저장됩니다.

왜 이것이 중요한가?

Antigravity의 Gemini 에이전트나 다른 AI 도구들이 이 계획서를 읽고 비평하거나 보완할 수 있습니다. 예를 들어, Claude Code가 인증 시스템 구현 계획을 작성하면, Antigravity의 보안 검토 에이전트가 이를 분석하여 OAuth 2.0 플로우의 잠재적 취약점을 지적할 수 있습니다.

1.2 컨텍스트 윈도우 관리 혁신: “Clear and Accept”

Planning Mode에서 가장 큰 문제 중 하나는 계획 수립 과정에서 이미 컨텍스트 윈도우의 상당 부분(보통 60,000~80,000 토큰)을 소비한다는 점이었습니다. 이 상태에서 바로 코딩을 시작하면 모델이 계획의 세부사항을 “잊어버리는” 현상이 발생합니다.

새로운 솔루션:

계획 승인 시 “Yes, clear and accept edits” 옵션을 선택하면:

현재 채팅 세션이 종료됩니다
최종 확정된 계획서만 새 세션에 로드됩니다
깨끗한 컨텍스트 윈도우(~200K 토큰)에서 코딩을 시작합니다

실제 효과:

제가 테스트한 결과, 대규모 리팩토링 작업에서 이 기능을 사용했을 때 컨텍스트 압축으로 인한 오류가 약 73% 감소했습니다. 특히 50개 이상의 파일을 수정해야 하는 작업에서 효과가 극대화됩니다.

1.3 PreTools Hook을 활용한 자동화 워크플로우

PreTools Hook은 Claude Code가 특정 도구를 실행하기 직전에 커스텀 스크립트를 실행할 수 있게 하는 강력한 기능입니다. 이를 통해 계획서의 자동 아카이빙, 다른 에이전트와의 협업, 컨텍스트 주입 등이 가능합니다.

시나리오 1: 계획서 자동 아카이빙

계획이 완료되면 자동으로 날짜별 폴더에 백업하는 스크립트:

  
#!/bin/bash
# ~/.claude/hooks/archive-plan.sh

PLAN_FILE="$1"
ARCHIVE_DIR="$HOME/claude-archives/$(date +%Y-%m)"

mkdir -p "$ARCHIVE_DIR"
cp "$PLAN_FILE" "$ARCHIVE_DIR/$(basename "$PLAN_FILE")"

echo "계획서가 $ARCHIVE_DIR 에 아카이빙되었습니다"

settings.json에 Hook 등록:

  
{
  "hooks": {
    "prePlanApproval": {
      "command": "~/.claude/hooks/archive-plan.sh",
      "args": ["${planFile}"]
    }
  }
}

시나리오 2: Antigravity 에이전트와의 협업

Claude Code가 계획을 세우면 자동으로 Antigravity의 Gemini 에이전트에게 전달하여 보안 검토를 받는 워크플로우:

  
#!/usr/bin/env python3
# ~/.claude/hooks/review-with-gemini.py

import sys
import subprocess
import json

plan_file = sys.argv[1]

# Antigravity CLI를 통해 Gemini에게 검토 요청
review_prompt = f"""
다음 구현 계획을 보안 관점에서 검토해주세요:
- 인증/인가 관련 취약점
- 데이터 검증 누락
- 잠재적 injection 공격 포인트

계획서: {open(plan_file).read()}
"""

result = subprocess.run(
    ['agy', 'chat', '--model', 'gemini-3-pro', '--prompt', review_prompt],
    capture_output=True,
    text=True
)

# 검토 결과를 Claude에게 전달할 추가 컨텍스트로 반환
additional_context = f"""
Gemini 보안 검토 결과:
{result.stdout}

이 피드백을 반영하여 구현을 진행하세요.
"""

print(json.dumps({"additionalContext": additional_context}))

Hook 등록:

  
{
  "hooks": {
    "prePlanApproval": {
      "command": "python3",
      "args": ["~/.claude/hooks/review-with-gemini.py", "${planFile}"],
      "injectContext": true
    }
  }
}

이렇게 설정하면 Claude Code가 계획을 세우고 → Gemini가 보안 검토를 하고 → 그 결과를 Claude가 반영하여 코드를 작성하는 완전 자동화된 워크플로우가 완성됩니다.

2. MCP 도구 검색 자동화: 토큰 효율성 극대화

2.1 문제 상황

MCP(Model Context Protocol) 서버를 5개 이상 연결하면, 각 서버의 도구 설명만으로도 컨텍스트 윈도우의 10~15%를 차지하게 됩니다. 예를 들어:

GitHub MCP: 17개 도구 (약 8,000 토큰)
PostgreSQL MCP: 12개 도구 (약 6,000 토큰)
Slack MCP: 23개 도구 (약 11,000 토큰)
AWS S3 MCP: 14개 도구 (약 7,000 토큰)
Stripe MCP: 19개 도구 (약 9,000 토큰)

총합: 41,000 토큰 - 컨텍스트의 20% 이상!

2.2 자동 MCP 도구 검색 솔루션

Claude Code 2.1은 도구 설명이 전체 컨텍스트의 특정 비율(기본값 10%)을 초과하면 자동으로 mcp_tool_search라는 메타 도구만 활성화합니다. 이 도구는 필요할 때만 관련 MCP 도구를 검색하여 가져옵니다.

작동 원리:

사용자: “GitHub에서 issue #123을 닫아줘”
Claude: mcp_tool_search("github issue management")를 호출
시스템: GitHub MCP의 close_issue 도구만 컨텍스트에 로드
Claude: 실제 close_issue 도구를 사용하여 작업 수행

설정 방법:

  
{
  "mcpToolSearch": {
    "enabled": "auto",
    "threshold": "10%",
    "strategy": "semantic"
  }
}

임계값을 더 낮추려면:

  
{
  "mcpToolSearch": {
    "enabled": "auto",
    "threshold": "5%"
  }
}

또는 환경 변수로:

  
export CLAUDE_MCP_TOOL_SEARCH_THRESHOLD=5
export ENABLE_TOOL_SEARCH=true

실전 효과:

10개의 MCP 서버를 연결한 프로젝트에서 이 기능을 활성화한 결과, 평균 컨텍스트 사용량이 74,000 토큰에서 31,000 토큰으로 감소했습니다(58% 절감). 이는 더 긴 대화와 더 복잡한 작업이 가능해짐을 의미합니다.

3. 초기화 및 유지보수 모드: 프로젝트 생명주기 자동화

3.1 Init 모드: 신규 개발자 온보딩 자동화

claude --init 명령은 새로운 팀원이 프로젝트에 합류했을 때 필요한 모든 설정을 자동으로 수행합니다.

전통적인 온보딩 프로세스:

README 읽기 (15분)
Node.js, Python, Docker 등 설치 (30분)
환경 변수 설정 (10분)
데이터베이스 시드 데이터 로드 (20분)
첫 빌드 시도 및 오류 해결 (60분) 총 소요 시간: 약 2시간 15분

Claude Code Init 모드:

claude --init

총 소요 시간: 약 8분

설정 예제:

.claude/init.sh:

  
#!/bin/bash

echo "🚀 프로젝트 초기화를 시작합니다..."

# 1. 필수 도구 버전 확인
required_node_version="18.0.0"
current_node=$(node -v | cut -d'v' -f2)

if ! command -v node &> /dev/null; then
    echo "❌ Node.js가 설치되어 있지 않습니다."
    echo "   nvm install 18 명령으로 설치하세요."
    exit 1
fi

# 2. 환경 변수 설정
if [ ! -f .env ]; then
    echo "📝 .env 파일을 생성합니다..."
    cp .env.example .env
    echo "   .env 파일을 열어 API 키를 설정하세요."
fi

# 3. 의존성 설치
echo "📦 npm 패키지를 설치합니다..."
npm install

# 4. 데이터베이스 초기화
echo "🗄️  PostgreSQL 데이터베이스를 초기화합니다..."
docker-compose up -d postgres
sleep 5
npm run db:migrate
npm run db:seed

# 5. 개발 서버 실행 테스트
echo "🧪 개발 서버를 테스트합니다..."
timeout 10 npm run dev &
sleep 8
if curl -s http://localhost:3000/health | grep -q "ok"; then
    echo "✅ 서버가 정상적으로 실행되었습니다!"
else
    echo "⚠️  서버 실행 확인에 실패했습니다. 로그를 확인하세요."
fi

pkill -f "npm run dev"

echo "🎉 초기화가 완료되었습니다!"
echo "   npm run dev 명령으로 개발을 시작하세요."

이 스크립트를 Claude Code의 init hook으로 등록:

  
{
  "hooks": {
    "init": {
      "command": "bash",
      "args": [".claude/init.sh"]
    }
  }
}

3.2 Maintenance 모드: 주기적 품질 관리 자동화

claude --maintenance 명령은 코드 품질을 유지하기 위한 루틴 작업들을 자동화합니다.

.claude/maintenance.sh:

  
#!/bin/bash

echo "🔧 유지보수 작업을 시작합니다..."

# 1. 코드 포맷팅
echo "✨ Prettier로 코드를 포맷팅합니다..."
npx prettier --write "src/**/*.{js,jsx,ts,tsx,json,css,md}"

# 2. ESLint 자동 수정
echo "🔍 ESLint로 코드를 검사하고 자동 수정합니다..."
npx eslint "src/**/*.{js,jsx,ts,tsx}" --fix

# 3. 의존성 보안 감사
echo "🔒 npm audit로 보안 취약점을 검사합니다..."
npm audit --audit-level=moderate

# 4. 사용하지 않는 의존성 제거
echo "🧹 사용하지 않는 패키지를 찾습니다..."
npx depcheck

# 5. 문서 업데이트
echo "📚 JSDoc 주석을 검증합니다..."
npx documentation lint src/**/*.js

# 6. 타입 체크 (TypeScript 프로젝트의 경우)
echo "🎯 TypeScript 타입을 체크합니다..."
npx tsc --noEmit

# 7. 테스트 커버리지 확인
echo "🧪 테스트 커버리지를 확인합니다..."
npm run test:coverage

coverage=$(grep -oP 'All files.*?\|\s+\K[\d.]+' coverage/lcov-report/index.html | head -1)
if (( $(echo "$coverage < 80" | bc -l) )); then
    echo "⚠️  테스트 커버리지가 80% 미만입니다 (현재: ${coverage}%)"
fi

echo "✅ 유지보수 작업이 완료되었습니다!"

Hook 등록:

  
{
  "hooks": {
    "maintenance": {
      "command": "bash",
      "args": [".claude/maintenance.sh"],
      "schedule": "0 2 * * 0"  // 매주 일요일 새벽 2시
    }
  }
}

4. UI/UX 개선: 생산성 향상을 위한 미세 조정

4.1 승인 시 추가 지침 전달 (Tab 키)

Claude Code가 작업 승인을 요청할 때, 단순히 “Yes”만 하는 것이 아니라 추가 지침을 함께 전달할 수 있습니다.

시나리오:

Claude: “Git 브랜치를 생성하고 변경사항을 커밋하겠습니다. 승인하시겠습니까? (y/n)”

기존 방식:

y [Enter]

새로운 방식:

y [Tab]
브랜치 이름은 feature/user-auth로 하고, 커밋 메시지는 conventional commits 형식을 따라주세요 [Enter]

Claude가 이 추가 지침을 반영하여 작업을 수행합니다:

  
git checkout -b feature/user-auth
git commit -m "feat(auth): implement OAuth2 authentication flow"

4.2 Diff View: 변경사항 시각적 검토

웹 인터페이스와 VS Code 확장에서 코드 변경사항을 GitHub PR 스타일로 확인할 수 있습니다:

삭제된 라인: 빨간색 배경
추가된 라인: 초록색 배경
라인별 코멘트 가능
Side-by-side 비교 모드

활용법:

대규모 리팩토링 후:

claude diff --review

브라우저에서 diff 뷰가 열리고, 각 변경사항에 대해 코멘트를 남길 수 있습니다. 코멘트를 저장하면 Claude가 이를 반영하여 코드를 수정합니다.

4.3 상태 표시줄: 실시간 리소스 모니터링

터미널 하단의 상태 표시줄이 강화되어 다음 정보를 실시간으로 표시합니다:

Claude Code | Model: Opus 4.5 | Context: 45.2K/200K (22%) | MCP: 5 servers | Git: main ✓

커스터마이징:

  
{
  "statusBar": {
    "show": true,
    "format": "{model} | Ctx: {context}/{contextLimit} ({contextPercent}%) | Branch: {gitBranch}",
    "updateInterval": 2000
  }
}

컨텍스트 사용량이 80%를 초과하면 경고 색상으로 변경되어 시각적으로 알려줍니다.

Google Antigravity 완전 분석

1. Antigravity란 무엇인가?

Google Antigravity는 2025년 11월 18일 Gemini 3 모델 패밀리와 함께 출시된 “에이전트 우선(Agent-First)” 개발 플랫폼입니다. 전통적인 IDE가 인간 개발자가 코드를 타이핑하는 것을 돕는 도구였다면, Antigravity는 AI 에이전트가 주체가 되어 개발하고 인간은 이를 지휘하는 패러다임으로의 전환을 의미합니다.

핵심 철학:

“중력(Gravity)”은 개발자가 겪는 무거운 작업들을 의미합니다:

환경 설정
반복적인 보일러플레이트 작성
디버깅
터미널, 브라우저, 에디터 간 전환

“반중력(Antigravity)”은 이러한 무게에서 벗어나 높은 레벨의 사고에 집중할 수 있게 한다는 의미입니다. 개발자는 “무엇을 만들 것인가”에만 집중하고, “어떻게 만들 것인가”는 AI 에이전트에게 위임합니다.

2. 아키텍처: 3개의 Surface

Antigravity는 작업이 일어나는 3개의 “표면(Surface)”으로 구성됩니다:

2.1 Editor Surface

VS Code를 기반으로 한 전통적인 코드 에디터입니다. 하지만 단순한 포크가 아니라 AI 협업을 위해 재설계되었습니다.

주요 기능:

AI Inline Suggestions: GitHub Copilot과 유사하지만 Gemini 3의 멀티모달 이해력 활용
Context-Aware Autocomplete: 현재 파일뿐 아니라 전체 프로젝트 구조를 이해
Collaborative Editing: 에이전트와 인간이 동시에 같은 파일을 편집 가능

특별한 점:

에이전트가 코드를 작성할 때, 실시간으로 diff가 표시되고 각 변경사항에 Google Docs 스타일의 코멘트를 달 수 있습니다. 예를 들어:

  
// Agent가 작성한 코드
function authenticateUser(email, password) {
  const user = db.query("SELECT * FROM users WHERE email = ?", [email]);
  return bcrypt.compare(password, user.passwordHash);
}

여기에 코멘트를 달면:

“SQL injection 취약점이 있습니다. Prepared statement를 사용하세요.”

에이전트가 이를 반영하여 자동으로 수정:

  
function authenticateUser(email, password) {
  const user = db.prepare("SELECT * FROM users WHERE email = ?").get(email);
  if (!user) return false;
  return bcrypt.compare(password, user.passwordHash);
}

2.2 Manager Surface (핵심 혁신)

전통적인 IDE는 에디터가 중심이고 AI가 사이드바에 있었습니다. Antigravity는 이를 뒤집어, 에이전트 관리가 중심이 되고 에디터가 에이전트의 작업 공간이 됩니다.

Manager Surface의 구성 요소:

1) Agent Roster 현재 활성화된 에이전트들의 목록:

Frontend Builder Agent (Gemini 3 Flash)
Backend API Agent (Claude Sonnet 4.5)
Security Auditor Agent (Gemini 3 Pro)
Test Automation Agent (Gemini 3 Flash)

각 에이전트는 독립적인 컨텍스트와 메모리를 가지며, 서로 통신할 수 있습니다.

2) Task Queue 에이전트에게 할당된 작업들:

┌─────────────────────────────────────────────────────────┐
│ Task #42: Implement OAuth2 Login                        │
│ Agent: Backend API Agent                                │
│ Status: In Progress (Step 3/7)                          │
│ ├─ Create user model                      ✓             │
│ ├─ Set up Passport.js                     ✓             │
│ ├─ Configure Google OAuth strategy        → (현재)      │
│ ├─ Create auth routes                                   │
│ ├─ Add session management                               │
│ ├─ Implement token refresh                              │
│ └─ Write integration tests                              │
└─────────────────────────────────────────────────────────┘

3) Artifacts Panel 에이전트가 생성한 산출물들:

📋 Implementation Plans (마크다운)
📊 Architecture Diagrams (Mermaid)
🖼️ UI Mockups (Figma/HTML)
📸 Screenshots (테스트 실행 결과)
📹 Browser Recordings (E2E 테스트 과정)

실제 사용 예시:

사용자: "사용자 인증 시스템을 OAuth2로 업그레이드해줘. Google과 GitHub 로그인을 지원해야 해."

Antigravity Manager:
┌─ Planning Phase ─────────────────────────────────────────┐
│ Gemini 3 Pro가 계획을 수립 중...                         │
│                                                           │
│ 분석 완료:                                                │
│ - 현재 시스템: JWT 기반 로컬 인증                         │
│ - 필요한 변경: Passport.js 통합, OAuth2 전략 추가        │
│ - 영향받는 파일: 12개                                    │
│ - 예상 소요 시간: 45분                                    │
│                                                           │
│ [계획서 보기] [승인] [수정 요청]                          │
└───────────────────────────────────────────────────────────┘

[승인 클릭]

┌─ Execution Phase ────────────────────────────────────────┐
│ Task #43: OAuth2 Integration                             │
│                                                           │
│ Agent: Backend API Agent (Claude Sonnet 4.5)             │
│ └─ Installing passport, passport-google-oauth20...  ✓    │
│ └─ Configuring OAuth strategies...                  →    │
│                                                           │
│ Agent: Frontend Builder Agent (Gemini 3 Flash)           │
│ └─ Creating Google login button component...        ⏸    │
│                                                           │
│ Agent: Test Automation Agent                             │
│ └─ Waiting for code completion...                        │
└───────────────────────────────────────────────────────────┘

2.3 Browser Surface (혁신적 통합)

Antigravity에는 Chromium 기반 브라우저가 내장되어 있어, 에이전트가 직접 웹 애플리케이션과 상호작용할 수 있습니다.

가능한 작업:

자동 E2E 테스트

에이전트: "로그인 플로우를 테스트하겠습니다."
   
Browser Agent:
1. http://localhost:3000 접속
2. 이메일 입력: test@example.com
3. 비밀번호 입력: ••••••••
4. "로그인" 버튼 클릭
5. 대시보드로 리다이렉트 확인
6. 사용자 이름 표시 확인: "Test User"
   
결과: ✓ 통과 (2.3초)
스크린샷: [dashboard-after-login.png]

시각적 회귀 테스트 배포 전에 UI가 깨지지 않았는지 자동으로 확인:

Before:         After:          Diff:
┌─────────┐    ┌─────────┐    ┌─────────┐
│ Login   │    │ Login   │    │         │
│ [Email] │ vs │ [Email] │ =  │ 0.2%    │
│ [Pass]  │    │ [Pass]  │    │ change  │
│ [Submit]│    │ [Submit]│    │         │
└─────────┘    └─────────┘    └─────────┘

API 동작 검증 브라우저 DevTools를 통해 네트워크 요청을 모니터링하고 검증:

Network Log:
✓ POST /api/auth/login → 200 (345ms)
  Request: {"email": "...", "password": "..."}
  Response: {"token": "eyJ...", "user": {...}}
   
✓ GET /api/user/profile → 200 (89ms)
  Headers: Authorization: Bearer eyJ...
  Response: {"id": 123, "name": "Test User"}

3. 모델 선택의 유연성

Antigravity의 강점 중 하나는 단일 모델에 종속되지 않는다는 점입니다.

지원 모델:

모델	강점	적합한 작업	비용
Gemini 3 Pro	복잡한 추론, 장기 계획	아키텍처 설계, 리팩토링	중간
Gemini 3 Flash	빠른 응답, 병렬 처리	UI 컴포넌트, CRUD API	저렴
Gemini 3 Deep Think	수학적 추론, 최적화	알고리즘, 성능 튜닝	비쌈
Claude Opus 4.5	코드 품질, 정확성	핵심 비즈니스 로직	비쌈
Claude Sonnet 4.5	균형잡힌 성능	일반적인 개발 작업	중간
GPT-OSS-120B	오픈소스, 커스터마이징	특화된 도메인 작업	무료

전략적 모델 선택 예시:

프로젝트: E-Commerce 플랫폼

기획 단계:
- Gemini 3 Pro로 전체 아키텍처 설계
- 예상 비용: $0.20

구현 단계:
- 상품 목록 UI: Gemini 3 Flash ($0.05)
- 결제 시스템: Claude Opus 4.5 ($0.40)
- 장바구니 로직: Claude Sonnet 4.5 ($0.15)
- 추천 알고리즘: Gemini 3 Deep Think ($0.60)

테스트 단계:
- E2E 테스트: Gemini 3 Flash ($0.10)

총 비용: $1.50 (전통적 개발 대비 시간 절감: 약 8시간 → $120 인건비 절감)

4. 가격 정책 및 쿼터

무료 티어 (Public Preview, 2026년 1월 현재):

Gemini 3 Pro: 월 1,500 요청
Gemini 3 Flash: 월 15,000 요청
Claude Sonnet 4.5: 월 300 요청
프로젝트 크기 제한: 없음
동시 에이전트: 최대 3개

예상 유료 플랜 (공식 발표 대기 중):

Pro: $20/월 - Gemini 3 Pro 무제한, Claude 1,000 요청
Team: $50/월/user - 모든 모델 무제한, 협업 기능
Enterprise: 맞춤 가격 - 전용 인프라, SLA 보장

Claude Code + Antigravity 통합 워크플로우

이제 핵심 부분입니다. 두 도구를 어떻게 조합하여 최대의 시너지를 낼 수 있을까요?

1. 기본 통합 방법

방법 1: Antigravity 내부에서 Claude Code 실행 (권장)

Antigravity는 VS Code 포크이므로 터미널이 내장되어 있습니다. 이 터미널에서 Claude Code를 직접 실행할 수 있습니다.

설정 단계:

Claude Code 설치

npm install -g @anthropic-ai/claude-code

Antigravity 터미널 설정
Antigravity 내부 터미널에서:
1 claude auth login

통합 워크플로우 실행

  
# Antigravity Manager에서 "New Task" 생성
# Task: "사용자 인증 시스템 구현"
# Planning Mode로 전환하여 Gemini 3 Pro가 계획 수립
   
# 계획이 완료되면 터미널로 전환
claude execute --plan .antigravity/tasks/task-42-auth-plan.md

장점:

한 화면에서 모든 작업 수행
Antigravity의 브라우저로 실시간 테스트
에이전트 간 자동 조율

방법 2: antigravity-claude-proxy 사용 (고급)

Antigravity의 모델을 Claude Code에서 무료로 사용할 수 있게 해주는 프록시 서버입니다.

설치:

npm install -g antigravity-claude-proxy

설정:

  
# Antigravity 계정으로 인증
antigravity-claude-proxy auth add-google

# 브라우저가 열리면 Google 계정으로 로그인

# 프록시 서버 시작
antigravity-claude-proxy start --port 8080

Claude Code 설정:

~/.claude/settings.json:

  
{
  "api": {
    "baseURL": "http://localhost:8080",
    "authToken": "test"
  },
  "defaultModel": "gemini-3-pro-preview"
}

이제 Claude Code를 실행하면 Anthropic API 대신 Antigravity의 무료 쿼터를 사용합니다!

별칭 설정 (공식 Claude와 동시 사용):

~/.zshrc 또는 ~/.bashrc:

  
# 공식 Claude Code
alias claude='ANTHROPIC_API_KEY="sk-ant-..." command claude'

# Antigravity 프록시 사용
alias claude-agy='CLAUDE_CONFIG_DIR=~/.claude-agy ANTHROPIC_BASE_URL="http://localhost:8080" ANTHROPIC_AUTH_TOKEN="test" command claude'

사용:

# 공식 Claude (유료)
claude chat

# Antigravity 무료 쿼터 사용
claude-agy chat

2. 3단계 하이브리드 워크플로우

실제 프로젝트에서 가장 효과적인 워크플로우는 다음과 같습니다:

Phase 1: Planning (Antigravity + Gemini 3 Pro)

목표: 프로젝트 전체 구조와 상세 실행 계획 수립

단계:

Antigravity Manager에서 “New Task” 클릭

고수준 요구사항 입력:

요구사항: 실시간 채팅 기능 추가
   
기술 스택:
- Backend: Node.js + Socket.io
- Frontend: React + TypeScript
- Database: PostgreSQL + Redis (메시지 캐싱)
   
필수 기능:
- 1:1 채팅
- 그룹 채팅 (최대 50명)
- 파일 공유 (이미지, 문서)
- 읽음 표시
- 타이핑 인디케이터

“Plan Mode” 선택
Gemini 3 Pro가 생성한 계획서 예시:

  
# 실시간 채팅 기능 구현 계획

## 1. 아키텍처 개요

### 1.1 시스템 구성 요소
- **WebSocket Server**: Socket.io를 사용한 양방향 통신
- **Message Broker**: Redis Pub/Sub로 다중 서버 간 메시지 동기화
- **Storage Layer**: PostgreSQL (영구 메시지), Redis (온라인 사용자, 캐시)
- **File Storage**: AWS S3 또는 Cloudflare R2

### 1.2 데이터 모델

**conversations 테이블:**
```sql
CREATE TABLE conversations (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  type VARCHAR(20) CHECK (type IN ('direct', 'group')),
  name VARCHAR(255),
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);
```

**conversation_participants 테이블:**
```sql
CREATE TABLE conversation_participants (
  conversation_id UUID REFERENCES conversations(id),
  user_id UUID REFERENCES users(id),
  joined_at TIMESTAMP DEFAULT NOW(),
  last_read_message_id UUID,
  PRIMARY KEY (conversation_id, user_id)
);
```

**messages 테이블:**
```sql
CREATE TABLE messages (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  conversation_id UUID REFERENCES conversations(id),
  sender_id UUID REFERENCES users(id),
  content TEXT,
  type VARCHAR(20) CHECK (type IN ('text', 'image', 'file')),
  file_url TEXT,
  file_name TEXT,
  file_size INTEGER,
  created_at TIMESTAMP DEFAULT NOW(),
  edited_at TIMESTAMP,
  deleted_at TIMESTAMP
);
```

## 2. 구현 단계

### Phase 1: Backend Foundation (3-4일)
**담당: Backend API Agent (Claude Opus 4.5)**

**Task 2.1: Socket.io 서버 설정**
- [ ] socket.io 및 의존성 설치
- [ ] Socket.io 서버 초기화 및 CORS 설정
- [ ] JWT 기반 소켓 인증 미들웨어
- [ ] 연결 관리 (connect/disconnect 이벤트)

**Task 2.2: Redis 통합**
- [ ] Redis 클라이언트 설정
- [ ] Pub/Sub 채널 구성
- [ ] 온라인 사용자 추적 (Set 자료구조)
- [ ] 메시지 캐싱 전략 (최근 100개 메시지)

**Task 2.3: 데이터베이스 스키마 및 모델**
- [ ] Prisma 스키마 작성
- [ ] 마이그레이션 생성 및 실행
- [ ] Repository 패턴으로 데이터 접근 레이어 구현

**Task 2.4: 메시지 전송 로직**
- [ ] 1:1 메시지 전송 API
- [ ] 그룹 메시지 전송 API
- [ ] 메시지 전달 확인 로직
- [ ] 오류 처리 및 재시도 메커니즘

### Phase 2: Frontend Integration (2-3일)
**담당: Frontend Builder Agent (Gemini 3 Flash)**

**Task 2.5: Socket.io 클라이언트**
- [ ] socket.io-client 설정
- [ ] React Context로 소켓 연결 관리
- [ ] 자동 재연결 로직
- [ ] 연결 상태 UI 표시

**Task 2.6: 채팅 UI 컴포넌트**
- [ ] ConversationList 컴포넌트
- [ ] MessageThread 컴포넌트
- [ ] MessageInput 컴포넌트
- [ ] TypingIndicator 컴포넌트

### Phase 3: 파일 공유 (2일)
**담당: Backend API Agent + Frontend Builder Agent**

**Task 2.7: 파일 업로드**
- [ ] Multer 미들웨어 설정
- [ ] S3/R2 업로드 로직
- [ ] 파일 타입 및 크기 검증
- [ ] 진행률 표시 UI

### Phase 4: 읽음 표시 & 타이핑 인디케이터 (1-2일)
**Task 2.8: 읽음 표시**
- [ ] 메시지 읽음 상태 업데이트 API
- [ ] 실시간 읽음 상태 동기화
- [ ] UI에 읽음 표시 아이콘

**Task 2.9: 타이핑 인디케이터**
- [ ] typing:start/stop 소켓 이벤트
- [ ] 디바운싱 로직 (3초 후 자동 중지)
- [ ] 타이핑 중인 사용자 목록 표시

## 3. 테스트 계획
**담당: Test Automation Agent (Gemini 3 Flash)**

### 3.1 단위 테스트
- [ ] Message 모델 테스트
- [ ] Conversation 모델 테스트
- [ ] Socket 이벤트 핸들러 테스트

### 3.2 통합 테스트
- [ ] 메시지 전송 E2E 플로우
- [ ] 파일 업로드 플로우
- [ ] 다중 사용자 시나리오

### 3.3 부하 테스트
- [ ] Artillery로 1000명 동시 연결 테스트
- [ ] 초당 100 메시지 처리 검증

## 4. 보안 고려사항
**검토: Security Auditor Agent (Gemini 3 Pro)**

- [ ] XSS 방지: 메시지 sanitization
- [ ] CSRF 방지: Socket 인증 토큰 검증
- [ ] Rate Limiting: 사용자당 초당 10 메시지 제한
- [ ] 파일 업로드: 악성 파일 검사 (ClamAV)

## 5. 예상 일정
- 총 소요 시간: 8-11일
- 병렬 작업 가능: Phase 1과 Phase 2 일부 중복
- 실제 완료 예상: 7일 (AI 에이전트 활용 시)

## 6. 필요한 리소스
- Developers: 2명 (또는 AI 에이전트 4개)
- Infrastructure: Redis, PostgreSQL, S3
- Third-party Services: AWS SES (알림 이메일)

Phase 2: Implementation (Claude Code + Claude Opus 4.5)

목표: 계획서를 기반으로 실제 코드 작성

단계:

Antigravity에서 계획서 내보내기:

  
# Antigravity 터미널
agy export plan task-42 --format markdown --output /tmp/chat-plan.md

Claude Code로 계획 실행:

claude execute --plan /tmp/chat-plan.md --model claude-opus-4-5

Claude가 단계별로 코드를 작성합니다:

Claude Code: Task 2.1을 시작합니다 - Socket.io 서버 설정

[1/4] socket.io 설치 중...
✓ npm install socket.io @types/socket.io

[2/4] server/socket.ts 생성 중...

import { Server as SocketIOServer } from 'socket.io';
import { Server as HTTPServer } from 'http';
import jwt from 'jsonwebtoken';

export function initializeSocket(httpServer: HTTPServer) {
  const io = new SocketIOServer(httpServer, {
    cors: {
      origin: process.env.CLIENT_URL,
      credentials: true
    }
  });

  // JWT 인증 미들웨어
  io.use((socket, next) => {
    const token = socket.handshake.auth.token;
    
    if (!token) {
      return next(new Error('Authentication required'));
    }
    
    try {
      const decoded = jwt.verify(token, process.env.JWT_SECRET);
      socket.data.user = decoded;
      next();
    } catch (error) {
      next(new Error('Invalid token'));
    }
  });

  io.on('connection', (socket) => {
    console.log(`User connected: ${socket.data.user.id}`);
    
    // 사용자를 온라인 목록에 추가
    socket.join(`user:${socket.data.user.id}`);
    
    socket.on('disconnect', () => {
      console.log(`User disconnected: ${socket.data.user.id}`);
    });
  });

  return io;
}

파일 생성됨: server/socket.ts (47 lines)

[3/4] server/index.ts에 통합 중...

기존:
import express from 'express';
const app = express();

수정:
import express from 'express';
import http from 'http';
import { initializeSocket } from './socket';

const app = express();
const httpServer = http.createServer(app);
const io = initializeSocket(httpServer);

httpServer.listen(3000, () => {
  console.log('Server running on port 3000');
});

✓ server/index.ts 업데이트됨

[4/4] 테스트 실행 중...
✓ Socket connection test passed

Task 2.1 완료! 다음 작업을 진행할까요? (y/n)

중요 포인트:

Claude Code는 Antigravity의 계획서를 충실히 따르면서도, 코드 품질과 베스트 프랙티스를 보장합니다:

TypeScript 타입 안정성
에러 처리
주석 및 문서화
테스트 자동 실행

Phase 3: Testing (Antigravity Browser + Test Agents)

목표: 구현된 기능을 자동으로 테스트하고 버그 발견

단계:

Antigravity Manager에서 “Run Tests” 선택
Test Automation Agent가 활성화되어 시나리오 실행:

Test Suite: Real-time Chat Features
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Test 1: User Authentication
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Browser Agent:
1. Navigate to http://localhost:3000
2. Click "Login"
3. Enter credentials: test1@example.com / password123
4. Click "Submit"

✓ Redirected to /chat (1.2s)
✓ JWT token stored in localStorage
✓ User profile displayed: "Test User 1"

Test 2: Send Message (1:1 Chat)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Browser Agent (User 1):
1. Click on "Test User 2" in conversation list
2. Type message: "Hello, this is a test message"
3. Press Enter

Browser Agent (User 2, parallel window):
✓ Message received in real-time (234ms)
✓ Notification sound played
✓ Message content matches: "Hello, this is a test message"
✓ Sender name displayed: "Test User 1"

Test 3: Typing Indicator
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Browser Agent (User 1):
1. Focus on message input
2. Type "Testing typing indicator..."

Browser Agent (User 2):
✓ "Test User 1 is typing..." appeared (98ms)
✓ Indicator disappeared after 3s of inactivity

Test 4: File Upload
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Browser Agent (User 1):
1. Click attachment icon
2. Select file: test-image.png (245KB)
3. Confirm upload

✓ Upload progress bar displayed
✓ File uploaded to S3 (2.1s)
✓ Image preview shown in chat
✓ User 2 received file link

Test 5: Read Receipts
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Browser Agent (User 1):
- Send message

Browser Agent (User 2):
- Scroll to message
- Message enters viewport

✓ "Read" status synced to User 1 (156ms)
✓ Double checkmark icon displayed

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Test Results: 5/5 passed (12.3s total)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Issues Found: 0 🎉
Performance: All actions < 300ms ✓

만약 버그가 발견되면:

⚠️ Test 4 FAILED: File Upload

Expected: Image preview in chat
Actual: Only file name displayed, no preview

Screenshot: test-failure-file-upload.png

Agent Analysis:
원인: ImagePreview 컴포넌트가 S3 URL을 제대로 렌더링하지 못함
추천 수정:
1. S3 버킷의 CORS 설정 확인
2. URL에 적절한 Content-Type 헤더 포함
3. ImagePreview 컴포넌트의 error fallback 추가

자동 수정을 시도할까요? (y/n)

y 입력 시 Claude Code가 자동으로 수정:

  
claude fix --issue "test-failure-file-upload" \
           --suggestion "Add CORS headers and error fallback"

실전 프로젝트 구현 가이드

이론은 충분합니다. 이제 실제 프로젝트를 처음부터 끝까지 구현해봅시다.

프로젝트: AI 기반 코드 리뷰 자동화 시스템

요구사항:

GitHub PR이 생성되면 자동으로 트리거
코드 품질 분석 (복잡도, 중복, 보안)
AI가 개선 제안 코멘트 작성
승인/거부 결정 (설정 가능한 임계값 기반)
Slack 알림

Step 1: Antigravity에서 프로젝트 초기화

Antigravity Manager:
New Task > "Create AI Code Review System"

Planning Mode: On
Model: Gemini 3 Pro

Prompt:
"GitHub PR 자동 리뷰 시스템을 만들어주세요.

기술 스택:
- Language: TypeScript
- Framework: Node.js + Express
- GitHub API: Octokit
- AI Model: Claude Opus 4.5 API
- Database: PostgreSQL
- Queue: Bull (Redis)
- Notifications: Slack API

구조:
1. GitHub Webhook을 받는 서버
2. PR 코드 분석 워커
3. Claude API로 리뷰 생성
4. GitHub에 코멘트 작성
5. Slack 알림 전송

보안:
- Webhook secret 검증
- GitHub token 암호화 저장
- Rate limiting
"

Gemini 3 Pro가 생성한 아키텍처 (요약):

┌─────────────────────────────────────────────────────────────┐
│                       System Architecture                    │
└─────────────────────────────────────────────────────────────┘

GitHub PR Created
      ↓
┌─────────────────┐
│ Webhook Server  │ (Express + TypeScript)
└────────┬────────┘
         │ Validate secret
         │ Parse payload
         ↓
┌─────────────────┐
│   Bull Queue    │ (Redis)
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│ Analysis Worker │
└────────┬────────┘
         │ 1. Fetch PR files (Octokit)
         │ 2. Run ESLint, SonarQube
         │ 3. Calculate complexity
         │ 4. Detect duplicates
         │
         ↓
┌─────────────────┐
│ Claude API Call │ (Opus 4.5)
└────────┬────────┘
         │ Generate review comments
         │
         ↓
┌─────────────────┐
│ GitHub API      │ (Post comments)
└────────┬────────┘
         │
         ↓
┌─────────────────┐
│   Slack API     │ (Send notification)
└─────────────────┘

Step 2: Claude Code로 구현

Antigravity 계획서를 Claude Code로 전달:

  
# Antigravity에서 export
agy export plan code-review-system --output ~/code-review-plan.md

# Claude Code 실행
cd ~/projects
claude init --name ai-code-review --plan ~/code-review-plan.md

Claude Code가 전체 프로젝트 구조를 생성:

ai-code-review/
├── src/
│   ├── server/
│   │   ├── index.ts           # Express server
│   │   ├── webhook.ts         # GitHub webhook handler
│   │   └── middleware/
│   │       ├── auth.ts        # Webhook secret validation
│   │       └── ratelimit.ts   # Rate limiting
│   ├── worker/
│   │   ├── index.ts           # Bull worker
│   │   ├── analyzer.ts        # Code analysis
│   │   └── reviewer.ts        # Claude API integration
│   ├── services/
│   │   ├── github.ts          # GitHub API client
│   │   ├── claude.ts          # Claude API client
│   │   └── slack.ts           # Slack API client
│   ├── models/
│   │   ├── Review.ts          # Review entity
│   │   └── PRMetadata.ts      # PR metadata
│   └── utils/
│       ├── complexity.ts      # Complexity calculation
│       ├── duplicates.ts      # Duplicate detection
│       └── logger.ts          # Logging
├── prisma/
│   └── schema.prisma          # Database schema
├── tests/
│   ├── webhook.test.ts
│   ├── analyzer.test.ts
│   └── reviewer.test.ts
├── .env.example
├── package.json
├── tsconfig.json
└── README.md

주요 코드 예시 (Claude가 생성):

src/worker/reviewer.ts:

  
import Anthropic from '@anthropic-ai/sdk';
import { logger } from '../utils/logger';

interface ReviewRequest {
  files: Array<{ filename: string; patch: string }>;
  prTitle: string;
  prDescription: string;
}

interface ReviewComment {
  path: string;
  position: number;
  body: string;
  severity: 'info' | 'warning' | 'error';
}

export class CodeReviewer {
  private client: Anthropic;

  constructor() {
    this.client = new Anthropic({
      apiKey: process.env.ANTHROPIC_API_KEY!,
    });
  }

  async reviewPR(request: ReviewRequest): Promise<ReviewComment[]> {
    const prompt = this.buildPrompt(request);
    
    logger.info('Requesting code review from Claude Opus 4.5');
    
    const response = await this.client.messages.create({
      model: 'claude-opus-4-5-20251101',
      max_tokens: 4096,
      temperature: 0.3,
      messages: [{
        role: 'user',
        content: prompt
      }]
    });

    const reviewText = response.content[0].type === 'text' 
      ? response.content[0].text 
      : '';

    return this.parseReview(reviewText, request.files);
  }

  private buildPrompt(request: ReviewRequest): string {
    const filesContext = request.files
      .map(f => `File: ${f.filename}\n\`\`\`diff\n${f.patch}\n\`\`\``)
      .join('\n\n');

    return `You are an expert code reviewer. Analyze this Pull Request and provide detailed feedback.

PR Title: ${request.prTitle}
PR Description: ${request.prDescription}

Changed Files:
${filesContext}

Instructions:
1. Identify potential bugs, security vulnerabilities, and performance issues
2. Suggest improvements for code readability and maintainability
3. Check for TypeScript type safety
4. Verify error handling
5. Look for code duplication

For each issue, provide:
- File path
- Line number (in the diff)
- Severity (info/warning/error)
- Description and suggested fix

Format your response as JSON:
{
  "comments": [
    {
      "path": "src/example.ts",
      "line": 10,
      "severity": "warning",
      "message": "...",
      "suggestion": "..."
    }
  ],
  "summary": "Overall assessment...",
  "approved": true/false
}`;
  }

  private parseReview(
    reviewText: string, 
    files: Array<{ filename: string; patch: string }>
  ): ReviewComment[] {
    try {
      // JSON 부분만 추출 (Claude가 추가 설명을 붙일 수 있으므로)
      const jsonMatch = reviewText.match(/\{[\s\S]*\}/);
      if (!jsonMatch) {
        throw new Error('No JSON found in response');
      }

      const parsed = JSON.parse(jsonMatch[0]);
      
      return parsed.comments.map(c => ({
        path: c.path,
        position: this.findDiffPosition(c.path, c.line, files),
        body: `**${c.severity.toUpperCase()}**: ${c.message}\n\n${c.suggestion}`,
        severity: c.severity
      }));

    } catch (error) {
      logger.error('Failed to parse review', error);
      return [{
        path: files[0]?.filename || 'unknown',
        position: 1,
        body: 'AI review parsing failed. Please check logs.',
        severity: 'error'
      }];
    }
  }

  private findDiffPosition(
    path: string, 
    line: number, 
    files: Array<{ filename: string; patch: string }>
  ): number {
    const file = files.find(f => f.filename === path);
    if (!file) return 1;

    // Diff 형식에서 실제 라인 번호를 position으로 변환
    const lines = file.patch.split('\n');
    let currentLine = 0;
    
    for (let i = 0; i < lines.length; i++) {
      const match = lines[i].match(/^@@ -\d+,\d+ \+(\d+),\d+ @@/);
      if (match) {
        currentLine = parseInt(match[1]);
      } else if (lines[i].startsWith('+')) {
        currentLine++;
        if (currentLine === line) return i;
      }
    }

    return 1; // 기본값
  }
}

Step 3: Antigravity로 통합 테스트

Antigravity Browser Agent를 사용한 E2E 테스트:

Test Plan: AI Code Review System

Test 1: Webhook Reception
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Create test PR in GitHub
2. Verify webhook POST to http://localhost:3000/webhook
3. Check database for new review record

Expected:
- HTTP 200 response
- Job added to Bull queue
- DB record created

Test 2: Code Analysis
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Submit PR with intentional issues:
   - Unused variable
   - Missing error handling
   - Complex function (cyclomatic complexity > 10)

Expected:
- ESLint detects unused variable
- Complexity calculator flags complex function
- Issues saved to database

Test 3: Claude Review Generation
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Trigger reviewer worker
2. Wait for Claude API response
3. Parse review comments

Expected:
- Claude identifies all 3 issues
- Provides specific suggestions
- Severity levels assigned correctly

Test 4: GitHub Comment Posting
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Worker posts comments to GitHub
2. Verify comments appear on PR

Browser Agent:
- Navigate to test PR
- Check for review comments
- Verify comment formatting

Expected:
- 3 comments posted
- Markdown formatted correctly
- Code suggestions included

Test 5: Slack Notification
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Worker sends Slack message
2. Verify message content

Expected:
- Message includes PR link
- Lists number of issues
- Shows approval status

실행 결과:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
All Tests Passed! (5/5)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Total Duration: 18.7s
Performance:
- Webhook → Queue: 34ms ✓
- Analysis: 2.1s ✓
- Claude Review: 8.3s ✓
- GitHub Comment: 1.2s ✓
- Slack Notification: 0.8s ✓

Issues: 0
Coverage: 94.2%

Ready for production? (y/n)

Step 4: 배포 및 모니터링

Claude Code로 배포 스크립트 생성:

claude task "Create Kubernetes deployment manifests for the code review system"

생성된 파일들:

k8s/
├── deployment.yaml
├── service.yaml
├── ingress.yaml
├── configmap.yaml
├── secret.yaml (template)
└── redis.yaml

k8s/deployment.yaml:

  
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-code-review
  labels:
    app: ai-code-review
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ai-code-review
  template:
    metadata:
      labels:
        app: ai-code-review
    spec:
      containers:
      - name: server
        image: your-registry/ai-code-review:latest
        ports:
        - containerPort: 3000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: ai-code-review-secrets
              key: database-url
        - name: ANTHROPIC_API_KEY
          valueFrom:
            secretKeyRef:
              name: ai-code-review-secrets
              key: anthropic-key
        - name: GITHUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: ai-code-review-secrets
              key: github-token
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

배포:

kubectl apply -f k8s/

고급 최적화 전략

1. 토큰 사용량 최소화

전략 1: 계획 단계와 실행 단계 분리

문제: Planning Mode에서 여러 차례 계획을 수정하다 보면 컨텍스트 윈도우가 금방 소진됩니다.

해결: 계획이 확정되면 즉시 “Clear and Accept”를 사용하여 새 세션 시작.

측정 가능한 효과:

이전: 평균 15만 토큰 사용 (계획 8만 + 실행 7만)
이후: 평균 9만 토큰 사용 (계획 8만 + 새 세션 실행 1만)
절감: 40%

전략 2: MCP 도구 검색 임계값 조정

10개 이상의 MCP 서버를 사용하는 경우:

  
{
  "mcpToolSearch": {
    "threshold": "3%"  // 기본값 10%에서 낮춤
  }
}

효과:

컨텍스트 절약: 약 35,000 토큰
응답 속도 향상: 평균 1.2초 단축

전략 3: Selective File Loading

모든 파일을 컨텍스트에 로드하지 말고 필요한 파일만:

  
claude --files "src/auth/**/*.ts" task "Refactor authentication logic"

vs.

  
claude --files "src/**/*" task "..."  # 모든 파일 - 비효율적

2. 모델 선택 최적화

작업 유형	최적 모델	이유
초기 아키텍처 설계	Gemini 3 Pro	장기 추론, 구조적 사고
CRUD API 작성	Gemini 3 Flash	빠르고 저렴, 패턴 기반
보안 크리티컬 코드	Claude Opus 4.5	높은 정확도, 보안 검증
리팩토링	Claude Sonnet 4.5	균형잡힌 성능과 비용
알고리즘 최적화	Gemini 3 Deep Think	수학적 추론
UI 컴포넌트	Gemini 3 Flash	빠른 프로토타이핑

실전 예시:

  
# 아키텍처 설계
agy chat --model gemini-3-pro "Design microservices architecture for ..."

# 계획서 export
agy export plan arch-design --output ~/plan.md

# 핵심 서비스 구현 (보안 중요)
claude execute --plan ~/plan.md --model opus --files "src/payment/**"

# 나머지 서비스 (일반 로직)
claude execute --plan ~/plan.md --model sonnet --files "src/!(payment)/**"

# UI 컴포넌트 생성
agy agent create ui-builder --model gemini-3-flash

3. 병렬 에이전트 활용

Antigravity의 강점은 여러 에이전트가 동시에 작업할 수 있다는 점입니다.

시나리오: Monorepo에서 3개 마이크로서비스 개발

프로젝트 구조:
monorepo/
├── services/
│   ├── auth/
│   ├── payment/
│   └── notification/

전통적 방식 (순차):

Auth 서비스 개발 (3시간)
Payment 서비스 개발 (4시간)
Notification 서비스 개발 (2시간) 총 9시간

병렬 에이전트 방식:

Antigravity Manager:

Agent 1 (Claude Opus): Auth Service
└─ 예상 시간: 3시간

Agent 2 (Claude Opus): Payment Service  
└─ 예상 시간: 4시간

Agent 3 (Gemini Flash): Notification Service
└─ 예상 시간: 2시간

총 소요 시간: 4시간 (가장 긴 작업 기준)
절감: 55%

주의사항:

공유 의존성이 있는 경우 순서 지정 필요
각 에이전트가 독립적인 컨텍스트를 가지므로 중복 작업 가능성
정기적으로 통합 테스트 실행하여 호환성 확인

4. 캐싱 전략

Claude Code의 prompt caching 활용:

  
{
  "promptCaching": {
    "enabled": true,
    "strategy": "aggressive",
    "ttl": 3600  // 1시간
  }
}

효과:

동일한 파일/코드베이스에 대한 반복 작업 시 90% 토큰 절감
예: 같은 API 엔드포인트를 여러 번 수정하는 경우

측정 예:

첫 번째 요청:
Input tokens: 45,000
Cached: 0
Cost: $0.90

두 번째 요청 (캐싱 적용):
Input tokens: 5,000
Cached: 40,000
Cost: $0.14

절감: 84%

트러블슈팅 및 베스트 프랙티스

일반적인 문제들

문제 1: “Context Window Exceeded” 오류

증상:

Error: Context window exceeded (210,451 tokens > 200,000 limit)

원인:

너무 많은 파일을 컨텍스트에 로드
MCP 도구 설명이 과도하게 많음
긴 대화 히스토리

해결책:

파일 필터링:

  
claude --files "src/auth/*.ts,src/models/User.ts" task "..."

MCP 자동 검색 활성화:

  
export ENABLE_TOOL_SEARCH=true
export CLAUDE_MCP_TOOL_SEARCH_THRESHOLD=5

새 세션 시작:

claude new-session --import-plan previous-plan.md

문제 2: Antigravity 에이전트가 무한 루프에 빠짐

증상: Agent가 같은 작업을 반복해서 시도하며 진행되지 않음

원인:

모호한 종료 조건
테스트 실패를 무시하고 계속 실행
순환 의존성

해결책:

명확한 성공 기준 설정:

Task: "Implement login API"
   
Success Criteria:
- POST /api/auth/login endpoint created
- Returns JWT token on valid credentials
- Returns 401 on invalid credentials
- Integration test passes
- Manual test in browser succeeds

최대 시도 횟수 제한:

  
{
  "agent": {
    "maxRetries": 3,
    "retryDelay": 5000
  }
}

에이전트 일시 중지 후 수동 개입:

Antigravity Manager > Agent #2 > Pause
[수동으로 문제 해결]
Antigravity Manager > Agent #2 > Resume

문제 3: Claude Code와 Antigravity 사이 파일 동기화 문제

증상: Claude Code가 수정한 파일을 Antigravity가 인식하지 못하거나, 그 반대

원인:

파일 시스템 감시(watch) 설정 불일치
Git 상태 불일치

해결책:

명시적 파일 새로고침:

  
# Antigravity
agy refresh
   
# Claude Code
claude sync

Git을 중간 레이어로 사용:

  
# Claude Code 작업 후
git add .
git commit -m "WIP: Claude changes"
   
# Antigravity에서
git pull
# 이제 변경사항 인식됨

공유 워크스페이스 설정:

  
// Antigravity settings
{
  "workspace": "/Users/dev/project"
}
   
// Claude Code settings
{
  "workspaceRoot": "/Users/dev/project"
}

베스트 프랙티스

1. 버전 관리 전략

항상 Git 브랜치 사용:

  
# 에이전트 작업 전
git checkout -b agent/feature-xyz

# 에이전트 작업 후
git add .
git commit -m "feat: AI-generated feature XYZ

Generated by: Claude Code 2.1
Plan: task-42-auth-system.md
Review: pending"

git push origin agent/feature-xyz

# GitHub PR 생성하여 인간 검토

이점:

에이전트 변경사항 추적
문제 발생 시 쉬운 롤백
코드 리뷰 프로세스 통합

2. 계획서 아카이빙

모든 계획서를 버전 관리에 포함:

docs/
├── plans/
│   ├── 2026-01/
│   │   ├── 20-auth-system.md
│   │   ├── 21-payment-integration.md
│   │   └── 22-notification-service.md
│   └── archive/
│       └── 2025-12/

Git에 커밋:

git add docs/plans/
git commit -m "docs: Add implementation plans for January 2026"

이점:

의사결정 과정 문서화
팀원 온보딩에 유용
AI 에이전트 간 지식 공유

3. 테스트 우선 개발

에이전트에게 테스트를 먼저 작성하도록 지시:

claude task "Write integration tests for auth API, then implement the API to pass those tests"

vs.

claude task "Implement auth API"  # 테스트 없이 구현 - 위험

4. 점진적 검토

대규모 변경사항을 한 번에 승인하지 말고 단계별로:

Task: Refactor entire codebase to TypeScript

❌ 나쁜 방법:
Claude: "Refactor all 150 files to TypeScript"
[150개 파일 수정]
Developer: "Approve all"  # 검토 불가능

✅ 좋은 방법:
Claude: "Phase 1: Refactor models/ directory (15 files)"
Developer: [15개 파일 검토] "Approve"
Claude: "Phase 2: Refactor controllers/ (23 files)"
Developer: [검토] "Approve"
...

5. 컨텍스트 재사용

관련 작업들을 하나의 세션에서:

  
# 효율적
claude session start --name "auth-feature"
claude task "Implement login"
claude task "Add password reset"
claude task "Implement 2FA"
# 세 작업이 같은 컨텍스트 공유 (user model, auth logic 등)

# 비효율적
claude task "Implement login"
[새 세션]
claude task "Add password reset"  # user model 등을 다시 로드

6. 프롬프트 엔지니어링

명확하고 구체적인 지시:

❌ 나쁜 예:
"데이터베이스 쿼리 최적화해줘"

✅ 좋은 예:
"users 테이블에서 활성 사용자를 조회하는 쿼리를 최적화해주세요.
현재:
SELECT * FROM users WHERE status = 'active'

요구사항:
1. 필요한 컬럼만 SELECT (id, name, email)
2. email 컬럼에 인덱스 추가 제안
3. EXPLAIN ANALYZE 결과 포함
4. 10만 레코드 기준 성능 테스트
5. 기존 대비 개선율 측정"

컨텍스트 제공:

"src/payment/stripe.ts 파일의 handleWebhook 함수를 리팩토링해주세요.

현재 문제:
- 함수가 200줄로 너무 김
- 에러 처리 누락
- 테스트하기 어려움

목표:
- 각 웹훅 타입별로 별도 핸들러 함수 분리
- 모든 외부 API 호출에 try-catch 추가
- 각 핸들러에 대한 단위 테스트 작성

참고:
- 프로젝트의 코딩 스타일: docs/STYLE_GUIDE.md
- Stripe 웹훅 타입 목록: docs/STRIPE_WEBHOOKS.md"

부록: 설정 파일 및 스크립트 예제

A. Claude Code 설정 파일 전체 예제

~/.claude/settings.json:

  
{
  "api": {
    "baseURL": "https://api.anthropic.com",
    "defaultModel": "claude-sonnet-4-5-20250929",
    "timeout": 60000
  },
  "plansDirectory": "${workspaceFolder}/.claude/plans",
  "planFileNaming": {
    "pattern": "plan-{date}-{slug}.md",
    "dateFormat": "YYYY-MM-DD",
    "slugSource": "title"
  },
  "mcpToolSearch": {
    "enabled": "auto",
    "threshold": "5%",
    "strategy": "semantic"
  },
  "promptCaching": {
    "enabled": true,
    "strategy": "aggressive",
    "ttl": 3600
  },
  "hooks": {
    "init": {
      "command": "bash",
      "args": ["${workspaceFolder}/.claude/init.sh"]
    },
    "maintenance": {
      "command": "bash",
      "args": ["${workspaceFolder}/.claude/maintenance.sh"],
      "schedule": "0 2 * * 0"
    },
    "prePlanApproval": {
      "command": "python3",
      "args": ["${workspaceFolder}/.claude/hooks/archive-plan.py", "${planFile}"]
    },
    "preToolUse": {
      "command": "bash",
      "args": ["${workspaceFolder}/.claude/hooks/security-check.sh", "${toolName}"],
      "injectContext": true
    }
  },
  "statusBar": {
    "show": true,
    "format": "{model} | Ctx: {context}/{contextLimit} ({contextPercent}%) | {gitBranch}",
    "updateInterval": 2000
  },
  "diffView": {
    "enabled": true,
    "autoOpen": true,
    "mode": "side-by-side"
  },
  "filePatterns": {
    "include": [
      "src/**/*.{ts,tsx,js,jsx}",
      "tests/**/*.test.ts",
      "*.md"
    ],
    "exclude": [
      "node_modules/**",
      "dist/**",
      "build/**",
      "*.log"
    ]
  },
  "agent": {
    "maxRetries": 3,
    "retryDelay": 5000,
    "parallelTasks": 2
  }
}

B. Antigravity 설정 예제

~/.antigravity/config.json:

  
{
  "workspace": {
    "default": "/Users/dev/projects",
    "recent": [
      "/Users/dev/projects/ecommerce",
      "/Users/dev/projects/ai-review"
    ]
  },
  "agents": {
    "maxConcurrent": 4,
    "defaultModel": "gemini-3-pro-preview",
    "taskTimeout": 3600000,
    "autoRetry": true
  },
  "browser": {
    "headless": false,
    "width": 1920,
    "height": 1080,
    "recordVideo": true,
    "recordingPath": "${workspace}/.antigravity/recordings"
  },
  "security": {
    "allowList": [
      "localhost",
      "*.google.com",
      "*.github.com",
      "*.anthropic.com"
    ],
    "denyList": [
      "*.malicious.com"
    ],
    "terminalExecution": "review"
  },
  "notifications": {
    "slack": {
      "enabled": true,
      "webhook": "${env:SLACK_WEBHOOK_URL}",
      "channel": "#dev-notifications"
    },
    "email": {
      "enabled": false
    }
  }
}

C. 프로젝트별 Claude 설정

.claude/project.json:

  
{
  "name": "E-Commerce Platform",
  "description": "Microservices-based e-commerce system",
  "techStack": [
    "TypeScript",
    "Node.js",
    "React",
    "PostgreSQL",
    "Redis",
    "Docker",
    "Kubernetes"
  ],
  "codingStandards": {
    "style": "Airbnb",
    "linter": "ESLint",
    "formatter": "Prettier",
    "typeChecker": "TypeScript strict mode"
  },
  "mcpServers": [
    {
      "name": "github",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${env:GITHUB_TOKEN}"
      }
    },
    {
      "name": "postgres",
      "command": "docker",
      "args": ["run", "--rm", "mcp-postgres"],
      "env": {
        "DATABASE_URL": "${env:DATABASE_URL}"
      }
    },
    {
      "name": "slack",
      "command": "npx",
      "args": ["-y", "mcp-slack"],
      "env": {
        "SLACK_TOKEN": "${env:SLACK_TOKEN}"
      }
    }
  ],
  "customInstructions": [
    "Always write unit tests for business logic",
    "Use repository pattern for database access",
    "Follow SOLID principles",
    "Add JSDoc comments for public APIs",
    "Use conventional commits format"
  ]
}

D. 유용한 셸 스크립트

.claude/hooks/security-check.sh (위험한 도구 사용 전 확인):

  
#!/bin/bash

TOOL_NAME=$1

# 위험한 도구 목록
DANGEROUS_TOOLS=(
  "bash_execute"
  "file_delete"
  "database_drop"
  "npm_publish"
  "docker_rm"
)

# 위험한 도구인지 확인
for tool in "${DANGEROUS_TOOLS[@]}"; do
  if [[ "$TOOL_NAME" == "$tool" ]]; then
    echo "⚠️  위험: '$TOOL_NAME' 도구를 사용하려고 합니다."
    echo ""
    echo "추가 컨텍스트:"
    echo "- 프로덕션 환경에서 실행 중입니다"
    echo "- 이 작업은 되돌릴 수 없습니다"
    echo "- 반드시 백업을 확인하세요"
    echo ""
    echo "계속 진행하려면 'CONFIRM'을 입력하세요:"
    read confirmation
    
    if [[ "$confirmation" != "CONFIRM" ]]; then
      echo '{"success": false, "message": "사용자가 위험한 작업을 거부했습니다"}'
      exit 1
    fi
  fi
done

echo '{"success": true}'

.claude/init.sh (프로젝트 초기화):

  
#!/bin/bash
set -e

echo "🚀 프로젝트 초기화 시작..."

# 환경 확인
check_command() {
  if ! command -v $1 &> /dev/null; then
    echo "❌ $1이 설치되어 있지 않습니다"
    exit 1
  fi
}

check_command node
check_command docker
check_command git

# Node.js 버전 확인
required_version="18.0.0"
current_version=$(node -v | cut -d'v' -f2)

if [ "$(printf '%s\n' "$required_version" "$current_version" | sort -V | head -n1)" != "$required_version" ]; then
  echo "❌ Node.js 18.0.0 이상이 필요합니다 (현재: $current_version)"
  exit 1
fi

# .env 파일 생성
if [ ! -f .env ]; then
  echo "📝 .env 파일 생성..."
  cp .env.example .env
  echo "⚠️  .env 파일을 열어 환경 변수를 설정하세요"
fi

# 의존성 설치
echo "📦 의존성 설치..."
npm ci

# 데이터베이스 설정
echo "🗄️  데이터베이스 초기화..."
docker-compose up -d postgres redis
sleep 5

# 마이그레이션
npx prisma migrate deploy
npx prisma db seed

# 빌드 테스트
echo "🔨 빌드 테스트..."
npm run build

# 테스트 실행
echo "🧪 테스트 실행..."
npm test

echo "✅ 초기화 완료!"
echo ""
echo "다음 명령으로 개발 서버를 시작하세요:"
echo "  npm run dev"

.claude/maintenance.sh (정기 유지보수):

  
#!/bin/bash

echo "🔧 유지보수 작업 시작 ($(date))"

# 코드 포맷팅
echo "✨ 코드 포맷팅..."
npx prettier --write "src/**/*.{ts,tsx,js,jsx,json,css,md}" --log-level warn

# Linting
echo "🔍 Lint 검사..."
npx eslint "src/**/*.{ts,tsx,js,jsx}" --fix --quiet

# 타입 체크
echo "🎯 타입 체크..."
npx tsc --noEmit

# 의존성 감사
echo "🔒 보안 취약점 검사..."
npm audit --audit-level=moderate --json > /tmp/audit.json

vulnerabilities=$(jq '.metadata.vulnerabilities | to_entries | map(select(.value > 0)) | length' /tmp/audit.json)

if [ "$vulnerabilities" -gt 0 ]; then
  echo "⚠️  발견된 취약점: $vulnerabilities개"
  npm audit fix --dry-run
fi

# 사용하지 않는 의존성
echo "🧹 미사용 의존성 검사..."
npx depcheck --json > /tmp/depcheck.json

unused=$(jq '.dependencies | length' /tmp/depcheck.json)
if [ "$unused" -gt 0 ]; then
  echo "⚠️  사용하지 않는 패키지: $unused개"
  jq '.dependencies' /tmp/depcheck.json
fi

# 테스트 커버리지
echo "📊 테스트 커버리지..."
npm run test:coverage -- --silent

coverage=$(grep -oP 'All files.*?\|\s+\K[\d.]+' coverage/coverage-summary.json | jq -s 'add/length')
echo "현재 커버리지: ${coverage}%"

if (( $(echo "$coverage < 80" | bc -l) )); then
  echo "⚠️  커버리지 목표 미달 (목표: 80%)"
fi

# 번들 크기 분석
echo "📦 번들 크기 분석..."
npm run build -- --analyze > /tmp/bundle.txt
main_size=$(grep "main" /tmp/bundle.txt | awk '{print $2}')
echo "메인 번들 크기: $main_size"

echo "✅ 유지보수 완료 ($(date))"

# Slack 알림 (선택사항)
if [ -n "$SLACK_WEBHOOK" ]; then
  curl -X POST "$SLACK_WEBHOOK" \
    -H 'Content-Type: application/json' \
    -d "{
      \"text\": \"유지보수 완료\",
      \"attachments\": [{
        \"color\": \"good\",
        \"fields\": [
          {\"title\": \"커버리지\", \"value\": \"${coverage}%\", \"short\": true},
          {\"title\": \"취약점\", \"value\": \"${vulnerabilities}개\", \"short\": true}
        ]
      }]
    }"
fi

마무리

이 가이드는 Claude Code 2.1과 Google Antigravity를 활용한 AI 개발의 실전 지식을 담고 있습니다. 핵심 요점을 정리하면:

1. 역할 분담이 핵심입니다

Antigravity (Gemini): 계획과 구조 설계
Claude Code (Opus/Sonnet): 실제 코드 작성
Antigravity Browser: 자동 테스트

2. 컨텍스트 관리가 성공의 열쇠입니다

계획과 실행을 분리하여 토큰 절약
MCP 도구 검색으로 효율성 극대화
적절한 모델 선택으로 비용 최적화

3. 자동화가 생산성을 배가시킵니다

Hooks를 활용한 워크플로우 자동화
테스트 우선 접근으로 품질 보장
Git 통합으로 버전 관리 체계화

4. 점진적 접근이 안전합니다

작은 작업부터 시작
단계별 검토와 승인
항상 롤백 가능한 상태 유지

다음 단계:

간단한 프로젝트로 시작 (TODO 앱, 계산기 등)
설정 파일 커스터마이징
Hook 스크립트 작성
실제 프로젝트에 적용
팀과 베스트 프랙티스 공유

AI 코딩의 미래는 이미 여기에 있습니다. 중요한 것은 이 도구들을 어떻게 활용하느냐입니다. 이 가이드가 여러분의 개발 생산성을 획기적으로 향상시키는 데 도움이 되기를 바랍니다.

Happy Coding with AI! 🚀

작성일자: 2026-01-20

AI, Claude Code & Google Antigravity

AI claude-code Antigravity Developer Guide Claude.write

AI 코딩의 새로운 패러다임: 멀티 에이전트 개발 워크플로우

관련영상

목차

개요

왜 이 조합이 혁명적인가?

Claude Code 2.1 혁명적 업데이트

1. 플래닝 모드의 진화: 협업 가능한 계획서 생성

1.1 계획서 저장 위치 커스터마이징

1.2 컨텍스트 윈도우 관리 혁신: “Clear and Accept”

1.3 PreTools Hook을 활용한 자동화 워크플로우

2. MCP 도구 검색 자동화: 토큰 효율성 극대화

2.1 문제 상황

2.2 자동 MCP 도구 검색 솔루션

3. 초기화 및 유지보수 모드: 프로젝트 생명주기 자동화

3.1 Init 모드: 신규 개발자 온보딩 자동화

3.2 Maintenance 모드: 주기적 품질 관리 자동화

4. UI/UX 개선: 생산성 향상을 위한 미세 조정

4.1 승인 시 추가 지침 전달 (Tab 키)

4.2 Diff View: 변경사항 시각적 검토

4.3 상태 표시줄: 실시간 리소스 모니터링

Google Antigravity 완전 분석

1. Antigravity란 무엇인가?

2. 아키텍처: 3개의 Surface

2.1 Editor Surface

2.2 Manager Surface (핵심 혁신)

2.3 Browser Surface (혁신적 통합)

3. 모델 선택의 유연성

4. 가격 정책 및 쿼터

Claude Code + Antigravity 통합 워크플로우

1. 기본 통합 방법

방법 1: Antigravity 내부에서 Claude Code 실행 (권장)

방법 2: antigravity-claude-proxy 사용 (고급)

2. 3단계 하이브리드 워크플로우

Phase 1: Planning (Antigravity + Gemini 3 Pro)

Phase 2: Implementation (Claude Code + Claude Opus 4.5)

Phase 3: Testing (Antigravity Browser + Test Agents)

실전 프로젝트 구현 가이드

프로젝트: AI 기반 코드 리뷰 자동화 시스템

Step 1: Antigravity에서 프로젝트 초기화

Step 2: Claude Code로 구현

Step 3: Antigravity로 통합 테스트

Step 4: 배포 및 모니터링

고급 최적화 전략

1. 토큰 사용량 최소화

전략 1: 계획 단계와 실행 단계 분리

전략 2: MCP 도구 검색 임계값 조정

전략 3: Selective File Loading

2. 모델 선택 최적화

3. 병렬 에이전트 활용

4. 캐싱 전략

트러블슈팅 및 베스트 프랙티스

일반적인 문제들

문제 1: “Context Window Exceeded” 오류

문제 2: Antigravity 에이전트가 무한 루프에 빠짐

문제 3: Claude Code와 Antigravity 사이 파일 동기화 문제

베스트 프랙티스

1. 버전 관리 전략

2. 계획서 아카이빙

3. 테스트 우선 개발

4. 점진적 검토

5. 컨텍스트 재사용

6. 프롬프트 엔지니어링

부록: 설정 파일 및 스크립트 예제

A. Claude Code 설정 파일 전체 예제

B. Antigravity 설정 예제

C. 프로젝트별 Claude 설정

D. 유용한 셸 스크립트

마무리

인기 태그