Andrej Karpathy가 말하는 Claude 코딩 경험: 에이전트 코딩이 대세가 된 이유 Andrej Karpathy on Claude Coding: Why Agent-Based Coding Is Now Dominant

Andrej Karpathy의 Claude 코딩 경험이 말해주는 것: 에이전트 코딩 시대의 도래

Andrej Karpathy가 코딩 워크플로우에서 에이전트 비율을 20%에서 80%로 뒤집었다. 단 한 달 만에. Tesla AI 디렉터 출신이자 OpenAI 공동창업자인 그가 이런 급격한 전환을 했다는 건, 단순한 개인 취향 변화가 아니다. 개발 패러다임 자체가 바뀌고 있다는 신호다.

에이전트 코딩이란 무엇인가

전통적인 AI 코딩 도구(Copilot, TabNine 등)는 기본적으로 “자동완성”이다. 당신이 타이핑하면, AI가 다음 줄을 예측한다. 수동적이고, 당신이 방향을 정해야 한다.

에이전트 코딩은 다르다. 당신이 목표를 설명하면, AI가 스스로 계획을 세우고, 코드를 작성하고, 테스트하고, 오류를 수정한다. Claude Code나 Cursor의 에이전트 모드가 대표적이다.

# 자동완성 방식: 당신이 한 줄씩 쓰고, AI가 제안
def calculate_tax(income):
    # AI: "return income * 0.3" 제안
    
# 에이전트 방식: 당신이 의도를 설명
# "한국 소득세법에 맞는 누진세 계산 함수를 만들어줘.
#  테스트 케이스도 포함해서."

# AI가 알아서 생성:
def calculate_korean_income_tax(income: int) -> int:
    """
    2024년 기준 한국 소득세 계산
    """
    brackets = [
        (12_000_000, 0.06),
        (46_000_000, 0.15),
        (88_000_000, 0.24),
        (150_000_000, 0.35),
        (300_000_000, 0.38),
        (500_000_000, 0.40),
        (1_000_000_000, 0.42),
        (float('inf'), 0.45),
    ]
    # ... 구현 + 테스트 코드까지

핵심 차이는 자율성이다. 에이전트는 컨텍스트를 유지하면서 여러 파일을 오가고, 빌드 에러를 읽고, 스스로 수정한다.

왜 80%까지 올라갔나: 실용적 분석

Karpathy가 언급한 핵심 변화는 “컨텍스트 윈도우 확장”과 “도구 사용 능력”이다.

컨텍스트의 힘

# 예전: 한 파일 내 100줄 정도만 맥락 파악
# 지금: 프로젝트 전체 구조 + 의존성 + 테스트 파일까지 파악

# Claude Code 예시
claude "src/ 디렉토리의 API 엔드포인트 중 
       인증 누락된 부분 찾아서 미들웨어 추가해줘"

이게 가능해진 이유는 단순하다. Claude 3.5 Sonnet 이후로 200K 토큰 컨텍스트가 실용화됐고, 도구 호출(tool use)이 안정화됐다. 파일을 읽고, 명령어를 실행하고, 결과를 해석하는 루프가 신뢰할 수 있는 수준이 됐다.

에이전트가 잘하는 것과 못하는 것

잘하는 작업:

• 보일러플레이트 코드 생성
• 기존 패턴을 따르는 새 기능 추가
• 테스트 코드 작성
• 리팩토링 (특히 이름 변경, 파일 분리)
• 문서화

아직 못하는 작업:

• 아키텍처 결정 (이건 당신이 해야 함)
• 성능 최적화의 미묘한 트레이드오프
• 도메인 특화 비즈니스 로직의 정확한 구현
• 레거시 코드의 숨겨진 의도 파악

# 에이전트에게 맡기면 좋은 예
# "User 모델에 email_verified 필드 추가하고, 
#  마이그레이션이랑 관련 테스트 업데이트해줘"

# 직접 해야 하는 예
# "우리 결제 시스템이 동시성 문제가 있는 것 같은데,
#  어디서 race condition이 생길 수 있는지 분석해줘"
# → 이건 에이전트 결과를 참고만 하고, 직접 검증해야

