Claude 4 고급 AI 코딩: Git Worktrees로 Claude 코드 병렬 실행하기

IndyDevDan 구독자 43,800명

요약

이 영상에서는 Claude 4 Opus와 Sonnet 모델 출시와 함께 Cloud Code가 정식 공개된 계기를 소개하며, Git worktrees를 활용해 여러 AI 에이전트를 병렬 실행해 코드베이스의 다양한 미래 버전을 동시에 생성하는 방법을 다룹니다. 계획(spec) 기반 프롬프트로 작업 사양을 명확히 정의한 뒤, 각 에이전트가 독립된 작업 영역에서 동시에 기능을 구현하도록 구성합니다. 비결정성 모델의 특성을 활용해 실패 위험을 분산하고, 최적 버전을 메인 브랜치에 병합해 고품질 결과물을 확보하는 워크플로우가 핵심입니다.

주요 키워드

agentic coding(에이전트 코딩) Git worktrees Cloud Code AI Developer Workflows(ADW) Claude 4 Opus Sonnet 4 병렬 워크플로우 계획 기반 코딩

하이라이트

🔑 Cloud Code의 일반 출시로 Opus 4와 Sonnet 4 모델을 코드베이스에 바로 적용 가능하게 되었음.
⚡️ Git Worktrees를 이용해 코드베이스를 복제하고 여러 에이전트를 병렬로 실행해 다양한 코드 미래를 탐색함.
🌟 계획 기반 프롬프트로 명확한 작업 사양(spec)을 작성한 뒤, 각 에이전트에게 일관되게 전달함.
🚀 병렬 워크플로우로 모델 비결정성(nondeterminism)을 활용, 실패 위험을 헷지하고 최적 결과를 선택함.
📌 UI 리팩토링 예시에서 세 가지 버전을 생성·비교, 실시간으로 스타일과 사용자 경험을 손쉽게 검증함.
🔄 최종적으로 가장 우수한 버전을 메인 브랜치에 머지(merge)해 즉시 배포 가능한 완성도 높은 코드를 확보함.
💡 이 기법은 애매한 요구사항, 높은 실패 가능성 작업, 다수 대안이 허용되는 UI 작업에 특히 효과적임.
📈 장기 실행되는 대규모 AI 코딩 작업에서 여러 에이전트를 활용해 작업 속도와 품질을 동시에 향상시킴.

용어 설명

agentic coding (에이전트 코딩)

독립적 AI 에이전트가 계획을 바탕으로 코드 작성·수정·배포까지 자동으로 수행하는 개발 워크플로우

Git worktrees

단일 저장소에서 여러 작업 디렉터리를 생성해 각각 별도 브랜치에서 병렬 작업을 가능하게 하는 Git 기능

AI Developer Workflows (ADW)

AI 에이전트를 활용해 소프트웨어 개발 전 과정을 자동화·조율하는 일련의 워크플로우

Cloud Code

Claude 모델과 연동해 코드 명령을 실행하고 파일 시스템·버전 관리까지 자동으로 처리하는 에이전트 코딩 툴

nondeterministic probabilistic machines

동일 입력에도 매번 다른 출력을 생성하는 확률 기반 언어 모델의 특성

Claude 4 Opus & Sonnet

Anthropic에서 발표한 새로운 고성능 언어 모델 시리즈

Claude 4 Opus와 Sonnet 모델이 공개되고, Cloud Code가 정식으로 일반 제공(GA)됨을 알립니다. 이를 통해 대규모 에이전트 코딩 툴에 본격 투자할 수 있게 되었습니다.

[00:00] 인디 개발자 댄이 Anthropic의 새로운 Claude 4 모델 시리즈(Sonnet, Opus)와 정식 출시된 Claude Code를 소개하며, 이것이 에이전틱 코딩 분야에서 게임 체인저가 될 것이라고 설명합니다.

[00:45] 병렬 AI 코딩 기법을 통해 여러 에이전트가 동시에 작업하여 코드베이스의 다양한 버전을 생성하고, 최고의 결과를 메인 브랜치로 병합하는 고급 기법을 소개합니다.

반복적 프롬프트 → 계획 작성 → 에이전트 실행 순서에서 한 걸음 더 나아가 다수의 에이전트를 동시에 병렬로 운용하는 고급 워크플로우를 설명합니다.

[01:39] 반복적 계획에서 병렬 에이전트 작업으로 발전한 에이전틱 코딩의 진화 과정을 설명하며, ThoughtBench라는 다중 모델 대화 애플리케이션을 예시로 제시합니다.

간단한 프론트엔드·백엔드 앱인 ThoughtBench를 예시로, 기존 UI를 고밀도 대시보드로 개편하기 위한 프롬프트 계획을 수립합니다.

[02:29] Claude Code가 정식 출시되어 /model 명령으로 Opus 4 모델을 선택할 수 있게 되었으며, 2024년의 에이전틱 AI 코딩 방식은 계획 수립 후 강력한 도구에 작업을 위임하는 것이라고 강조합니다.

[02:54] 코드베이스에 포함된 UI 개선 프롬프트를 통해 ThoughtBench를 고밀도 정보 대시보드로 변환하면서 우수한 사용자 경험을 유지하는 작업 계획을 설명합니다.

[03:11] Claude Code를 사용한 일반적인 워크플로우와 병렬 처리의 장점을 설명하며, 기존 방식의 한계와 개선된 접근법을 제시합니다.

`git worktree add` 명령으로 여러 작업 디렉터리를 생성해 코드베이스를 복제합니다. 변수화된 프롬프트로 UI 리팩토링 기능을 각 디렉터리에 전달합니다.

[03:35] Git 워크트리를 활용한 병렬 개발 환경 설정 방법을 설명하고, 다이어그램을 통해 git worktree add 명령어로 별도 환경을 구성하는 과정을 보여줍니다.

[04:06] LLM의 비결정적 특성을 활용한 병렬 처리의 이점을 강조하며, 여러 버전의 코드를 생성해 최적의 결과를 선택할 수 있음을 설명합니다.

[04:15] Claude Code의 슬래시 명령어와 변수 설정 기법을 소개하고, UI rewrite 기능을 위한 실제 프롬프트 실행 과정을 시연합니다.

`/exe parallel` 커맨드를 사용해 계획과 병렬 작업 수를 인자로 전달, 각 에이전트를 독립 환경에서 동시에 실행하도록 구성합니다.

[04:48] Claude 4 Opus가 병렬로 실행하는 작업들을 나열하며, Git 워크트리 생성, 환경 설정, 종속성 설치 등의 자동화된 프로세스를 설명합니다.

[05:14] 실제 생성된 워크트리 환경을 확인하고, 전체 코드베이스가 성공적으로 복제되었음을 보여주며, 자동 편집 모드 활성화와 오류 처리 과정을 설명합니다.

[05:53] Claude 4 Opus가 에이전틱 워크플로우를 완료하여 3개의 새로운 git work tree를 생성했습니다. 이는 전통적인 프롬프트가 아닌 AI 개발자 워크플로우(ADW)입니다.

LLM의 비결정성 특성으로 각 실행마다 다른 결과가 나오기 때문에 실패 헷지, 다양한 관점 확보, 작업 분산 등을 통해 최적 해를 도출할 수 있습니다.

[06:14] AI 코딩은 단순한 코드 생성을 넘어 엔지니어링 워크플로우가 필요합니다. Git, 파일 시스템과의 상호작용, 코드 작성 및 파일 업데이트 등 일상적인 엔지니어링 작업이 포함됩니다.

[06:34] 3개의 work tree가 각자의 브랜치에서 작동하도록 설정이 완료되었습니다. 이 병렬 에이전틱 코딩 워크플로우를 통해 여러 미래 현실의 코드베이스를 얻고 최고의 부분을 선택할 수 있습니다.

[07:15] 이제 에이전트들에게 기능 배포에 필요한 액세스 권한을 부여합니다. commands 디렉토리의 exe.p parallel 파일을 통해 모든 에이전트를 실행할 예정입니다.

[07:39] 워크플로우 변수로 실행할 계획과 병렬 work tree 수(에이전트 수)를 설정합니다. 각 에이전트에게 전용 코드베이스를 제공하고 계획을 전달하는 구조입니다.

[07:59] /exe parallel 명령을 실행하여 UI 개편 계획을 시작합니다. cloud code/commands는 인덱스 기반으로 작동하며, 첫 번째 인수는 계획, 두 번째는 병렬 수가 됩니다.

[08:27] Claude 4 Opus를 사용해 3개의 병렬 인스턴스로 코딩 작업을 수행하는 강력한 시스템을 설정한다. 각 인스턴스는 별도의 하위 작업으로 동일한 기능을 병렬로 구축한다.

[08:54] AI 코딩에서 좋은 계획이 곧 좋은 프롬프팅이라는 핵심 원칙을 강조한다. 컴퓨팅 파워가 증가할수록 명확한 소통과 계획의 중요성이 더욱 커진다.

