서론
2025년 3월, Andrej Karpathy가 공개한 짧은 데모 영상 하나가 AI 커뮤니티를 술렁이게 만들었다. “AutoResearch"라는 프로젝트였는데, 핵심은 간단했다: 사용자가 연구 주제를 입력하면, LLM 에이전트가 자율적으로 논문을 검색하고, 내용을 종합하고, 브라우저에 보고서를 생성한다.
놀라운 것은 그가 작성한 코드가 단 78줄이었다는 점이다.
1
2
3
4
5
6
7
8
| # Karpathy의 AutoResearch 핵심 컨셉 (요약)
async def auto_research(topic: str):
papers = await search_arxiv(topic)
for paper in papers:
content = await read_paper(paper.url)
summary = await llm.summarize(content)
# 브라우저에서 실시간으로 작업 과정을 보여줌
return generate_report(summaries)
|
이 작은 프로젝트가 시사하는 바는 크다. 우리는 이제 “코드를 짜는 것"이 아니라 “의도를 표현하는 것"으로 소프트웨어 개발의 패러다임이 이동하고 있다. 그리고 이 변화는 단순히 개발자의 생산성 문제가 아니다. 모든 조직이 어떻게 일하고, 어떻게 가치를 창출하는지를 근본적으로 재편하고 있다.
본문에서는 2026년 현재 AI 엔지니어링을 지배하는 5가지 핵심 아이디어를 분석하고, 이들이 어떻게 상호 강화하며 새로운 패러다임을 형성하는지 살펴본다.
본론
1. 자율적 구성 요소 개선 (Autonomous Component Improvement)
전통적인 소프트웨어 개발에서는 인간 엔지니어가 버그를 수정하고 성능을 최적화한다. 하지만 AI 시스템은 스스로 개선될 수 있다. 이것이 “자율적 구성 요소 개선"의 핵심이다.
작동 원리: LLM 기반 에이전트가 자신의 출력을 평가하고, 피드백 루프를 통해 지속적으로 개선한다. 이는 RLHF(Reward Modeling from Human Feedback)의 연장선에 있지만, 훨씬 더 자율적이다.
1
2
3
4
5
6
7
8
9
| graph TD
A[초기 코드 생성] --> B[자동 테스트 실행]
B --> C{결과 평가}
C -->|실패| D[에러 분석]
D --> E[수정 제안 생성]
E --> A
C -->|성공| F[성능 프로파일링]
F --> G[최적화 적용]
G --> H[배포]
|
실제 구현 예시 (PyTorch 기반 자율 개선 루프):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
| import torch
from dataclasses import dataclass
from typing import Callable, Optional
import asyncio
@dataclass
class ImprovementLoop:
model: torch.nn.Module
evaluator: Callable
improver: Callable # LLM-based code improver
max_iterations: int = 10
threshold: float = 0.95
async def run(self, initial_code: str) -> str:
current_code = initial_code
for i in range(self.max_iterations):
# 1. 평가 단계
score, feedback = await self.evaluator(current_code)
print(f"Iteration {i}: Score = {score:.3f}")
if score >= self.threshold:
print("Threshold reached!")
break
# 2. 개선 제안 생성 (LLM 호출)
improvement = await self.improver(
code=current_code,
feedback=feedback,
iteration=i
)
# 3. 적용 및 검증
current_code = improvement.updated_code
return current_code
# 사용 예시
async def evaluate_code(code: str) -> tuple[float, str]:
"""코드 품질 평가 - 단위 테스트, 정적 분석 등"""
test_results = await run_tests(code)
coverage = calculate_coverage(test_results)
complexity = analyze_complexity(code)
score = 0.4 * coverage + 0.3 * (1 - complexity/100) + 0.3 * test_results.pass_rate
feedback = generate_feedback(test_results, complexity)
return score, feedback
|
이 패턴의 실제 적용 사례로는 Anthropic의 “Constitutional AI"와 Google DeepMind의 “AlphaCode 2"가 있다. 시스템이 자신의 출력을 비판하고 개선하는 능력은 인간 개발자의 개입 없이도 지속적인 품질 향상을 가능하게 한다.
2. 의도 기반 엔지니어링 (Intent-Based Engineering)
“어떻게"가 아니라 “무엇을” 지정하는 것. 이것이 의도 기반 엔지니어링의 핵심이다.
전통적 접근 vs 의도 기반 접근:
| 측면 | 전통적 엔지니어링 | 의도 기반 엔지니어링 | |:—|:—|:—| | 핵심 질문 | “어떻게 구현할까?” | “무엇을 원하는가?” | | 프롬프트 형태 | 구체적 지시사항 | 목표와 제약조건 | | 오류 처리 | 예외 코드 작성 | 의도 불일치 감지 | | 테스트 방식 | 단위 테스트 작성 | 의도 충족도 검증 | | 문서화 | API 스펙 정의 | 의도 명세서 작성 |
실무 적용 가이드:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
| from pydantic import BaseModel, Field
from typing import Literal
import anthropic
class Intent(BaseModel):
"""의도 명세서 - 구현 방법이 아닌 목표 정의"""
goal: str = Field(description="달성하고자 하는 목표")
constraints: list[str] = Field(default_factory=list)
success_criteria: list[str] = Field(default_factory=list)
priority: Literal["speed", "accuracy", "cost"] = "balanced"
class IntentBasedEngineer:
def __init__(self, client: anthropic.Anthropic):
self.client = client
async def realize(self, intent: Intent) -> str:
"""의도를 실제 코드로 변환"""
prompt = f"""
사용자 의도:
- 목표: {intent.goal}
- 제약조건: {intent.constraints}
- 성공 기준: {intent.success_criteria}
- 우선순위: {intent.priority}
위 의도를 충족하는 코드를 작성하라.
구현 세부사항은 당신의 판단에 맡긴다.
"""
response = self.client.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=4096,
messages=[{"role": "user", "content": prompt}]
)
return response.content[0].text
# 실제 사용 예시
intent = Intent(
goal="사용자 이메일 목록에서 중복을 제거하고 도메인별로 그룹화",
constraints=[
"메모리 사용량 100MB 이하",
"100만 개 이메일 처리 가능"
],
success_criteria=[
"O(n) 시간복잡도",
"원본 순서 보존"
],
priority="speed"
)
|
이 접근법의 핵심은 추상화 수준을 높이는 것이다. 개발자는 구현 세부사항보다 비즈니스 로직과 의도에 집중하게 된다.
3. 투명성 전환 (Transparency Transition)
AI 시스템이 “블랙박스"에서 “글래스박스"로 진화하고 있다. 2026년의 AI 엔지니어링에서는 설명 가능성이 선택이 아닌 필수다.
1
2
3
4
5
6
7
| graph LR
A[입력] --> B[AI 시스템]
B --> C[출력]
B --> D[의사결정 경로]
D --> E[신뢰도 점수]
D --> F[근거 제시]
D --> G[대안 제안]
|
투명성 확보를 위한 기술 스택:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| from typing import TypedDict, list
import json
class Explanation(TypedDict):
reasoning_steps: list[str]
confidence: float
sources: list[str]
alternatives: list[str]
class TransparentAI:
def __init__(self, base_model):
self.model = base_model
self.explanation_buffer = []
def generate_with_explanation(
self,
prompt: str,
require_sources: bool = True
) -> tuple[str, Explanation]:
"""투명한 추론 과정을 포함한 응답 생성"""
# Chain-of-Thought 프롬프팅
cot_prompt = f"""
{prompt}
다음 형식으로 응답하라:
1. 추론 과정 (단계별)
2. 최종 답변
3. 신뢰도 (0-1)
4. 참조 소스
5. 대안적 해석
"""
raw_response = self.model.generate(cot_prompt)
explanation = self._parse_explanation(raw_response)
# 의사결정 로그 저장 (감사용)
self._log_decision(prompt, explanation)
return explanation["final_answer"], explanation
def _parse_explanation(self, response: str) -> Explanation:
"""응답에서 설명 요소 추출"""
# 실제로는 더 정교한 파싱 필요
return {
"reasoning_steps": [],
"confidence": 0.0,
"sources": [],
"alternatives": []
}
def _log_decision(self, prompt: str, explanation: Explanation):
"""의사결정 과정을 로그에 저장"""
self.explanation_buffer.append({
"timestamp": datetime.now().isoformat(),
"prompt": prompt,
"explanation": explanation
})
|
이 투명성은 단순히 “설명"을 넘어 **감사 가능성(auditability)**과 **책임 소재 파악(accountability)**으로 이어진다. 특히 금융, 의료, 법률 분야에서는 이것이 규제 요건이 되고 있다.
4. 스캐폴딩 인식 (Scaffolding Awareness)
스캐폴딩(Scaffolding)은 AI 시스템이 작업을 수행할 때 사용하는 지원 구조다. 이를 인식하고 최적화하는 것이 핵심 역량이 되었다.
스캐폴딩의 종류:
| 유형 | 설명 | 예시 | |:—|:—|:—| | 프롬프트 스캐폴딩 | LLM 입력 구조화 | Few-shot 예제, CoT 유도 | | 도구 스캐폴딩 | 외부 도구 연결 | 검색 엔진, 계산기, DB | | 워크플로우 스캐폴딩 | 작업 단계 구조화 | 계획-실행-검증 루프 | | 컨텍스트 스캐폴딩 | 배경 지식 제공 | RAG, 지식 그래프 |
스캐폴딩 최적화 프레임워크:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
| from abc import ABC, abstractmethod
from typing import Generic, TypeVar
T = TypeVar('T')
class Scaffold(ABC, Generic[T]):
"""스캐폴딩 추상 클래스"""
@abstractmethod
def build(self, task: str) -> T:
pass
@abstractmethod
def evaluate(self, result: T, task: str) -> float:
pass
@abstractmethod
def adapt(self, feedback: float) -> 'Scaffold[T]':
pass
class PromptScaffold(Scaffold[str]):
"""프롬프트 스캐폴딩 구현"""
def __init__(self, examples: list[str], template: str):
self.examples = examples
self.template = template
self.adaptation_history = []
def build(self, task: str) -> str:
examples_text = "
".join([
f"예시 {i+1}:
{ex}"
for i, ex in enumerate(self.examples)
])
return self.template.format(
examples=examples_text,
task=task
)
def evaluate(self, result: str, task: str) -> float:
# 결과 품질 평가 (예: 정확도, 완성도)
return self._quality_score(result, task)
def adapt(self, feedback: float) -> 'PromptScaffold':
# 낮은 피드백일 경우 예제 추가/수정
if feedback < 0.7:
# 새로운 예제 생성 또는 기존 예제 수정
new_example = self._generate_better_example()
self.examples.append(new_example)
self.adaptation_history.append(feedback)
return self
class DynamicScaffoldOptimizer:
"""스캐폴딩 동적 최적화"""
def __init__(self, scaffold: Scaffold):
self.scaffold = scaffold
self.performance_window = []
async def optimize(self, tasks: list[str], iterations: int = 5):
for i, task in enumerate(tasks):
built = self.scaffold.build(task)
result = await self._execute(built)
score = self.scaffold.evaluate(result, task)
self.performance_window.append(score)
# 적응적 조정
if len(self.
|
1
2
3
4
5
| performance_window) >= 3:
avg = sum(self.performance_window[-3:]) / 3
self.scaffold = self.scaffold.adapt(avg)
return self.scaffold
|
핵심 통찰: 스캐폴딩 비용은 투자다. 잘 설계된 스캐폴딩은 초기 구축 비용이 들지만, 장기적으로 시스템 성능과 신뢰성을 크게 향상시킨다.
5. 전문지식 확산 (Expertise Democratization)
가장 중요하고도 과소평가되는 변화. AI가 전문지식의 진입장벽을 낮추고 있다.
1
2
3
4
5
6
7
8
9
10
| graph TD
A[전문지식] --> B[AI 시스템]
B --> C[자연어 인터페이스]
C --> D[비전문가 접근]
D --> E[새로운 전문가 생성]
E --> A
B --> F[지식 증류]
F --> G[경량 모델]
G --> H[엣지 배포]
|
전문지식 확산의 메커니즘:
- 지식 캡처: 전문가의 암묵지를 명시지로 변환 2. 지식 증류: 대형 모델에서 소형 모델로 지식 전이 3. 지식 전파: 자연어 인터페이스를 통한 접근성 확보
실제 구현: 지식 증류 파이프라인:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
| import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
class KnowledgeDistillation:
"""지식 증류를 통한 전문지식 확산"""
def __init__(
self,
teacher: nn.Module,
student: nn.Module,
temperature: float = 2.0,
alpha: float = 0.7
):
self.teacher = teacher
self.student = student
self.temperature = temperature
self.alpha = alpha # 지식 손실 가중치
# Teacher는 학습하지 않음
for param in self.teacher.parameters():
param.requires_grad = False
def distillation_loss(
self,
student_logits: torch.Tensor,
teacher_logits: torch.Tensor,
labels: torch.Tensor
) -> torch.Tensor:
"""증류 손실 계산"""
# Soft targets (teacher의 지식)
soft_loss = nn.KLDivLoss(reduction='batchmean')(
nn.functional.log_softmax(
student_logits / self.temperature, dim=1
),
nn.functional.softmax(
teacher_logits / self.temperature, dim=1
)
) * (self.temperature ** 2)
# Hard targets (실제 정답)
hard_loss = nn.CrossEntropyLoss()(student_logits, labels)
# 결합 손실
return self.alpha * soft_loss + (1 - self.alpha) * hard_loss
def train_step(
self,
batch: dict,
optimizer: torch.optim.Optimizer
) -> float:
"""단일 학습 스텝"""
self.student.train()
self.teacher.eval()
with torch.no_grad():
teacher_outputs = self.teacher(batch['input_ids'])
student_outputs = self.student(batch['input_ids'])
loss = self.distillation_loss(
student_outputs.logits,
teacher_outputs.logits,
batch['labels']
)
optimizer.zero_grad()
loss.backward()
optimizer.step()
return loss.item()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| # 전문지식 확산 워크플로우
async def democratize_expertise(
expert_prompts: list[str],
domain: str
):
"""전문가 프롬프트에서 지식을 추출하고 증류"""
# 1. 전문가 지식 캡처
expert_knowledge = []
for prompt in expert_prompts:
response = await large_model.generate(prompt)
expert_knowledge.append({
"prompt": prompt,
"response": response
})
# 2. 합성 데이터 생성
synthetic_data = generate_training_data(
expert_knowledge,
num_samples=10000
)
# 3. 소형 모델 파인튜닝
small_model = train_with_distillation(
teacher=large_model,
student=small_model_init,
data=synthetic_data
)
# 4. 엣지 배포
quantized = quantize_model(small_model)
deploy_to_edge(quantized, target_devices)
return quantized
|
이 패러다임의 사회적 함의는 깊다. 전문가가 아닌 사람도 전문가 수준의 작업을 수행할 수 있게 되면, 조직 구조와 역할 정의가 어떻게 변할까?
5가지 아이디어의 상호 강화
이 다섯 가지 아이디어는 독립적이지 않다. 서로 강화하며 시너지를 만든다:
| 조합 | 시너지 효과 | |:—|:—| | 자율 개선 + 의도 기반 | 시스템이 의도를 이해하고 자체 최적화 | | 투명성 + 스캐폴딩 | 설명 가능한 지원 구조로 신뢰성 향상 | | 전문지식 확산 + 자율 개선 | 더 많은 사용자가 시스템 개선에 기여 | | 의도 기반 + 투명성 | 의도 충족 여부를 투명하게 검증 | | 스캐폴딩 + 전문지식 | 전문가 지식을 효과적인 스캐폴딩으로 변환 |
결론
핵심 요약
2026년 AI 엔지니어링의 패러다임 변화를 5가지 축으로 정리했다:
- 자율적 구성 요소 개선: AI 시스템이 스스로를 최적화한다 2. 의도 기반 엔지니어링: “어떻게” 대신 “무엇을” 지정한다 3. 투명성 전환: 블랙박스에서 글래스박스로 4. 스캐폴딩 인식: 지원 구조를 의도적으로 설계한다 5. 전문지식 확산: AI가 지식의 진입장벽을 낮춘다
전문가 인사이트
Karpathy의 AutoResearch가 78줄로 구현 가능했던 이유는 이 5가지 아이디어를 직관적으로 통합했기 때문이다.
- 의도 기반: “연구해줘"라는 간단한 지시
- 스캐폴딩: 브라우저라는 외부 도구 활용
- 투명성: 작업 과정을 실시간으로 시각화
- 자율 개선: 에러 발생 시 자체 수정 시도
- 지식 확산: 전문 연구 작업을 비전문가도 수행 가능
앞으로 경쟁력 있는 AI 조직은 이 5가지를 개별 기술이 아닌 통합 시스템으로 구현할 것이다. 단일 기능 AI 도구가 아니라, 이 패러다임들이 상호 작용하는 생태계를 구축하는 것이 핵심 과제다.
참고 자료
출처: https://news.hada.io/topic?id=28166