실전 워크플로우: 어떻게 80%를 달성하나

솔직히 말하면, 아무 작업이나 에이전트에게 던지면 80%가 되지 않는다. 전략이 필요하다.

1. 작업을 분해하라

# 나쁜 예
claude "전체 인증 시스템을 OAuth2로 바꿔줘"

# 좋은 예
claude "1. 현재 auth/ 디렉토리 구조 분석해줘"
# 결과 확인 후
claude "2. OAuth2 토큰 검증 미들웨어 만들어줘"
# 결과 확인 후
claude "3. 기존 세션 방식과 병행 가능하게 해줘"

2. 맥락을 제공하라

에이전트는 당신의 코드베이스를 처음 보는 것과 같다. 관련 파일을 명시적으로 알려주면 정확도가 급상승한다.

claude "src/api/users.py와 tests/test_users.py를 참고해서
       동일한 패턴으로 src/api/orders.py 만들어줘"

3. 결과를 검증하라

에이전트가 80%를 처리한다는 건, 당신이 20%의 검토/수정을 한다는 뜻이다. 이 20%가 핵심이다.

# 생성된 코드 리뷰 체크리스트
- [ ] 의도한 대로 동작하는가? (직접 실행)
- [ ] 엣지 케이스 처리는? 
- [ ] 보안 취약점은 없는가?
- [ ] 기존 코드 스타일과 일관성 있는가?

주의해야 할 함정들

과신의 문제

에이전트가 자신감 있게 틀린 코드를 생성할 때가 있다. 특히 최신 라이브러리 버전이나 마이너한 API는 환각(hallucination)이 발생한다.

# AI가 생성한 코드 (실제로는 존재하지 않는 API)
import some_library
result = some_library.magic_function()  # 이런 함수 없음

# 반드시 확인
pip show some_library  # 버전 확인
# 공식 문서에서 API 존재 여부 검증

컨텍스트 오염

긴 대화에서 에이전트가 이전 지시와 현재 지시를 혼동하기도 한다. 새로운 작업은 새 세션에서 시작하는 게 안전하다.

의존성 문제

에이전트가 편의상 새 패키지를 추가하는 경우가 있다. requirements.txt나 package.json 변경사항은 꼭 확인하라.

결론: 패러다임 전환을 받아들여라

Karpathy의 80% 에이전트 코딩은 과장이 아니다. 실제로 반복적이고 패턴화된 작업의 대부분을 AI가 처리할 수 있는 시점에 도달했다.

하지만 이건 개발자가 필요 없어진다는 뜻이 아니다. 오히려 반대다. 아키텍처 설계, 요구사항 분석, 코드 리뷰, 장애 대응—이런 고차원 작업에 더 많은 시간을 쓸 수 있게 됐다는 뜻이다.

내 개인적인 견해: 에이전트 코딩을 거부하는 건 2010년대에 IDE 자동완성을 거부하는 것과 같다. 도구를 마스터하는 개발자와 거부하는 개발자의 생산성 격차는 앞으로 더 벌어질 것이다.

다만, 한 가지 명심하라. 에이전트가 작성한 코드의 책임은 여전히 당신에게 있다. “AI가 그렇게 했어요”는 프로덕션 장애 보고서에서 받아들여지지 않는다.

What Andrej Karpathy’s Claude Coding Experience Tells Us: The Age of Agentic Coding

Andrej Karpathy flipped his coding workflow from 20% to 80% agent-based. In just one month. When the former Tesla AI Director and OpenAI co-founder makes such a drastic shift, it’s not just personal preference—it’s a signal that the development paradigm itself is changing.

What Is Agentic Coding

Traditional AI coding tools (Copilot, TabNine, etc.) are essentially “autocomplete.” You type, AI predicts the next line. It’s passive, and you set the direction.

Agentic coding is different. You describe the goal, and the AI plans, writes code, tests, and fixes errors autonomously. Claude Code and Cursor’s agent mode are prime examples.