[09:08] 단순한 AI 도구 대신 최첨단 Claude 4 Opus의 여러 인스턴스를 활용한 고급 병렬 에이전트 코딩을 시작한다. 이는 장기 실행 에이전트 워크플로우의 확장된 형태다.

[09:35] 코드베이스 분석을 위해 루트 디렉토리에서 시작하여 서버와 클라이언트 구조를 파악하고, tree 명령어로 깊이 있는 분석을 수행한 후 UI 개편 계획을 읽어들인다.

세 개의 에이전트가 각각 5~14분간 10~33개의 도구 호출로 작업을 수행하고 결과 요약 파일을 생성합니다. 토큰 사용량과 실행 시간 차이를 확인합니다.

[10:01] 앞으로 엔지니어링 작업의 핵심은 계획 수립과 사고 과정에 있으며, 3개의 병렬 에이전트가 각자의 코드베이스에서 동일한 스펙을 구현하게 된다.

[10:24] 병렬 에이전트 시스템이 실행되기 시작하며, 이는 고급 에이전트 디코딩으로 상당한 비용이 발생한다. 모든 에이전트가 동시에 병렬로 작업을 수행하는 비자명한 작업이다.

[11:01] Claude Code 설정에서 여러 명령을 기본 활성화하여 자동 작동하도록 설정했으며, 병렬 워크플로우를 사용하는 이유와 구체적인 장점에 대해 설명합니다.

[11:45] LLM의 비결정론적 특성을 설명하며, 같은 프롬프트로도 매번 다른 결과가 나오는 것이 버그가 아닌 기능임을 강조합니다. 특히 대규모 장기 실행 작업에서 이런 특성이 두드러집니다.

애매한 요구사항, UI 개편처럼 여러 해법이 허용되는 작업, 실패 위험이 있는 장기 작업에 적합합니다. 명확한 계획이 전제되어야 효과가 극대화됩니다.

[13:05] 인간처럼 LLM도 비결정론적 토큰 생성 기계이며, 이런 특성을 활용해 미래의 여러 버전을 볼 수 있다고 설명합니다. 병렬 에이전트 실행을 통해 복잡한 작업에서 모델 실패에 대비할 수 있습니다.

[13:39] 병렬 에이전트 워크플로우의 핵심 장점을 설명하며, 여러 에이전트가 동시에 작업할 때 성공 확률이 높아지고 단일 인스턴스보다 우수한 결과를 얻을 수 있다고 설명합니다.

[14:04] 같은 문제에 대한 다양한 관점을 얻는 것의 중요성을 강조하며, 특히 UI 개발에서 여러 수용 가능한 버전 중 최적의 것을 선택할 수 있는 장점을 설명합니다.

[14:32] 엔지니어링 작업을 여러 에이전트에게 위임할 수 있는 확장성을 언급하며, 3개의 에이전트를 사용하여 3배의 기회와 향상된 최종 결과를 얻는 방법을 설명합니다.

[15:03] 실제 코드 실행 결과를 보여주며, 에이전트 2가 10개 도구만 사용하여 5분 만에 완료된 반면, 다른 에이전트들은 여전히 실행 중이며 더 많은 도구를 사용하고 있음을 확인합니다.

[15:42] 태스크 1이 9분(80k Opus 토큰)에 완료되었고, 세 번째 에이전트는 24개 도구를 사용하며 여전히 실행 중임을 보고하며, 각 에이전트가 다른 접근 방식과 처리 시간을 가지고 있음을 보여줍니다.

[16:15] 세 번째 에이전트가 24개의 도구를 사용하며 계속 실행 중이며, 병렬 에이전트 코딩 기법의 장점과 언제 사용해야 하는지에 대해 설명합니다.

[16:44] 병렬 에이전트 코딩을 사용하기에 적합한 경우들을 설명합니다: 모호한 작업, 여러 버전이 허용되는 UI 작업, 에이전트 실패 가능성, 어려운 작업 등입니다.

[17:09] 가장 중요한 조건인 명확한 계획의 필요성을 강조하며, 계획을 세울 수 없다면 병렬 워크스페이스 대신 기존 코드베이스에서 반복 작업을 하는 것이 좋다고 설명합니다.

[17:53] 에이전트 3이 33개의 도구 사용으로 작업을 완료했으며, 프론트엔드 서버들을 부팅할 스크립트가 필요하다고 설명합니다.

[18:16] 세 에이전트 모두 완료되어 각각 9분, 5분, 14분의 실행 시간을 기록했으며, 결과를 나란히 확인하기 위해 start tree clients.sh 스크립트를 생성하여 실행합니다.

세 가지 병렬 작업으로 생성된 서로 다른 UI 버전을 직접 실행해 비교합니다. 터미널 스타일, 현대적 디자인, 컴팩트 오버레이 등 각 특징을 확인합니다.

[18:42] 클라이언트 시작 스크립트를 실행하여 UI 재작성 프로젝트를 시작합니다. 각 클라이언트가 메인 서버에 연결되어 실행되는 것을 확인할 수 있습니다.

[19:16] 3개의 병렬 클라이언트(클라이언트 1, 2, 3)를 동시에 부팅하여 ThoughtBench 애플리케이션의 다양한 버전을 실행합니다.

[19:35] 원본 애플리케이션과 3가지 다른 UI 버전을 비교합니다. 각 버전마다 독특한 디자인과 스타일을 보여주며, 실제로 프롬프트 입력과 실행이 가능합니다.

[19:50] 버전 2의 모던하고 깔끔한 파란색 하이라이팅 디자인을 특히 좋아합니다. 미래적인 오버레이 스타일이지만 일부 가독성 문제가 있습니다.

[20:24] 버전 3은 공간 절약을 위해 압축된 오버레이와 작은 폰트를 사용하는 직관적인 디자인을 보여줍니다.

[20:51] 최종적으로 버전 2를 가장 선호한다고 평가합니다. 기존 테마와 잘 어울리면서도 한 단계 발전된 느낌으로, 버튼과 스타일링이 우수하고 공간 활용도 효율적입니다.

[21:09] Claude Code를 사용한 병렬 워크스페이스 작업의 결과를 확인하며, 로더 설정과 UI 요소들의 품질에 만족감을 표현합니다.

[21:16] 애플리케이션의 세 가지 버전을 성공적으로 생성했으며, 각 버전에서 Claude Code와 Opus를 활용해 클라이언트를 업데이트했다고 설명합니다.

[21:30] 계획 수립의 중요성을 강조하며, 에이전트들을 병렬화하여 독립된 환경에서 동일한 계획에 따라 실행시켰다고 설명합니다.

[21:44] 최고의 결과를 병합하기 위해 두 번째 버전을 선택하고, Cursor를 열어 워크트리에서 해당 버전을 확인하는 과정을 보여줍니다.

[22:00] 포트 검색을 통해 현재 작업 중인 것이 두 번째 버전임을 확인하고, git status를 실행하여 변경사항들을 검토합니다.

[22:23] 독립적인 에이전트들이 모든 작업을 요약하는 패턴의 장점을 설명하며, git diff를 통해 메인 브랜치 대비 630라인의 변경사항을 확인합니다.

[22:47] 직접적인 코딩 작업 없이 계획만으로 모든 변경을 이뤄냈음을 강조하며, 좋은 계획이 좋은 프롬프팅이라는 원칙적 AI 코딩의 핵심을 설명합니다.

[23:04] UI 리라이트 에이전트 2로 커밋을 완료하고 푸시한 후, 메인 브랜치로 돌아가 git branch 명령으로 모든 브랜치를 확인합니다.

[23:32] 브랜치 2를 메인에 병합하는 과정을 시연하며, 다른 엔지니어와 협업하듯이 git merge 명령을 실행하여 모든 변경사항을 성공적으로 통합합니다.

가장 우수한 에이전트 브랜치를 메인에 merge하고, 포트 설정을 원복한 뒤 최종 UI를 배포 가능한 형태로 셋업합니다.

[23:46] Git 병합을 통해 원래 브랜치에서 새로운 변경사항을 확인하고, vite 파일에서 병합이 성공적으로 이루어졌음을 검증합니다.

[24:02] 병렬 작업의 결과로 업데이트된 thoughtbench 버전을 확인하면서, 여전히 텍스트 가독성 등 일부 수정이 필요한 부분들이 있음을 언급합니다.

[24:24] 여러 에이전트가 백그라운드에서 병렬로 작업하는 혁신적 아이디어를 강조하며, 이를 통해 애플리케이션의 다양한 버전을 선택할 수 있게 되었다고 설명합니다.

[24:39] Beni 코드베이스의 nit parallel 기능을 소개하며, 동적 접근 방식으로 원하는 만큼 많은 병렬 워크 트리를 생성할 수 있다고 설명합니다.

[24:59] 병렬 에이전틱 코딩의 핵심 목적을 설명합니다. 미래에 대한 여러 기회, 다양한 관점과 버전을 확보하여 최고의 결과를 선택할 수 있게 하는 것입니다.

[25:14] Git 워크 트리 병렬 에이전틱 코딩의 전체 워크플로우를 요약합니다. 작업 계획, 다중 에이전트 병렬 실행, 최고 버전 선택 및 병합, 지속적 배포의 과정을 설명합니다.

