메뉴
HN
Hacker News 19일 전

AI가 코드를 짜준다면, 굳이 파이썬 써야 하나?

IMP
9/10
핵심 요약

AI 코딩 에이전트의 비약적 발전으로 파이썬이나 JS 같은 쉬운 언어보다 컴파일러 피드백 루프가 확실한 Rust, Go 같은 시스템 언어가 더 유리해졌습니다. 실제로 마이크로소프트의 TypeScript 7.0(Go 이식)부터 Ladybird 브라우저 엔진의 Rust 이식까지, 단 몇 주 만에 수만 줄의 프로덕션 코드가 재작성되며 패러다임 전환이 현실화되고 있습니다.

번역된 본문

AI가 코드를 대신 짜준다면, 왜 파이썬을 써야 할까? (원문: If AI Writes Your Code, Why Use Python?, Noah Mitchem, 2026년 4월 28일)

지난 10년간 '빠른 실행 속도'보다 '빠른 출시(개발 속도)'가 승리했다. 이제는 그렇지 않다.

새 프로젝트를 위한 프로그래밍 언어를 고르는 것은 대개 간단한 문제였다. 파이썬이나 TypeScript를 사용했다. 왜냐하면 생태계가 방대하고, 채용할 수 있는 인재 풀이 깊었으며, 금요일까지 인상적인 데모를 만들 수 있었기 때문이다. Rust, Go, C++ 등은 10~100배 더 뛰어난 성능을 제공했지만, 그 대가를 치러야 했다. 6개월의 적응 기간, 좁은 인재 시장, 불편한 빌드 시스템 등이 그것이다. 그래서 당신은 파이썬 버전을 출시하고, 고객에게 판 뒤, '나중에 성능을 최적화하겠다'고 자신과 약속했다. 당신이 그 약속을 지킨 적은 거의 없었지만, 그래도 괜찮았다. 다른 누구도 그렇게 하지 않았으니까.

하지만 그 거래는 끝났다. AI가 어려운 언어들을 능숙하게 다루게 되었기 때문이다.

어려운 언어들이 먼저 쉬워졌다 2년 전만 해도 GPT-4는 환각(Hallucination) 현상을 일으키며 크레이트(Crate) 이름조차 제대로 적지 못해 제대로 된 Rust 함수 하나 쓰지 못했다. 그러나 2026년 4월, Claude Opus 4.7, GPT-5.5, Gemini 3.1, DeepSeek V4는 몇 주 사이에 모두 SWE-bench Verified에서 80% 이상의 정확도를 기록했다. AI 연구소들은 동시성 버그, 레이스 컨디션(Race conditions), 기획 단계에서 식별된 아키텍처 결함 등 시스템 작업을 공개적으로 최적화하고 있다.

지난달 CtrlAltDwayne이 트윗에 올린 가장 훌륭한 한 줄 설명은 이렇다: "2026년에 Rust를 써야 하는 가장 좋은 이유는 메모리 안전성이나 성능이 아니다. AI가 C++보다 더 나은 Rust 코드를 작성하기 때문이다. 컴파일러 피드백 루프가 매우 촘촘하여 모델이 실시간으로 스스로를 교정한다. 모든 에러 메시지는 무료 훈련 신호(Free training signal)가 된다. Rust는 누구도 그 중요성을 알지 못했던 10년 전에 AI 보조 개발을 위해 우연히 설계되었다."

같은 논리가 다양한 정도로 Go와 Swift에도 적용된다. 강력한 타입 시스템과 빠른 컴파일 및 확인 루프는 에이전트에게 가장 타이트한 반복 주기를 제공한다. 인간에게 가장 어려웠던 시스템 언어가 에이전트에게는 가장 쉬운 언어로 판명된 것이다.

실제로 출시된 결과물들 단 한 분기 동안 공개된 결과물들을 보라.

마이크로소프트는 TypeScript 컴파일러를 Go로 재작성했다. 세계에서 가장 많이 사용되는 JavaScript 상위 집합을 만든 팀은 지난주 TypeScript 7.0 베타를 출시했다. 10년 된 TypeScript 코드베이스를 Go로 포팅하여 버전 6.0보다 약 10배 빠르다. Anders Hejlsberg의 이유는 이랬다: Go는 엔지니어링 비용의 극히 일분으로 대부분의 성능 이점을 제공했다. 지구상에서 가장 큰 JS/TS 기업이 그들의 핵심 도구를 위해 더 어렵고 빠른 언어를 선택했다. 그들은 노력의 계산 방식이 그들 발밑에서 변했기 때문에 그렇게 했다.