# Autocomplete approach: you write line by line, AI suggests
def calculate_tax(income):
    # AI: suggests "return income * 0.3"
    
# Agentic approach: you describe intent
# "Create a progressive tax calculation function following 
#  Korean income tax law. Include test cases."

# AI generates autonomously:
def calculate_korean_income_tax(income: int) -> int:
    """
    Korean income tax calculation based on 2024 brackets
    """
    brackets = [
        (12_000_000, 0.06),
        (46_000_000, 0.15),
        (88_000_000, 0.24),
        (150_000_000, 0.35),
        (300_000_000, 0.38),
        (500_000_000, 0.40),
        (1_000_000_000, 0.42),
        (float('inf'), 0.45),
    ]
    # ... implementation + test code included

The key difference is autonomy. Agents maintain context while navigating multiple files, reading build errors, and self-correcting.

Why It Jumped to 80%: A Practical Analysis

The core changes Karpathy mentioned are “context window expansion” and “tool use capability.”

The Power of Context

# Before: ~100 lines of context within a single file
# Now: entire project structure + dependencies + test files

# Claude Code example
claude "Find API endpoints in src/ directory missing 
       authentication and add middleware"

Why this became possible is simple. Since Claude 3.5 Sonnet, 200K token context became practical, and tool calling stabilized. The loop of reading files, executing commands, and interpreting results reached a reliable level.

What Agents Do Well and Don’t

Good at:

• Boilerplate code generation
• Adding new features following existing patterns
• Writing test code
• Refactoring (especially renaming, file splitting)
• Documentation

Still struggling with:

• Architecture decisions (that’s your job)
• Subtle tradeoffs in performance optimization
• Accurate implementation of domain-specific business logic
• Understanding hidden intent in legacy code

# Good task for agents
# "Add email_verified field to User model,
#  update migrations and related tests"

# Do it yourself
# "Our payment system seems to have concurrency issues,
#  analyze where race conditions might occur"
# → Use agent results as reference only, verify yourself

Real-World Workflow: How to Actually Hit 80%

Let’s be honest—you don’t hit 80% by throwing any task at an agent. You need strategy.

1. Decompose Your Tasks

# Bad example
claude "Convert the entire auth system to OAuth2"

# Good example
claude "1. Analyze current auth/ directory structure"
# Review results
claude "2. Create OAuth2 token validation middleware"
# Review results
claude "3. Make it work alongside existing session auth"

2. Provide Context

The agent is seeing your codebase for the first time. Explicitly pointing to relevant files dramatically improves accuracy.

claude "Reference src/api/users.py and tests/test_users.py,
       create src/api/orders.py following the same pattern"

3. Validate Results

Agent handling 80% means you’re doing 20% review/fixes. That 20% is crucial.

# Generated code review checklist
- [ ] Does it work as intended? (actually run it)
- [ ] Edge case handling?
- [ ] Security vulnerabilities?
- [ ] Consistent with existing code style?

Pitfalls to Watch For

The Overconfidence Problem

Agents sometimes generate incorrect code with complete confidence. Especially with latest library versions or minor APIs, hallucinations occur.

# AI-generated code (API doesn't actually exist)
import some_library
result = some_library.magic_function()  # No such function

# Always verify
pip show some_library  # Check version
# Verify API existence in official docs

Context Pollution

In long conversations, agents may confuse previous instructions with current ones. Starting new tasks in fresh sessions is safer.

Dependency Creep

Agents sometimes add new packages for convenience. Always check requirements.txt or package.json changes.

Conclusion: Embrace the Paradigm Shift

Karpathy’s 80% agentic coding isn’t hyperbole. We’ve genuinely reached a point where AI can handle most repetitive, pattern-based tasks.

But this doesn’t mean developers become obsolete. Quite the opposite. Architecture design, requirements analysis, code review, incident response—you now have more time for these higher-order tasks.

My personal take: refusing agentic coding is like refusing IDE autocomplete in the 2010s. The productivity gap between developers who master these tools and those who don’t will only widen.

However, remember one thing. You’re still responsible for code the agent writes. “The AI did it” won’t fly in a production incident report.