에이전트 코딩의 미래를 대비해 계획 기반 병렬 워크플로우 중요성을 강조하고, Principled AI Coding 강좌로 기초부터 고급 기법까지 학습할 것을 제안합니다.

[25:39] 컴퓨팅을 통한 엔지니어링 임팩트 최대화 방법 중 하나로 병렬 에이전틱 코딩을 제시하며, Principled AI 코딩 과정을 소개합니다.

[25:56] 현재 과정에서는 Ader 같은 기존 AI 코딩 도구를 다루며, 향후 과정에서는 에이전틱 코딩에 대해 더 깊이 다룰 예정이라고 안내합니다.

[26:10] AI 코딩의 기초와 원칙 설정의 중요성을 강조하며, 이러한 기초가 과정 출시 6개월 후에도 지속적으로 참조 가능한 이유라고 설명합니다.

[26:25] Claude를 활용한 AI 개발의 핵심 개념들을 설명하며, 맥락-모델-프롬프트의 구조로 초급부터 고급까지의 학습 과정을 제시합니다.

[26:34] ADWs(AI 개발자 워크플로우)와 에이전틱 워크플로우의 현실적 구현 가능성을 강조하며, 코드가 스스로 작성되는 자동화된 개발 환경을 소개합니다.

[26:51] 원칙적 AI 코딩 코스의 2단계 개발 계획을 발표하며, 에이전틱 코딩으로의 발전 방향을 제시합니다.

[27:04] Claude 4 Opus와 Sonnet의 출시, Claude Code의 연구 프리뷰 종료 등 최신 AI 도구들의 발전상을 소개합니다.

[27:16] 다중 에이전트 병렬 작업을 통한 생산성 향상과 최적 솔루션 선택 방법론을 제안하며, 증가된 컴퓨팅 파워 활용의 중요성을 강조합니다.

[27:30] 지속적인 Claude Code 언급의 이유를 설명하며, AI 개발 트렌드의 신호를 감지하는 능력의 중요성을 강조합니다.

[27:47] Claude Code를 차별화된 에이전틱 코딩 도구로 정의하며, 추가 학습 자료와 지속적인 발전 계획을 안내합니다.

[00:00] 안녕하세요, 엔지니어 여러분. 인디 개발자 댄입니다.

[00:02] 이번 영상의 결말을 미리 스포일러하자면

[00:04] 정말 놀라운 내용이 될 거라고 말씀드리겠습니다.

[00:08] Anthropic 덕분에 완전히 새로운 Claude 4 모델 시리즈를 만나볼 수 있게 되었습니다.

[00:11] 새로운 Sonnet과 새로운 Opus 모델이 출시되었습니다.

[00:15] 그리고 매우 중요한 점은, 많은 엔지니어들이 놓칠 수 있지만

[00:18] Claude Code가 이제 정식으로 사용 가능하다는 것입니다.

[00:21] 이제 우리는 최고의 에이전틱 코딩 도구에 크게 투자할 수 있습니다.

[00:23] 새로운 최첨단 모델들과 함께

[00:26] 효과적인 대규모 에이전틱 엔지니어링이 가능해졌습니다.

[00:29] 새로운 최첨단 모델들로

[00:32] 실제 엔지니어링 작업에서

[00:35] Opus 4와 Sonnet 4 모델이

[00:37] 모든 다른 모델들을 압도하고 있습니다.

[00:40] 이는 정말 큰 변화입니다.

[00:43] 오늘은 여러분께

[00:45] 정말 강력한 병렬 AI 코딩 트릭을 공유하고 싶습니다.

[00:49] 여러 에이전틱 코딩 에이전트를 동시에 활용해서

[00:52] 코드베이스의 여러 버전을 생성할 수 있는 방법입니다.

[00:55] 미래 코드베이스의 다양한 버전을 만들어낼 수 있습니다.

[00:58] 경고드리자면 이는 고급 에이전틱 코딩 기법이고

[01:01] 비용이 저렴하지 않습니다.

[01:04] 우리는 계획을 세우고

[01:06] 그 계획을 실행할 것입니다.

[01:08] 여러 에이전트가 각자의 코드베이스 버전에서

[01:11] 작업하도록 배치할 예정입니다.

[01:13] 그런 다음 최고의 버전을 선택해서

[01:15] 메인 타임라인, 즉 메인 브랜치로 병합할 것입니다.

[01:18] Claude 4 시리즈 덕분에

[01:21] 이 기법이 그 어느 때보다 중요해졌고

[01:24] 실현 가능해졌습니다.

[01:26] 제가 무슨 의미인지 정확히 보여드리겠습니다.

[01:28] 새로운 Claude 4 시리즈로

[01:31] 에이전트 코딩을 병렬화해봅시다.

[01:35] 우리는 반복적인 계획 수립에서 시작해서

[01:39] 더 큰 프롬프트 작성으로, 그리고 계획 작성으로 발전해왔습니다.

[01:42] 이제 한 단계 더 나아가보겠습니다.

[01:45] 여러 에이전트를 동시에

[01:47] 병렬로 작업하도록 할 것입니다.

[01:49] 이 고급 에이전트 코딩 기법은

[01:51] 엄청난 이점을 제공합니다.

[01:54] 우리가 무엇을 작업하고 있는지 이해해봅시다.

[01:56] Beni라는 간단한 코드베이스를 다룰 예정입니다.

[01:58] 이것은 ThoughtBench 애플리케이션입니다.

[02:00] 간단한 프론트엔드와 백엔드 애플리케이션으로

[02:02] 여러 모델과 동시에 대화할 수 있게 해줍니다.

[02:04] 새로운 Claude와 Opus 4 모델이

[02:06] 실행되고 있는 것을 볼 수 있습니다.

[02:09] UI 애플리케이션에 대해

[02:10] 멀티 에이전트 코딩을 시연하는 것이 정말 중요합니다.

[02:12] 이 UI를 개선하고

[02:14] 스타일링을 조금 업데이트할 예정이지만

[02:16] 여러 버전의 Claude Code를 실행해서

[02:19] 이 작업을 수행할 것입니다.

[02:21] 설정해봅시다.

[02:23] Claude Code가 업데이트되었고 정식으로 사용 가능합니다.

[02:25] 이는 정말 큰 뉴스입니다.

[02:27] 이제 우리는 Claude Code에 크게 투자할 수 있습니다.

[02:29] /model을 입력하고 모델을 선택할 수 있습니다.

[02:31] 새로운 최고급 Opus 4 모델을

[02:34] 사용하겠습니다.

[02:36] 이 작업을 완료하기 위해

[02:38] 우리는 계획을 세웁니다.

[02:41] 에이전틱 AI 코딩은

[02:43] 2024년의 방식입니다.

[02:46] 많은 가치를 제공하고 싶다면

[02:49] 앉아서 작업을 계획하고

[02:51] 강력한 에이전트 코딩 도구에 맡기는 것이 좋습니다.

[02:54] 코드베이스 안에 UI 개선 프롬프트가 있습니다.

[02:56] 기본적으로 우리가 원하는 모든 작업을 자세히 설명하고 있습니다.

[02:58] 여기서 핵심은

[03:00] 우리가 원하는 것입니다.

[03:02] ThoughtBench를

[03:04] 고밀도 정보 대시보드로 변환하면서

[03:06] 훌륭한 사용자 경험을 유지하는 것입니다.

[03:11] 이게 우리가 실행하려는 프롬프트입니다.

[03:12] 보통이라면 Command + Shift + R로 이것을 복사할 텐데요.

[03:14] 이게 제가 사용하는 단축키입니다. 그리고

[03:16] '이걸 구현해줘'라고 말하겠죠.

[03:17] 그러면 Claude Code가 이를 실행하고

[03:19] 현재 브랜치를 업데이트할 겁니다.

[03:21] 하지만 여러 에이전트를 각자의 환경에서

[03:23] 병렬로 실행하면 훨씬 더 좋은 결과를 얻을 수 있습니다.

[03:26] 그럼 이게 어떤 모습일까요?

[03:28] 베니 코드베이스 안에서

[03:30] .claude.coms를 열어보면

[03:32] 이 간단한 병렬 초기화 프롬프트를 볼 수 있습니다.

[03:35] 이 프롬프트가 하는 일이 뭘까요?

[03:37] 이 프롬프트는 새로운 Git 워크트리를

[03:39] 설정해줄 것입니다. 여기 다이어그램에서 보신 것처럼

[03:42] git worktree add 명령어를 사용해서

[03:45] 위치를 지정할 수 있습니다.

[03:47] 여기 trees 디렉토리에서

[03:49] UI revamp one 디렉토리를 생성하고

[03:51] 기본적으로 베니 코드베이스 전체를 복제할 것입니다.

[03:54] 물론 이를 확장할 수도 있습니다.

[03:56] 여러 에이전트가 정확히 동일한 기능을

[03:59] 구축하기를 원합니다.

[04:02] LLM은 본질적으로 비결정적이기 때문에