Anthropic의 연구원인 Nicholas Carlini는 16개의 병렬 Claude 에이전트를 조율하여 Rust로 프로덕션 C 컴파일러를 작성했다. 10만 줄의 코드다. 이 컴파일러는 x86, ARM, RISC-V에서 Linux 6.9를 부팅한다. QEMU, FFmpeg, SQLite, PostgreSQL, Redis를 컴파일한다. 심지어 둠(Doom)도 돌아간다. 약 2,000번의 Claude Code 세션에 걸쳐 들인 총비용은 20,000달러 조금 못했다. 과거 Rust로 C 컴파일러를 작성하는 것은 대학원 석사 논문 주제였다. 이제는 그렇지 않다.

'The Rust Programming Language'를 공동 저술한 13년 차 Rust 베테랑 Steve Klabnik은 Claude와 함께 2주 만에 Rue라는 새로운 시스템 언어를 구축했다. 대략 7만 줄의 Rust 코드다. 그의 말이다: "이번에 작업한 지 2주 만에 전번에 들였던 한두 달보다 더 많은 진전을 이뤘습니다."

Ladybird 브라우저의 창시자이자 평생 C++ 엔지니어인 Andreas Kling은 Claude Code와 Codex에게 수백 개의 작은 프롬프트를 지시하여 단 2주 만에 Ladybird의 JavaScript 엔진을 C++에서 Rust로 포팅했다. 대략 25,000줄의 Rust 코드이며, 원래 C++ 코드와 바이트 단위로 완벽히 일치하고, 65,000개 이상의 test262 및 Ladybird 테스트에서 단 한 건의 회귀(Regression)도 발생하지 않았다. "이 같은 작업은 제가 직접했다면 몇 달이 걸렸을 것입니다."

이 모든 것은 2024년에는 불가능했다. 2025년에는 간신히 가능했다. 2026년 초에는 이제 흔한 일이 되어가고 있다.

'하지만 생태계는 어떻고?' 논란은 이것으로 끝 파이썬과 JavaScript를 위한 가장 강력한 논거는 언어 자체가 아니었다. 바로 생태계였다: FastAPI, Django, PyTorch, React, Next.js, npm의 400만 개 패키지. "우리 팀은 며칠 만에 기능을 출시합니다. 왜냐하면 생태계가 모든 문제의 90%를 이미 해결해 놓았기 때문입니다." 이는 지난 시절에는 결정적인 이유였다.