[04:03] 이들을 병렬화함으로써

[04:06] 코드베이스의 미래에 대한 다양한 버전을 얻을 수 있고

[04:08] 그 중에서 가장 좋은 것을 선택할 수 있습니다.

[04:11] 자, 이제 이걸 시작해보고

[04:13] 실행되는 동안 프롬프트를 분석해보겠습니다.

[04:15] slash simple과 parallel을 입력하겠습니다.

[04:16] 프롬프트 안에서 변수를 설정하는 것을 볼 수 있습니다.

[04:19] 이건 제가 프롬프트 전체에서

[04:21] 변수를 참조하기 위해 좋아하는 기법입니다.

[04:23] Claude Code의 슬래시 명령어를 통해

[04:25] 변수를 설정하고 전달할 수 있습니다.

[04:28] 이 기능의 이름을 지정하겠습니다.

[04:31] UI rewrite라고 부르겠습니다. 그게 전부입니다.

[04:33] 하나의 매개변수를 전달하는 것입니다.

[04:35] 이것이 여기를 대체할 것입니다.

[04:38] 이 프롬프트를 시작해보겠습니다.

[04:40] Claude 4 Opus에서 실행되는 Claude Code가

[04:42] trees 디렉토리를 생성할 것입니다.

[04:45] 바로 그 명령어를 볼 수 있습니다.

[04:48] 그리고 이 단계들을 병렬로 실행할 것입니다.

[04:49] 새로운 Git 워크트리를 생성하고

[04:51] 환경 변수를 적절한 폴더로 복사하고

[04:53] 서버로 이동해서 종속성을 설치할 것입니다.

[04:55] bun을 사용해서 프론트엔드에서도 같은 작업을 하고

[04:58] Vite 설정을 업데이트해서

[04:59] 다른 포트에서 실행하도록 할 것입니다.

[05:01] 기억하세요, 우리는 이것들을 병렬로 실행하고

[05:03] 모든 결과를 비교하고 싶습니다.

[05:05] 여기서 우리의 에이전틱 워크플로우가

[05:07] 병렬로 실행되는 것을 볼 수 있습니다.

[05:09] 각각의 전용 환경에서

[05:10] 모든 작업을 시작하고 있습니다.

[05:12] UI rewrite one을 열어보면

[05:14] 전체 코드베이스의 직접적인 복제본을 볼 수 있습니다.

[05:18] 여기에 claude, client, server가 있죠.

[05:20] 애플리케이션의 루트와 정확히 동일합니다.

[05:23] Git 워크트리 덕분에 말 그대로

[05:26] 전체 코드베이스를

[05:28] 세 개의 별도 버전으로 복제했습니다.

[05:29] 이게 어디로 향하는지 보시겠죠.

[05:32] 자, Vite 설정이 업데이트되었습니다.

[05:34] 자동 편집 모드를 켜보겠습니다.

[05:37] 이제 병렬 쓰기가 실행될 것입니다.

[05:39] Opus가 오류를 만나면

[05:40] 그냥 해결해 나갈 것입니다.

[05:43] 오류를 수정해 나갈 것입니다.

[05:45] 그리고 Opus가 오류를 만나도

[05:47] 그냥 계속해서 작업을 진행할 것입니다.

[05:50] 오류를 해결하면서 말이죠.

[05:52] 문제를 해결해 나갈 것입니다.

[05:53] 애플리케이션의 모든 버전을 업데이트하고 있습니다.

[05:55] 전체 환경이 설정되어 있죠.

[05:57] git work tree 목록이 여기 있습니다.

[05:59] 이제 3개의 새로운 work tree를 가지게 되었습니다.

[06:02] Claude 4 Opus가 이 에이전틱 워크플로우를 완료했습니다.

[06:05] 명확히 말씀드리자면, 이것이 바로 그것입니다.

[06:07] 좋습니다. 이것은 프롬프트가 아닙니다.

[06:09] 우리는 더 이상 전통적인 프롬프트를 실행하지 않습니다.

[06:11] 우리는 에이전틱 워크플로우를 실행하고 있습니다.

[06:12] 워크플로우를 실행하고 있습니다.

[06:14] Principled AI 코딩 멤버들은

[06:16] 이것을 ADW, 즉 AI 개발자 워크플로우라고 알고 있습니다.

[06:19] AI 코딩만으로는 충분하지 않습니다.

[06:22] 단순히 코드를 생성하는 것 이상이 필요합니다.

[06:24] 엔지니어링 워크플로우가 필요합니다.

[06:26] 우리는 Git과 상호작용하고 있습니다.

[06:27] 파일 시스템과 상호작용하고 있습니다.

[06:29] 코드를 작성하고 있습니다.

[06:31] 파일을 업데이트하고 있습니다.

[06:32] 일상적인 엔지니어링 작업에는

[06:34] 훨씬 더 많은 일들이 진행되고 있습니다.

[06:37] 우리는 3개의 새로운 work tree를 생성했고

[06:40] 모두 각자의 브랜치에서 작동하고 있습니다.

[06:42] 이것이 설정 과정입니다.

[06:43] 좋습니다. 우리는 이미 계획을 가지고 있고

[06:46] 이제 코드베이스를 설정하고 있습니다.

[06:49] 아직 구축하고 있지는 않지만

[06:52] 브랜치와 트리를 설정했습니다

[06:54] 에이전트들이 작업할 수 있도록 말이죠.

[06:56] 이것은 강력한 병렬 에이전틱 코딩

[06:58] 워크플로우로서 여러분의

[06:59] 영향력을 확장하는 데 사용할 수 있습니다.

[07:01] 잠시 후에 이것이

[07:02] 얼마나 강력한지 보여드리겠습니다.

[07:04] 여러 버전을 얻게 될 것이기 때문입니다.

[07:06] 이 코드베이스의 여러 미래 현실을 얻게 되고

[07:09] 최고의 부분들을 선택할 수 있으며

[07:11] 정확히 무엇을 메인 타임라인,

[07:13] 즉 메인 브랜치로 되돌릴지 선택할 수 있습니다.

[07:15] 좋습니다. 지금 우리는 대략 여기에 있습니다.

[07:17] 계속해서 여정을 이어가겠습니다.

[07:19] 모든 코드베이스가 설정되었습니다.

[07:21] 에이전트들에게 이 기능을

[07:23] 배포하는 데 필요한 액세스 권한을 부여해 보겠습니다.

[07:26] claude를 열어서

[07:27] commands 디렉토리로 돌아가겠습니다.

[07:29] 이것은 에이전트 코딩을 위한

[07:31] 3개의 필수 디렉토리 중 하나입니다.

[07:33] exe.p parallel을 열어보겠습니다.

[07:36] 여기서 실제로 모든 에이전트를

[07:37] 실행할 것입니다.

[07:39] 여기에서 동일한 워크플로우를 볼 수 있습니다.

[07:42] 맨 위에 변수들이 있습니다.

[07:44] 여기 있는 변수들은 실행하려는 계획과

[07:46] 병렬 work tree의 수입니다.

[07:49] 즉, 실행하려는 에이전트의 수입니다.

[07:50] 이 프롬프트의 나머지 부분은

[07:51] 꽤 간단합니다.

[07:53] 기본적으로 모든 에이전트에게

[07:54] 각자 전용 코드베이스를 제공하고

[07:56] 이 계획을 그들에게 전달한다고 말하고 있습니다.

[07:59] 좋습니다. 이제 시작해 보겠습니다.

[08:01] /exe parallel을 실행하겠습니다.

[08:03] 실행하려는 계획은 UI 개편입니다.

[08:06] thoughtbench 애플리케이션을 업데이트하겠습니다.

[08:08] 좋습니다. 이것에 대한 참조를 복사하고

[08:10] 첫 번째 인수로 여기에 전달하겠습니다.

[08:12] cloud code/commands로 작업할 때는

[08:15] 인덱스를 기반으로 합니다.

[08:17] 따라서 여기 첫 번째 인수는

[08:20] 우리의 첫 번째 매개변수가 될 것이고

[08:22] 두 번째는 다음에 전달하는

[08:24] 병렬 수가 될 것입니다

[08:27] 병렬 워크트리와 간단한 초기화를 설정했습니다

[08:30] 병렬로 3개를 설정했으니까요. 여기에 숫자 3을 입력하겠습니다

[08:31] 여기에 숫자 3을 입력하겠습니다

[08:33] 이건 정말 강력할 거예요

[08:34] Claude 4 Opus가 이제 3개의 인스턴스를 돌릴 거예요

[08:38] 3개의 인스턴스를 설정할 겁니다

[08:40] 3개의 하위 작업, 3개의 병렬 하위 작업을 설정하고

[08:42] 하위 작업을 설정하고 시작할 겁니다

[08:44] 우리가 완전히 계획한 이 기능을 구축하기 시작할 거예요

[08:46] 완전히 계획한 이 기능을 구축하기 시작할 거예요

[08:48] 채널 시청자분들과

[08:49] 원칙적 AI 코딩 멤버분들은 알고 계시겠지만

[08:51] 좋은 계획이 곧 좋은 프롬프팅입니다

[08:54] 이걸 계속 반복해서 말할 거예요

[08:56] 더 많은 컴퓨팅 파워에 접근할수록

[08:57] 점점 더 중요해지기 때문입니다

[08:59] 소통하는 가장 좋은 방법은

[09:01] 명확하게 쓰는 것, 명확하게 생각하는 것

[09:03] 그리고 계획하는 것입니다. 그런 다음

[09:06] 이런 훌륭한 패키지를 AI 코딩 도구에 넘겨줍니다

[09:08] 이제 바로 그것을 할 거예요

[09:09] 하지만 단순한 AI 코딩 도구나

[09:10] 에이전트 코딩 도구로 하는 대신

[09:13] 최첨단 Claude 4 Opus에

[09:16] 여러 인스턴스로 넘겨주는 거예요

[09:18] 이건 정말 대단한 일입니다

[09:22] 확장에 대해 이야기할 때

[09:24] 장기 실행 에이전트 워크플로우와 장기 실행 에이전트 코딩 작업에 대해 이야기하는데

[09:27] 이것이 바로 더 나아가 확장하는 방법입니다

[09:30] 더 이상 지체하지 말고 시작해봅시다

[09:32] 시작! 이제 백그라운드에서 작업할 거예요

[09:33] 백그라운드에서 작업할 거예요

[09:35] 몇 가지 명령어를 실행해야 했어요

[09:37] 코드베이스를 이해하고 싶었거든요

[09:39] 먼저 루트로 돌아가고 싶었고

[09:41] 그 다음 서버와 클라이언트 디렉토리를 살펴보면서

[09:43] 코드베이스의 고수준 구조를 이해하고 싶었어요

[09:45] 코드베이스의 고수준 구조를 이해하고 싶었어요

[09:47] tree 명령어를 실행해서

[09:49] 코드베이스를 더 깊이 살펴볼 거예요

[09:52] 그리고 우리가 전달한 계획을 읽을 거예요

[09:54] UI 개편 계획을 읽을 거예요

[09:56] 좋아요. 이제 UI 개편 계획을 읽을 거예요

[09:58] 환상적이네요

[09:59] 이제부터 엔지니어링 작업의 대부분이

[10:01] 계획 수립에서 일어날 거예요

[10:03] 사고, 엔지니어링에서 말이죠

[10:04] 원하는 작업의 엔지니어링에서 말이죠

[10:06] 그런 다음 3개의 병렬 에이전트를 만들어서

[10:08] 3개의 병렬 에이전트를 만들어서

[10:09] 각자의 코드베이스에서 스펙을 구현하게 할 거예요

[10:11] 각자의 코드베이스에서 스펙을 구현하게 할 거예요

[10:14] 이게 정말 중요할 거예요

[10:17] 여기서 3개의 작업이 시작되는 걸 보실 거예요

[10:18] 여기서 3개의 작업이 시작되는 걸 보실 거예요

[10:21] 정말 기대됩니다

[10:24] 이 기능은 정말 미친 거예요

[10:26] 토큰이 좀 새어나오고 있네요

[10:27] Opus 토큰들이 말이죠

[10:30] 이건 정말 비싸요

[10:32] 이렇게 많은 에이전트를 시작해서

[10:34] 이렇게 많은 작업을 하는 것은 비싸요

[10:36] 이것은 고급 에이전트 디코딩입니다

[10:38] 바로 그겁니다. 이들은 모두 병렬로 실행되고 있어요

[10:40] 위쪽 것만 실행되는 것처럼 보이지만

[10:43] 실제로는 모두 동시에 실행되고 있어요

[10:44] 이것들을 실행시켜두겠습니다

[10:46] 실제로 꽤 시간이 걸릴 거예요

[10:48] 이건 간단하지 않은 작업이거든요

[10:49] 에이전트들을 실행시켜두겠습니다

[10:52] 여기 자동 승인이 켜져 있고

[10:54] 설정에서 여러 가지를 활성화해뒀어요

[10:56] 보여드릴 수 있어요

[10:58] 저희 설정에서 보여드릴 수 있어요

[11:00] 저희 설정에서

[11:01] 설정에서 여러 가지 명령을 기본적으로

[11:05] 활성화해서 Claude Code가 작동하도록 했습니다.

[11:08] 그렇습니다. 이게 실행되는 동안

[11:12] 왜 이렇게 하고 싶어하는지 이야기해봅시다.

[11:17] 왜 병렬 워크플로우를 원할까요?

[11:20] 이것의 구체적인 장점은 무엇일까요?

[11:24] 우리가 얻고 있는 진정한 우위는 무엇일까요?

[11:30] 매주, 매주 월요일마다 저는 여기 테이블에

[11:34] 문자 그대로 이 테이블에 와서

[11:40] 여러분이 사용할 수 있는 가치 있는 엔지니어링 통찰을 제공하고 싶습니다.

[11:45] 여러분의 실무 엔지니어링 작업에서 직접 사용할 수 있는 것들 말이죠.

[11:49] 그래서 이것이 여러분의 실무에 어떻게 유용한지

[11:53] 이야기해보겠습니다. 보시다시피

[11:57] 아직도 작업 중입니다. readme를 열어서

[12:01] 여기서 몇 가지 핵심 아이디어를 살펴봅시다.

[12:06] 왜 병렬로 실행하는가? LLM은

[12:10] 비결정론적 확률 기계입니다.

[12:13] 즉, 실행할 때마다

[12:17] 다른 결과를 얻게 된다는 뜻입니다.

[12:21] 같은 프롬프트라도 다른 결과를 주죠.

[12:25] 특히 우리가 운영하고자 하는

[12:29] 규모를 고려하면 더욱 그렇습니다.

[12:33] 일회성 빠른 변경이나

[12:37] 그린필드 애플리케이션은 신경 쓰지 않습니다.

[12:41] 여기저기 작은 조정도 관심 없어요.

[12:45] 저는 대규모 장기 실행 작업에 대해 이야기하고 있습니다.

[12:50] 엄청난 양의 엔지니어링 작업을 실행하는 것 말이죠.

[12:53] 그것이 채널에서 우리가 목표로 하는 것입니다.

[12:57] 에이전틱 코딩 도구들과 그 이상으로

[13:01] 엄청난 양의 작업이 완료되기를 원합니다.

[13:05] 이런 장기 실행 작업에서는

[13:09] 두 번 실행하면 다른 결과를 얻는다는 것을

[13:13] 보장할 수 있습니다. 이제 여러분은

[13:17] 이것이 버그라고 생각할 수도 있습니다. 아닙니다.

[13:21] 이것은 기능입니다. 여러분과 저처럼

[13:26] 우리는 비결정론적 토큰 생성 기계입니다.

[13:30] 제가 다음에 말할 것은 오리,

[13:34] 바나나, 인피니티 스톤, 맞죠?

[13:38] 제가 다음에 무엇을 말할지 항상 알 수는 없습니다.

[13:42] 추측할 수는 있죠. 높은 확률로

[13:45] 특히 제가 그리고 우리가 활동하는

[13:49] 도메인 공간에서 작업한다면 말이죠.

[13:53] 하지만 제가 여기서 생성할 다음 토큰을

[13:56] 확실히 알 수는 없습니다.

[14:00] 그것이 여러분이 매주 찾아오는

[14:04] 이유의 일부입니다. 제가 생성하는

[14:08] 토큰들이 차별화된 토큰이기 때문이죠.

[14:11] 이 영상에서도 그 또 다른 예시입니다.

[14:13] 구독 꼭 해주세요. 등등등.

[14:17] 이것은 기능입니다. 버그가 아니라요.

[14:20] 이것이 제 요점입니다. 우리는 이를 활용해서

[14:25] 미래의 여러 버전을 볼 수 있습니다.

[14:30] 이제 우리는 코드베이스의 여러 미래를 구축할

[14:36] 수 있는 역량을 갖추었고

[14:40] 그 중에서 최고의 결과를 선택할 수 있습니다.

[14:43] 이것이 바로 이것이 강력한 이유입니다.

[14:47] 여러 에이전트를 병렬로 실행함으로써

[14:51] 우리는 이것을 할 수 있습니다. 복잡한 작업에서

[14:55] 모델 실패에 대해 헤지할 수 있습니다.

[14:59] 이 작업 중 하나가 실패할 가능성이 매우 높습니다.

[15:02] UI를 업데이트하지 않을 수도 있고

[15:04] 어떤 버그가 발생할 수도 있습니다.

[15:07] 17개의 도구 호출이 보이는데

[15:10] 그냥 실패할 수도 있습니다. 그것은 매우 가능한 일이고

[13:39] 여러 에이전트 워크플로우를 동시에 실행하는 것의 장점은

[13:41] 우리를 위해 일하는 여러 에이전트가 있다는 것입니다.

[13:42] 여기서 장점은

[13:44] 이 중 두 개가 성공할 수도 있고

[13:46] 하나가 성공할 수도 있다는 것입니다.