원문 보기
원문 보기 (영어)
If AI Writes Your Code, Why Use Python? Noah Mitchem 7 min read · Apr 28, 2026 -- 21 Listen Share For the last decade, fast-to-ship beat fast-to-run. Not anymore. Picking a language for a new project was usually an easy answer. You used Python or TypeScript because the ecosystems were enormous, the hiring pool was deep, and you could make an impressive demo by Friday. Rust, Go, C++, and many more would give you 10–100x the performance, but you paid for it: six months of ramp, a smaller talent market, a build system that fought you. So you shipped the Python version, sold it to customers, and promised yourself you’d “make it performant later.” You rarely did, and that was fine, because nobody else did either. That bargain is over, and it’s over because AI got good at the hard languages. The hard languages got easy first Two years ago, GPT-4 couldn’t write a Rust function without hallucinating crate names. By April of 2026, Claude Opus 4.7, GPT-5.5, Gemini 3.1, and DeepSeek V4 had all cleared 80% on SWE-bench Verified within weeks of each other. The labs are openly optimizing for systems work: concurrency bugs, race conditions, and architectural flaws identified during the planning phase. The best one-tweet explanation came from CtrlAltDwayne last month: “The best argument for Rust in 2026 is not memory safety or performance. It is that AI writes better Rust than it writes C++. The compiler feedback loop is so tight that models self-correct in real time. Every error message is a free training signal. Rust was accidentally designed for AI-assisted development 10 years before anyone knew that mattered.” via X.com The same logic applies, to varying degrees, to Go and Swift. Strong type systems plus fast compile-and-check loops give agents the tightest iteration cycle. The systems languages that were hardest for humans turn out to be the easiest for agents. What actually shipped Look at what landed in a single quarter. Microsoft rewrote the TypeScript compiler in Go. The team behind the most-used superset of JavaScript shipped TypeScript 7.0 beta last week, roughly 10x faster than 6.0, by porting the decade-old TypeScript codebase to Go. Anders Hejlsberg’s reasoning : Go delivered most of the performance benefit at a fraction of the engineering cost. The biggest JS/TS shop on earth picked a harder, faster language for its flagship tool, and they did it because the effort calculus changed under them. Nicholas Carlini, a researcher at Anthropic, orchestrated 16 parallel Claude agents to write a production C compiler in Rust. 100,000 lines. It boots Linux 6.9 on x86, ARM, and RISC-V. It compiles QEMU, FFmpeg, SQLite, PostgreSQL, and Redis. It runs Doom. Total cost: just under $20,000 across nearly 2,000 Claude Code sessions. A C compiler written in Rust used to be a graduate thesis. It isn’t anymore. Steve Klabnik, a 13-year Rust veteran who co-wrote The Rust Programming Language, built a new systems language called Rue in two weeks with Claude. Roughly 70,000 lines of Rust. His own words: I’ve gotten further in the two weeks I’ve been working on it this time than the month or two I spent last time. Andreas Kling, creator of the Ladybird browser and a career C++ engineer, ported Ladybird’s JavaScript engine from C++ to Rust in two weeks by directing Claude Code and Codex through hundreds of small prompts. Roughly 25,000 lines of Rust, byte-for-byte parity with the C++ original, zero regressions across 65,000+ combined test262 and Ladybird tests. “The same work would have taken me multiple months to do by hand.” None of this was possible in 2024. In 2025 it was marginal. In early 2026 it’s becoming commonplace So much for “but the ecosystem” The strongest argument for Python and JavaScript was never the languages themselves. It was the ecosystems: FastAPI, Django, PyTorch, React, Next.js, npm’s 4 million packages. “Our team ships features in days because the ecosystem already solved 90% of every problem.” That was decisive for the last 10 years. It’s been quietly eroding for the last 2. When you `import pydantic`, the entire validation core is a Rust library. Polars, the pandas alternative, is Rust. Hugging Face tokenizers is Rust. orjson is Rust. The JetBrains 2025 Python survey caught the telemetry: Rust usage for Python binary extensions jumped from 27% to 33% in one year. The Python ecosystem is increasingly a Rust ecosystem wearing a Python hat. The plumbing is following the same trajectory. Astral, founded by Charlie Marsh in 2022, shipped ruff, uv, and ty. All three are written in Rust, and all three went from zero to hundreds of millions of monthly downloads. On March 19, 2026, OpenAI acquired Astral ; the internal justification was that uv saves Codex roughly one million minutes of compute per week. Ten weeks earlier, Anthropic acquired Bun (7M monthly downloads, 89K GitHub stars) and framed it as “essential infrastructure for AI-led software engineering.” Evan You’s VoidZero shipped Rolldown-Vite , a Rust bundler that cut GitLab’s 2.5-minute build to 40 seconds with 100x less memory. Lee Robinson, VP of Product at Vercel: “We’ve reached peak optimization with JS.” What’s left of “but the ecosystem” is this: the packages you import in Python and JavaScript are increasingly wrappers around code written in languages you were told you couldn’t ship in. Now you can ship in those languages directly, and the wrapper is starting to look like overhead. Why patch when you can port? The old open-source bargain had a positive feedback loop. You pick Python because it’s easy. You find a bug in a dependency. You fix it. You upstream the fix. The ecosystem gets healthier. Agents broke that loop in a specific way: the unit of contribution shifted from the patch to the port. Armin Ronacher, the creator of Flask, ported his Rust library MiniJinja to Go in January using an agent. The run lasted 10 hours, 3 supervised and 7 unattended. His actual human time was 45 minutes. The API cost was $60. If porting a library across languages is a 45-minute job, the case for upstreaming a fix to someone else’s library gets weaker every month. Why patch what you can fork? His own observation: For me, the value is shifting from the code to the tests and documentation. A good test suite might actually be worth more than the code. The loop that built PyPI and npm still works today. It is not obvious it works in 2028. Where this argument breaks This isn’t a clean sweep. A few things are worth admitting. First, sometimes the right answer is still the old answer. Prisma removed its Rust query engine in favor of a TypeScript/WASM core: bundle size dropped 85%, queries got up to 3.4x faster. Native Rust binaries are hostile to serverless runtimes. PyTorch still owns roughly 85% of deep-learning research, and that isn’t changing because the model weights don’t care what language you wrap around them. Secondly, AI is not equally good at every systems language. Smaller languages like Zig, Haskell and Gleam don’t have the same quality when AI-generated (for now). Training data shapes what the model can help you with. Rust and Go won the lottery because they were popular enough to flood GitHub. Zig, Haskell and Gleam are still on the wrong side of that curve. The reason the shift is permanent The old defense of Python and TypeScript was really a defense of the developer experience. Those languages were chosen because they minimized the friction between a human’s idea and a shipped product. Rust was never slower at runtime; it was slower at 2am when you had to ship. Agents do the hard part now. The human’s job shifted from “writing the code” to “architecting the system and reviewing the output.” In that workflow, Python’s ergonomic advantages matter less every quarter, and a harder language’s runtime advantages compound every day you run the service in production. Armin Ronacher, in his February essay A Language For Agents : The biggest reason new languages might work is that the cost of codin