[13:47] 그리고 세 개보다 훨씬 더 많은 에이전트를 실행할 수 있습니다.

[13:49] 저는 그냥 이것을 보여드리고 있는 것입니다.

[13:51] 이것은 제가 여러분과 공유하고 싶은

[13:53] 간단하고 최소한의 예제입니다.

[13:54] 이것이 여러 에이전트를 병렬로 실행하는

[13:56] 한 가지 이유입니다.

[13:59] 이것은 이미 여러분이 혼자서

[14:01] 단일 인스턴스를 실행하는 것보다 뛰어납니다.

[14:03] 이제 두 번째를 살펴보겠습니다.

[14:04] 같은 문제에 대해 다른 관점을 얻을 수 있고

[14:06] 그 다음 최고의 것을 선택할 수 있습니다.

[14:08] 왜 이것이 중요할까요?

[14:09] 사용자 인터페이스 같은 것들의 경우

[14:11] 이것의 좋은 예시인데

[14:13] 우리가 원하는 일반적인 방향은 있지만

[14:15] 정확히 어떤 버전을 원하는지

[14:17] 모를 수도 있습니다.

[14:19] 우리의 경우 UI를 개편하고 있습니다.

[14:22] 이것의 수용 가능한 버전은 많습니다.

[14:23] 이 비디오에서 보시게 될 것처럼

[14:26] 우리가 살펴볼 여러 최종 상태가 있습니다.

[14:28] 세 번째로

[14:29] 우리의 엔지니어링 작업을 격리하고

[14:32] 2개에서 n개의 에이전트에게 위임할 수 있습니다.

[14:34] 실제로 이것에는 제한이 없습니다.

[14:36] 저는 그냥 3개를 선택했습니다.

[14:39] 좋은 숫자입니다.

[14:41] 시작하기에 좋은 위치입니다.

[14:42] 세 가지 다른 버전을 원합니다.

[14:44] 이것은 여러분에게 코드베이스의

[14:47] 미래에 대한 훌륭한 시작 세트를 제공할 것입니다.

[14:50] 선택할 수 있는 것들 말이죠.

[14:52] 우리는 세 개 중 최고를 병합할 수 있습니다.

[14:55] 다시 3배의 기회를 얻는 것입니다.

[14:56] 직접 컴퓨팅을 사용해서

[14:58] 우리가 가진 최종 결과를 개선하고 있습니다.

[15:00] 이것이 우리가 병렬로 실행하는 이유입니다.

[15:03] 코드를 살펴보겠습니다.

[15:05] 에이전트 2가 완료된 것 같습니다.

[15:07] 확인해보세요. 에이전트 2는

[15:09] 완료되었습니다. 10개의 도구만 사용했습니다.

[15:11] 매우 흥미롭습니다. 계속 진행해보겠습니다.

[15:14] 뭔가를 추적하려는 것 같습니다.

[15:15] 뭔가를 수정하는 것 같습니다.

[15:16] 승인해보겠습니다.

[15:18] 매우 멋지죠?

[15:21] Opus가 10개 도구, 67,000 토큰을 실행했고

[15:26] 태스크 2에서 5분 동안 실행되었습니다.

[15:28] 태스크 3과 태스크 1은 아직 실행 중입니다.

[15:30] 코드베이스 1에서 엄청난 도구 사용이 있는 것을 볼 수 있습니다.

[15:34] 분명히 매우 다른 결과를 얻을 것입니다.

[15:35] 도구 호출 수만 봐도 이미 알 수 있습니다.

[15:37] 이것은 실행하는 데 더 많은 시간이 필요할 것입니다.

[15:39] 태스크 1이 아직 도구 호출을 쌓고 있는 것을 볼 수 있습니다.

[15:41] 결과를 받았습니다.

[15:42] results.md가 있죠.

[15:45] 그것이 병렬 도구의 끝이어야 합니다.

[15:48] results.md를 검색하면

[15:50] 거기서 마지막 명령 중 하나였던 것을 볼 수 있습니다.

[15:53] 태스크 1도 이제 완료되었습니다.

[15:55] 태스크 1은 9분이 걸렸습니다.

[15:57] 기본적으로 10분입니다.

[15:58] 이 장시간 실행되는

[16:00] 에이전트 워크플로우를 보세요.

[16:03] Opus 토큰 80k입니다.

[16:05] 거기에 많은 가치가 있을 것입니다.

[16:08] 그리고 우리의 세 번째 에이전트는

[16:10] 여전히 실행 중입니다.

[16:12] 24개의 도구를 사용하고 있습니다.

[16:15] 아직 실행 중입니다. 24개의 도구를 사용하고 있네요.

[16:17] 꽤 훌륭한 결과가 나올 것 같습니다.

[16:18] 완료될 때까지 기다려보겠습니다.

[16:20] 이 강력한 기법을 언제 사용해야 하는지

[16:21] 간단히 설명해 드리겠습니다.

[16:23] 항상 이 기법을 사용하고 싶지는 않으시죠?

[16:24] 보시다시피 시간이 좀 걸릴 것이지만,

[16:26] 좋은 점은 여러 개를 병렬로

[16:27] 구축한다는 것입니다.

[16:29] 거의 항상 가장 오래 걸리는 에이전트의 시간만큼만

[16:32] 걸린다고 보시면 됩니다.

[16:34] 항상 멀티 에이전트 git worktrees를

[16:36] 사용하는 것에 대한 논리도 있지만,

[16:38] 한번 살펴보겠습니다.

[16:40] 좋습니다. 이 기법을 언제 사용하는지

[16:42] 알아보겠습니다.

[16:44] 상당히 간단합니다.

[16:45] 모호한 작업에 완벽합니다.

[16:47] 여러 버전이 허용될 수 있는 UI 작업이 있을 때,

[16:50] 에이전트 중 하나가 성공할 것이라고

[16:53] 생각할 때,

[16:55] 에이전트 중 하나가 실패할 수도

[16:57] 있다고 생각할 때,

[16:58] 어려운 작업을 하고 있다고 생각할 때는

[17:01] 3개나 5개의 에이전트를 실행해서

[17:03] 어느 것이 성공하는지 보면 됩니다.

[17:05] 그리고 물론 이것이 아마

[17:06] 가장 중요한 포인트일 겁니다.

[17:07] 이것을 먼저 말했어야 했는데요.

[17:09] 명확한 계획이 있어야 합니다.

[17:11] 그리고 독립적인 브랜치에 넣을 만큼

[17:13] 충분한 작업이 있어야 합니다.

[17:16] 항상 계획을 사용하는 것에 대한 강력한 논리가 있습니다.

[17:20] 제 모든 작업은 거의

[17:21] 사양서에서 나옵니다.

[17:23] 저는 생각하고, 쓰고, 계획하고,

[17:26] 에이전트 코딩 도구들과 함께

[17:27] AI 초안을 작성합니다.

[17:30] 그들이 계획을 세우는 데 도움을 줍니다.

[17:32] 만약 계획을 세울 수 없다면,

[17:34] 반복적으로 프롬프트를 해야 한다면,

[17:36] 병렬 워크스페이스를 사용하지

[17:38] 않는 것이 좋습니다.

[17:39] 의미가 없을 거예요. 자신만의 코드베이스에서

[17:42] 반복 작업을 하는 것이 좋습니다.

[17:44] 이 중 하나라도 해당되고,

[17:45] 특히 세 번째가 해당된다면,

[17:47] 작업을 계획할 수 있고, 미리 볼 수 있고,

[17:49] 무엇을 찾고 있는지 안다면,

[17:50] 병렬 처리가 정말 강력할 것입니다.

[17:53] 여기 에이전트 3이 있습니다. 33개의 도구를 사용했네요.

[17:56] 이것이 작동하는 동안,

[17:58] 모든 프론트엔드 서버를 부팅할

[18:01] 프론트엔드 스크립트가 필요할 것입니다.

[18:03] 초기화 병렬 스크립트 내부에서

[18:06] 클라이언트 포트만 업데이트했습니다.

[18:08] 프론트엔드 변경만 하기 때문입니다.

[18:11] 실제로 여기서 메인 서버를 실행할 수 있어서

[18:12] 기존 코드베이스를 사용할 수 있습니다.

[18:14] 좋습니다. 이것 보세요.

[18:16] 정말 멋집니다. 세 에이전트 모두

[18:18] 완료되었습니다.

[18:20] 총 실행 시간을 확인해 보겠습니다.

[18:22] 이것 보세요. 세 개의 에이전트가

[18:24] 9분, 5분, 14분 동안 실행되었습니다.

[18:27] 여기 요약이 있습니다.

[18:28] 결과 요약을 받았습니다.

[18:30] 이것들을 실행하기 위해,

[18:32] 나란히 보고 싶습니다.

[18:35] start tree clients.sh를 생성합니다.

[18:36] 각 워크트리에 대해 클라이언트를 시작한다고

[18:39] 말하고 실행해 보겠습니다.

[18:41] 좋습니다. 시작해 보겠습니다.

[18:42] 이걸 확인해보세요. 클라이언트를 시작합니다. 우리는

[18:44] 이걸 살펴볼 수 있어요. 네,

[18:45] 이게 완벽해요. UI 재작성이고 그리고

[18:48] 실행 중인 것을 볼 수 있어요. 여기에

[18:50] 멋진 로깅이 있고 그리고

[18:52] 모든 프로세스를 기다릴 거예요.

[18:53] 좋아 보이네요. 시작해보죠.

[18:54] 좋아요. 이제 시작됩니다.

[18:56] 파일 잠금 해제 권한을 주고 있네요.

[18:58] 좋습니다. 그럼 이 파일을

[18:59] 실행해보죠. 그리고 참고로 만약 여기서

[19:01] gs를 입력하면 git status... 우리는 메인 브랜치에서

[19:04] 이 하나의 변경사항만 있어요.

[19:06] 맞죠. 다른 모든 변경사항들은

[19:08] 우리 워크트리들로 분리되었어요. 하지만 자,

[19:10] 더 이상 지체하지 말고 이걸 복사해서

[19:12] 실행해보죠. 우리는 모든 클라이언트를

[19:14] 동시에 시작할 거예요. 자, 이것들을

[19:16] 부팅해보죠.

[19:18] 클라이언트 1, 클라이언트 2, 클라이언트 3, 이들은

[19:20] 모두 메인 서버에 연결되어 있어요. 자, 이것들을

[19:23] 시작해보죠.

[19:24] 이미 약간의 차이점을

[19:25] 볼 수 있어요. ThoughtBench 애플리케이션으로

[19:28] 가보죠. 왜냐하면 거기서

[19:30] 변경에 초점이 맞춰져 있거든요. 자, 하나가 있고,

[19:32] 둘이 있고, 셋이 있습니다. 그리고 이걸 확인해보세요,

[19:35] 여러분. 여기가 원본이에요, 맞죠? 그럼

[19:37] 여기에 '안녕'이라고 입력할 수 있어요. 프롬프트가 있고,

[19:39] 맞죠? 실행될 거예요. 어쩌고저쩌고

[19:40] 어쩌고. 모든 게 좋아 보입니다. 그리고 여기 우리의

[19:43] 다른 버전들이 있어요. 좋아요. 여기가

[19:46] 어... 버전 1이에요.

[19:47] 터미널 같은 스타일을 볼 수 있어요. 여기가 버전 2입니다.

[19:50] 이걸 보세요. 정말 이 버전이

[19:52] 마음에 들어요. 정말 깔끔하죠, 맞죠? 뭔가 모던한

[19:54] 느낌이에요. 이 파란색 하이라이팅과 모던한

[19:56] 스타일이 정말 마음에 들어요. 그리고 네, 여기서

[19:58] 프롬프트를 실행할 수 있어요. 이게 작동하는지 봅시다. 네,

[20:00] 좋습니다. 저것 봐요. 정말 흥미로워요. 뭔가

[20:02] 오버레이 설정 같은 거예요, 맞죠? 매우 미래적인

[20:06] 모습이에요. 어... 읽기에는 좀 어렵고

[20:08] 그리고 당연히 아시다시피,

[20:10] 여기에 스타일링 문제들이 있지만,

[20:12] 그건 중점이 아니에요.

[20:14] 당연히 후속 프롬프트로 들어가서

[20:16] 정리할 수 있어요. 정말 여기서

[20:18] 집중해주셨으면 하는 건 우리가

[20:20] 애플리케이션의 여러 작동 버전들을

[20:23] 가지고 놀 수 있다는 사실이에요.

[20:24] 여기가 버전 3입니다. 매우 흥미롭죠,

[20:26] 맞죠? 그럼 "어떻게 지내세요?"라고

[20:28] 말할 수 있어요. 그냥 적당한 채우기 프롬프트죠. 그리고

[20:31] 이걸 확인해보세요. 맞죠. 이

[20:32] 버전도 마음에 들어요. 좀 더 그냥

[20:34] 직관적이에요. 여기서

[20:36] 리셋하고 'hello'라고 입력해보죠. 이 버전은

[20:39] 공간 절약을 위해 오버레이들을 정말 압축하고 있어요.

[20:42] 모든 폰트가 훨씬 작아진 걸 볼 수 있어요.

[20:44] 이거 정말 멋지죠,

[20:45] 맞죠? 우리는 이 새로운 애플리케이션의

[20:47] 여러 작동 버전들을 가지고 있어요. 좋아요. 어...

[20:51] 두 번째 버전이 가장

[20:52] 마음에 든다고 말해야겠어요, 맞죠? ThoughtBench. 이게

[20:54] 우리의 이전 테마와

[20:56] 잘 맞아요. 그냥 다음 단계로

[20:58] 끌어올린 느낌이에요. 당연히 여기에

[20:59] 개선할 스타일링 수정사항들이 있어요. 하지만

[21:02] 버튼들이 마음에 들어요. 스타일링이 마음에 들어요.

[21:03] 이 느낌이 마음에 들어요. 그리고 여기서 좀 더

[21:06] 압축되어 있어서

[21:07] 공간을 조금 더 절약하고 있어요.

[21:09] 네, 이제 리셋을 해볼게요. 타입을 입력하고

[21:11] 네, 이런 방식이 마음에 드네요.

[21:13] 이런 로더들의 설정도 좋아요.

[21:16] 어쨌든 정말 멋지죠? 우리가

[21:17] 워크스페이스의 여러 버전을 만들었어요.

[21:20] 맞죠? 우리는 애플리케이션의

[21:22] 세 가지 버전을 만들었습니다.

[21:24] 모든 버전에서 Claude Code를 실행하여

[21:26] Opus로 클라이언트를 업데이트했습니다.

[21:30] 계획을 세웠어요. 이게 정말 중요하죠?

[21:31] 우리의 역할이 무엇인지 알아야 해요.

[21:34] 계획을 세웠고, 에이전트를 병렬화하여

[21:38] 각자의 독립된 환경에서 실행하게 했습니다.

[21:40] 모두 동일한 계획에 따라 실행했어요.

[21:42] 그리고 여기까지 왔습니다.

[21:44] 이제 최고의 결과를 병합해봅시다.

[21:46] 저는 두 번째 버전이 마음에 들어요.

[21:49] 마치 이 코드베이스에서 작업하는

[21:50] 엔지니어처럼 말이죠. Cursor를 열고

[21:52] trees로 가겠습니다. UI 리라이트예요.

[21:54] 아마 2번일 것 같네요. 좋아요.

[21:57] 우리는 지금 애플리케이션의 한 버전 안에 있어요.

[22:00] 어떻게 이것을 확인할 수 있을까요?

[22:03] 이 포트를 찾을 수 있을 거예요.

[22:05] 이 포트를 검색해봅시다. 완벽해요.

[22:08] 맞죠? 그 포트가 바로 여기 있어요.

[22:09] 그래서 이것이 확실히 두 번째 버전이네요.

[22:11] 좋아요. git status를 실행해서

[22:14] 모든 변경사항을 확인할 수 있어요.

[22:15] 그리고 실행할 수 있습니다.

[22:18] 우리가 두 번째 브랜치에 있다는 걸

[22:20] 볼 수 있어요. 여기 결과 파일이 있네요.

[22:23] 이것은 독립적인 에이전트들이

[22:25] 모든 작업을 요약하도록 하는

[22:27] 훌륭한 패턴입니다.

[22:29] 모든 것이 의도한 대로 작동하고 있어요.

[22:34] 이제 git diff도 확인해볼 수 있습니다.

[22:37] stat head가 필요할 것 같네요.

[22:38] 맞나요? 네, 됐네요.

[22:40] 메인 브랜치와 비교하면

[22:43] 630라인을 에이전트가 변경했어요.

[22:46] 우리는 아무것도 건드리지 않았어요.

[22:47] 아무것도 하지 않았습니다.

[22:49] 우리가 한 건 계획뿐이에요.

[22:50] 다시 한번 말하지만, 좋은 계획이

[22:52] 좋은 프롬프팅입니다.

[22:54] 모든 원칙적인 AI 코딩 멤버가

[22:55] 아는 사실이에요. 만약 작업을 계획하지

[22:57] 않고 있다면, 다음 단계의

[22:59] 에이전트 코딩 도구들로 할 수 있는

[23:01] 일들에서 뒤처지기 시작할 거라고

[23:03] 생각해요. 좋아요.

[23:04] 여기서 완전히 커밋하겠습니다.

[23:08] GCM이라고 하겠어요. UI 리라이트

[23:10] 에이전트 2라고 하겠습니다.

[23:12] 이 브랜치에서 작업하는 엔지니어처럼

[23:13] 적당히 내용을 만들어 보고 있어요.

[23:15] git push를 하겠습니다.

[23:17] 좋아요. 리라이트 2가 푸시되었네요.

[23:19] 이제 메인 브랜치로 돌아가겠습니다.

[23:21] 워크 트리들이 보이네요.

[23:23] 여기서 git branch를 실행하면

[23:25] git branch예요. 더 빠르게 이동하기 위해

[23:27] 모든 것에 단축 코드를 사용해요.

[23:29] 모든 주요 브랜치들이 보이네요.

[23:32] 이제 브랜치 2를 병합하겠습니다.

[23:33] start client가 있는 걸 볼 수 있어요.

[23:36] 이걸 커밋하고

[23:37] 그 브랜치를 병합해봅시다.

[23:40] 이걸 복사하고 다른 엔지니어와 하듯이

[23:42] git merge로 이 브랜치를 실행합니다.

[23:44] 짠! 모든 변경사항들이 여기 있어요.

[23:46] 원래 브랜치를 확인할 수 있습니다. 여기에

[23:48] 원래 버전이 있어요. 새로고침하면,

[23:50] 앗. vite 파일을 열어보면,

[23:52] 병합이 잘 되었다는 걸 확인할 수 있습니다. 그래서

[23:55] 이걸 원래 상태로 되돌릴 거예요

[23:56] 포트를. 스크립트를 실행해 볼게요

[23:58] 여기서. 이걸 열어서. 그리고 thoughtbench로 들어가면

[24:00] 이제 물론 새로 업데이트된 버전을 볼 수 있습니다. 그래서

[24:02] 새로 업데이트된 버전을 확인할 수 있어요. 앞서 말했듯이, 여전히

[24:06] 몇 가지 수정할 부분이 있죠? 확실히 해야 할 게

[24:07] 이 텍스트가

[24:08] 읽기 쉽도록 하는 거예요. 음, 이제 다시

[24:10] 메인 브랜치로 돌아가서 원한다면, 빠른 변경사항을

[24:12] 배포해서

[24:14] 텍스트가 읽기 쉽게 만들 수 있어요,

[24:16] 항상 Claude 인스턴스를 열어서

[24:18] 이런 변경사항들을 수정할 수 있거든요. 지금은

[24:21] 그런 건 중점적으로 다루지 않을 거예요. 단지

[24:23] 이 흥미로운 아이디어를 강조하고 싶었어요

[24:24] 여러 에이전트가 백그라운드에서

[24:27] 병렬로 작업하는 것 말이에요. 이제

[24:29] 이 애플리케이션의 여러 버전을

[24:31] 선택할 수 있게 되었습니다

[24:33] 골라서 사용할 수 있어요

[24:35] 그리고 가능성은 정말 무한합니다

[24:37] 여기서. 원하는 만큼 많은 에이전트를 설정할 수 있어요

[24:39] Beni 코드베이스를 확인해보시면

[24:41] 설명란에 링크가 있는데, 저는

[24:43] nit parallel도 있어요. 더

[24:45] 동적인 접근 방식을 취해서

[24:47] 원하는 만큼 많은 병렬 워크 트리를

[24:50] 한 번에 생성할 수 있어요. 좋아요. 그리고

[24:53] 이게 가능하게 하는 건, 다시 한 번,

[24:54] 세 개의 에이전트만 실행하는 대신,

[24:56] 3개에서 n개까지의 에이전트를 실행할 수 있다는 거예요

[24:59] 그리고 여기서 전체 목적은

[25:00] 우리가 찾고 있는 미래에 대한 여러 가지 기회를 갖는 거죠?

[25:03] 여러 관점을 가지고

[25:04] 여러 버전을 갖는 거예요

[25:06] 일부는 성공적이고 우리는 선택할 수 있어요

[25:09] 최고를 선택할 수 있다는 거죠

[25:11] 이것이 Git 워크 트리 병렬 에이전틱

[25:14] 코딩입니다. 작업을 계획하고 여러 에이전트를

[25:17] Git 워크 트리로 병렬 실행하고

[25:20] 최고를 선택해서 최고를 병합한 다음

[25:22] 계속 배포하는 것이에요. 이를 통해 여러 개의

[25:25] 최고 버전을 선택할 수 있어요. 단순히

[25:27] 빠르게 작성하는 게 아니라, 단순히

[25:29] 회사를 위해 많은 가치를 생성하는 게 아니라

[25:30] 작업을 위해 가치를 생성하는 거예요

[25:32] 작업과 회사를 위한 n가지 가능성 중

[25:35] 최고를 생성하는 거예요

[25:36] 엔지니어링을 위해, 최고를 병합하는 것이

[25:39] 우리가 탐구하고 있는 여러 방법 중 하나일 뿐이에요

[25:42] 컴퓨팅을 통해 엔지니어링 임팩트를 최대화하는 방법을. 구독을

[25:45] 꼭 하시고, 아직 하지 않으셨다면

[25:47] Principled AI 코딩을 꼭 확인해 보세요

[25:49] 이것은 제가 만든 기초 과정으로

[25:52] 오늘날과 미래의 AI 코딩 도구로

[25:54] 뛰어난 성과를 내도록 도와드리기 위해서예요

[25:56] 이 과정에서는 구식 AI를 사용해요

[25:59] 코딩 도구인 Ader를. 제가 지금 작업하고 있는

[26:01] 다음 과정에서는

[26:03] 매주매주 말하자면,

[26:06] 에이전틱 코딩에 대해 훨씬 더 많이

[26:08] 이야기할 예정이에요. 하지만 정말 중요한 건

[26:10] 기초를 다지는 거예요

[26:12] 괜찮죠? 이 과정에서

[26:14] 기초를 다지고, AI 코딩의

[26:16] 원칙을 설정해요. 그리고 이것이 제가

[26:18] 말 그대로 이 과정이 출시된 지 6개월 후에도

[26:21] 여전히 이 과정을 참조할 수 있는

[26:22] 유일한 방법이에요. 그리고

[26:25] 이 안에 있는 아이디어들이 있죠. 맥락, 모델,

[26:27] 프롬프트, 초급에서 중급으로

[26:29] 고급까지, 모든 것이 거기에 있습니다. 확실히

[26:32] 이 코스에 내재된 가치를 얻으세요.

[26:34] 루프를 닫으세요. 코드가

[26:35] 스스로 작성하도록 하세요. ADWs, 여기서 보신 것처럼, AI

[26:38] 개발자 워크플로우, 일명

[26:40] 에이전틱 워크플로우입니다. 이것은 현실이에요.

[26:42] 이제 더 이상 하기 어려운 것이 아닙니다.

[26:44] 지금 당장 할 수 있는 일이에요.

[26:46] 추가적인 추진력이 필요하다면,

[26:48] 다음에 올 것에 대비하고 싶다면,

[26:51] 원칙적 AI 코딩을 확인해보세요. 제가

[26:53] 언급했듯이, 현재 이 코스의 파트

[26:56] 2, 2단계를 활발히 작업하고 있는데

[26:58] 원칙적 코딩에서 우리가 해온 모든 것을

[27:00] 에이전틱 코딩과 함께

[27:01] 다음 단계로 밀어넣을 거예요. Claude 4가

[27:04] 여기 있습니다. Claude Code는 연구

[27:07] 프리뷰에서 벗어났어요. 이 모든 것이 큰 뉴스입니다. Claude 4

[27:10] Opus는 미친 수준이에요. Claude 4 Sonnet은

[27:13] 훌륭한 워크호스입니다. 우리는 더 많은 도구를 가지고

[27:16] 컴퓨팅을 활용할 수 있어요. 이 아이디어들을 가져다가,

[27:19] 동시에 여러 에이전트와 함께 작성하세요.

[27:21] 더 많은 일을 완수하세요.

[27:23] N개 중 최고를 선택하세요. 여러분은

[27:25] 그 어느 때보다 많은 컴퓨팅 파워를 사용할 수 있습니다. 저는 정말, 정말

[27:28] 이 도구에 투자하기를 권합니다.

[27:30] 제가 Claude에 대해 이야기하는 이유가 있어요

[27:32] Code를 말 그대로 매달 지금까지.

[27:35] 알다시피, 말 그대로 8개 비디오를

[27:36] 연속으로요. 왜냐하면 저는 신호를 감지할 수 있기 때문입니다.

[27:39] 그리고 여기서 우리가 본 것처럼

[27:42] Claude와의 코드, 알다시피, 발표

[27:44] 그리고 여기서 발표된 모든 것들, 저는

[27:46] 여러분도 신호를 보기 시작할 수 있기를 바랍니다

[27:47] Claude Code는 차별화된

[27:50] 에이전틱 코딩 도구입니다. 이전

[27:52] 비디오들을 확인해서 더 이해하세요. 여기에는 많은

[27:54] 더 논의할 것들이 있어요. 더 많은

[27:56] 우위를 여러분에게 드릴 것이 있습니다. 그러니 확실히

[27:57] 놓치지 마세요. 우리는

[27:59] 에이전트 코딩 미래로 밀고 나가고 있습니다. 우리는 이제

[28:02] 여러 에이전트를 병렬로 실행하여

[28:05] 컴퓨팅을 확장하고, 성공을 확장하고 있습니다.

[28:08] 매주 월요일마다 저를 어디서 찾을 수 있는지 알고 계시죠.

[28:11] 집중력을 유지하고 계속 구축하세요.