a16z Podcast
Summary & Insights
The gap between writing a line of code and maintaining a living system in production is a chasm of complexity that AI has yet to fully cross. While Large Language Models (LLMs) have mastered the “syntax”—the digital representation of logic—they struggle with “semantics,” which in this context refers to the actual runtime behavior of a system. The challenge is that a program’s behavior is not just a product of its code, but a result of its interaction with unpredictable workloads, hardware constraints, and a state space that expands exponentially with every added bit of data.
Jad Naous, CEO of Grepr, argues that AI’s success in coding stems from the fact that it was trained on a manageable manifold of all human-written code. However, operational systems are “heavy-tailed” and exception-based. Naous posits that while AI can now write remarkable amounts of production code, running a system requires reasoning about things that are not contained in the training data, such as a specific server’s memory spike or a sudden change in traffic patterns. He views the world of AI as a digital simulation that is often discordant with the messy, physical reality of infrastructure.
The intellectual exchange between Naous and a16z centers on whether this operational gap is an insurmountable wall or a solvable engineering problem. a16z suggests that the path forward is not to ask AI to predict failures—which is computationally irreducible—but to use AI to manage the workflow of debugging. By treating operations as a series of deterministic steps (detecting a change, forming a hypothesis, running an experiment), a16z argues that AI can simulate the role of a human SRE (Site Reliability Engineer) to constrain a nearly infinite state space into something manageable.
Naous illustrates this transition through his work at Grepr, where he moves beyond simple observability. He argues that companies have historically bought observability as a proxy for reliability, but the marginal return on that investment has flattened. Grepr’s approach is to extract signal from the data stream upstream, reducing costs by up to 90%, and then feeding those high-fidelity signals into an AI layer. This AI doesn’t just alert; it reasons through the signal to determine if a new log pattern is a meaningful anomaly or mere noise.
A significant portion of the dialogue explores the “leverage” AI provides to engineers. Naous claims that the disparity between average and elite engineers has multiplied tenfold. Because AI handles the syntax, the elite engineer’s value now lies in their ability to manage architectural complexity and break down massive problems into tasks an AI can execute. Naous shares a striking example of shipping a complex “auto-promotion” feature in a data lake in ten days—a project that would have previously taken a single engineer six months.
Ultimately, the conversation pivots to a philosophical debate on the limits of AI. a16z remains optimistic that the “distributional” success of AI in code will eventually expand to operations. Naous is more cautious, suggesting that some problems are computationally irreducible—you simply have to run the system to see what happens. He suggests that the future may not be AI “solving” the real world, but humans changing the real world to fit the constraints that AI can actually manage.
Major Discussion Themes
Syntax vs. Semantics in Software
Naous and a16z distinguish between the “syntax” of code (the characters typed) and the “semantics” (what the machine actually does at runtime). They argue that LLMs are masters of syntax because they have seen nearly every possible way to write a function. However, semantics are influenced by external factors—schema, data shape, and hardware—which are often invisible to the model. This distinction explains why AI can write a distributed algorithm but cannot tell you how much RAM to allocate to it.
The “Leverage Gap” in Engineering
Naous observes a widening productivity gap between senior architects and junior developers. Since AI handles the boilerplate and routine implementation, the “bottleneck” has shifted to high-level systems thinking. The ability to maintain a complex mental model of a distributed system and decompose it into prompts is now the primary driver of value, allowing a small team (like Naous’s ten-person team) to output the work of a much larger organization.
The Failure of Traditional Observability
Naous critiques the current industry trend of spending 5-20% of infrastructure budgets on observability tools. He argues that more data does not equal more reliability; instead, it creates a “noise” problem. The goal should be shifting from “lagging indicators” (alerting after a spike) to “upstream signal extraction,” where AI identifies a change in the environment before it manifests as a production incident.
Computational Irreducibility and Simulation
a16z and Naous debate whether AI can ever fully replace a human operator. a16z argues that while the state space of a system is effectively infinite, the steps a human takes to debug it are finite and can be modeled. Naous counters with the idea of computational irreducibility—the notion that some systems cannot be predicted and must be simulated or run in real-time to find the answer, placing a hard limit on predictive AI.
Surprising Insights
- The 10x-20x Productivity Jump: Production-grade features that previously took six months for one engineer can now be shipped in roughly ten days using AI agents.
- The Observability Paradox: Spending more on observability tools has reached a point of diminishing returns where the cost of data collection is growing faster than the reliability it provides.
- AI as a Human Trainer: The most effective engineers aren’t just using AI; they are being “trained” by the AI on how to communicate and structure problems more logically.
- The “Coolness” of System Design: Systems engineering is often less about “smart algorithms” and more about over-provisioning (e.g., adding more RAM) because predictive routing and memory management are too unstable.
- The Manifold of Code: AI’s success in coding is attributed to the fact that human-written code exists on a “manageable manifold,” whereas the physical world’s operational states are far more chaotic.
- Venture Capital as a “Kabuki Show”: Naous suggests that the analytical part of VC is now largely commoditized by AI, and the remaining value is purely based on human relationships and access.
- The Security Adversary: Solving AI for security is harder than for operations because security involves an active adversary intentionally seeking out “rare states,” whereas operations deal with “natural” rare states.
Practical Takeaways
- Shift from Alerts to Change Detection: Instead of monitoring for a metric spike (lagging indicator), use AI to detect when a new, unseen pattern emerges in logs (leading indicator).
- Decompose Complexity for Agents: To maximize AI leverage, don’t ask for a whole system; break the project into semantic layers, define the “golden expectations” (tests), and assign sub-agents to parallel tasks.
- Focus on the “Workflow,” Not the “Answer”: When using AI for troubleshooting, don’t ask “Why did this happen?” Instead, prompt the AI to “Run through a hypothesis-verification workflow” to constrain the problem.
- Prioritize Upstream Filtering: Reduce telemetry costs and noise by extracting signals at the source rather than sending raw data to a downstream observability platform.
- Invest in Architectural Thinking: As syntax becomes a commodity, the most valuable skill for engineers is “systems thinking”—the ability to handle high-dimensional complexity and define the boundaries of a problem.
- Use “Golden Expectations” for PRs: With the volume of AI-generated code increasing, the review process should shift from reviewing the code itself to rigorously validating the tests and “golden” output expectations.
🛍️ Products & Resources Mentioned
- ⚡ DeviceWindows Subsystem for Linux (WSL) — Used by Jad Naous to run a Linux kernel within Windows for development without needing a Mac.View on Amazon →
- 🛠️ GearClaude Code — A coding harness/tool used by the guest to manage context and spin up sub-agents for software engineering.View on Amazon →
- 🛠️ GearGitHub Copilot — Mentioned as one of the early AI autocomplete tools the team used when starting their company.View on Amazon →
- 🛠️ GearIntelliJ IDEA — The IDE used in conjunction with AI autocomplete tools for early development workflows.View on Amazon →
Khoảng cách giữa việc viết một dòng mã và việc duy trì một hệ thống đang vận hành thực tế (production) là một vực thẳm về độ phức tạp mà AI vẫn chưa thể vượt qua hoàn toàn. Trong khi các Mô hình Ngôn ngữ Lớn (LLM) đã làm chủ được “cú pháp” (syntax) — tức là sự biểu diễn kỹ thuật số của logic — thì chúng lại gặp khó khăn với “ngữ nghĩa” (semantics), mà trong ngữ cảnh này chính là hành vi vận hành thực tế (runtime behavior) của một hệ thống. Thách thức nằm ở chỗ hành vi của một chương trình không chỉ là sản phẩm của mã nguồn, mà là kết quả của sự tương tác với các khối lượng công việc không thể dự báo, các hạn chế về phần cứng và một không gian trạng thái mở rộng theo cấp số nhân với mỗi bit dữ liệu được thêm vào.
Jad Naous, CEO của Grepr, lập luận rằng thành công của AI trong việc lập trình bắt nguồn từ việc nó được huấn luyện trên một tập hợp hữu hạn các mã nguồn do con người viết. Tuy nhiên, các hệ thống vận hành thực tế lại có đặc điểm “đuôi nặng” (heavy-tailed) và dựa trên các trường hợp ngoại lệ. Naous cho rằng dù AI hiện nay có thể viết một lượng lớn mã nguồn cho production, nhưng việc vận hành một hệ thống đòi hỏi khả năng suy luận về những điều không nằm trong dữ liệu huấn luyện, chẳng hạn như sự tăng vọt bộ nhớ của một máy chủ cụ thể hoặc sự thay đổi đột ngột trong mô hình lưu lượng truy cập. Ông nhìn nhận thế giới của AI như một mô phỏng kỹ thuật số thường xuyên xung đột với thực tế vật lý hỗn loạn của cơ sở hạ tầng.
Cuộc trao đổi trí tuệ giữa Naous và a16z tập trung vào việc liệu khoảng cách vận hành này là một bức tường không thể vượt qua hay là một bài toán kỹ thuật có thể giải quyết được. a16z gợi ý rằng con đường phía trước không phải là yêu cầu AI dự đoán các lỗi — điều vốn không thể giản lược về mặt tính toán (computationally irreducible) — mà là sử dụng AI để quản lý quy trình làm việc (workflow) của việc gỡ lỗi (debugging). Bằng cách coi vận hành là một chuỗi các bước xác định (phát hiện thay đổi, đưa ra giả thuyết, chạy thử nghiệm), a16z lập luận rằng AI có thể mô phỏng vai trò của một kỹ sư SRE (Site Reliability Engineer) để thu hẹp một không gian trạng thái gần như vô hạn thành một thứ có thể quản lý được.
Naous minh họa sự chuyển đổi này thông qua công việc của ông tại Grepr, nơi ông tiến xa hơn việc quan sát đơn thuần (observability). Ông lập luận rằng từ trước đến nay các công ty mua các công cụ quan sát như một phương tiện thay thế cho độ tin cậy, nhưng tỷ suất lợi nhuận biên từ khoản đầu tư đó đã đi ngang. Cách tiếp cận của Grepr là trích xuất tín hiệu từ luồng dữ liệu ở thượng nguồn (upstream), giảm chi phí lên đến 90%, sau đó đưa các tín hiệu có độ trung thực cao này vào một lớp AI. AI này không chỉ cảnh báo; nó suy luận thông qua tín hiệu để xác định xem một mẫu log mới là một điểm bất thường có ý nghĩa hay chỉ là nhiễu.
Một phần đáng kể của cuộc đối thoại khám phá về “đòn bẩy” mà AI cung cấp cho các kỹ sư. Naous khẳng định rằng sự chênh lệch giữa các kỹ sư trung bình và kỹ sư xuất sắc đã tăng gấp mười lần. Vì AI xử lý phần cú pháp, giá trị của một kỹ sư xuất sắc giờ đây nằm ở khả năng quản lý độ phức tạp về kiến trúc và chia nhỏ các vấn đề khổng lồ thành các tác vụ mà AI có thể thực hiện. Naous chia sẻ một ví dụ ấn tượng về việc triển khai tính năng “tự động thăng cấp” (auto-promotion) phức tạp trong một data lake chỉ trong mười ngày — một dự án mà trước đây một kỹ sư đơn lẻ sẽ phải mất sáu tháng để hoàn thành.
Cuối cùng, cuộc trò chuyện chuyển sang một cuộc tranh luận triết học về các giới hạn của AI. a16z vẫn lạc quan rằng thành công mang tính “phân phối” của AI trong lập trình cuối cùng sẽ mở rộng sang lĩnh vực vận hành. Naous thận trọng hơn, cho rằng một số vấn đề là không thể giản lược về mặt tính toán — bạn đơn giản là phải vận hành hệ thống để xem điều gì xảy ra. Ông gợi ý rằng tương lai có thể không phải là AI “giải quyết” thế giới thực, mà là con người thay đổi thế giới thực để phù hợp với những hạn chế mà AI thực sự có thể quản lý.
Các Chủ Đề Thảo Luận Chính
Cú pháp và Ngữ nghĩa trong Phần mềm
Naous và a16z phân biệt giữa “cú pháp” của mã (các ký tự được nhập) và “ngữ nghĩa” (những gì máy tính thực sự thực hiện khi vận hành). Họ lập luận rằng LLM là những bậc thầy về cú pháp vì chúng đã thấy gần như mọi cách có thể để viết một hàm. Tuy nhiên, ngữ nghĩa bị ảnh hưởng bởi các yếu tố bên ngoài — lược đồ (schema), hình dạng dữ liệu và phần cứng — những thứ thường vô hình đối với mô hình. Sự phân biệt này giải thích tại sao AI có thể viết một thuật toán phân tán nhưng không thể cho bạn biết nên cấp phát bao nhiêu RAM cho nó.
“Khoảng cách Đòn bẩy” trong Kỹ thuật
Naous quan sát thấy khoảng cách năng suất ngày càng rộng giữa các kiến trúc sư cao cấp và các lập trình viên sơ cấp. Vì AI xử lý các phần mã lặp lại (boilerplate) và triển khai thông thường, “điểm nghẽn” đã chuyển sang tư duy hệ thống cấp cao. Khả năng duy trì một mô hình tâm trí phức tạp về một hệ thống phân tán và phân rã nó thành các câu lệnh (prompts) hiện là động lực chính tạo ra giá trị, cho phép một nhóm nhỏ (như nhóm mười người của Naous) tạo ra khối lượng công việc của một tổ chức lớn hơn nhiều.
Sự Thất Bại của Quan Sát Truyền Thống
Naous phê phán xu hướng hiện nay của ngành khi chi 5-20% ngân sách cơ sở hạ tầng cho các công cụ quan sát. Ông lập luận rằng nhiều dữ liệu hơn không đồng nghĩa với độ tin cậy cao hơn; thay vào đó, nó tạo ra vấn đề về “nhiễu”. Mục tiêu nên là chuyển từ “các chỉ số trễ” (cảnh báo sau khi có sự tăng vọt) sang “trích xuất tín hiệu thượng nguồn”, nơi AI xác định một thay đổi trong môi trường trước khi nó biểu hiện thành một sự cố vận hành.
Tính Không thể Giản lược về Tính toán và Mô phỏng
a16z và Naous tranh luận về việc liệu AI có bao giờ thay thế hoàn toàn con người trong vận hành hay không. a16z lập luận rằng dù không gian trạng thái của một hệ thống là vô hạn, nhưng các bước mà con người thực hiện để gỡ lỗi là hữu hạn và có thể được mô hình hóa. Naous phản bác bằng khái niệm không thể giản lược về mặt tính toán — quan niệm cho rằng một số hệ thống không thể dự đoán được và phải được mô phỏng hoặc chạy trong thời gian thực để tìm câu trả lời, tạo ra một giới hạn cứng cho AI dự đoán.
Những Thông Tin Bất Ngờ
- Bước nhảy năng suất 10x-20x: Các tính năng cấp độ production mà trước đây một kỹ sư mất sáu tháng để hoàn thành thì nay có thể triển khai trong khoảng mười ngày bằng cách sử dụng các tác nhân AI (AI agents).
- Nghịch lý của Quan sát: Việc chi tiêu nhiều hơn cho các công cụ quan sát đã chạm đến điểm lợi nhuận giảm dần, nơi chi phí thu thập dữ liệu tăng nhanh hơn độ tin cậy mà nó mang lại.
Here is the professional translation into Vietnamese, maintaining the HTML structure:
Bài học thực tiễn
- Chuyển từ Cảnh báo sang Phát hiện thay đổi: Thay vì theo dõi các chỉ số tăng đột biến (chỉ số muộn), hãy sử dụng AI để phát hiện khi một mẫu hình mới, chưa từng thấy xuất hiện trong nhật ký hệ thống (chỉ số dẫn dắt).
- Chia nhỏ sự phức tạp cho các AI Agent: Để tối đa hóa đòn bẩy từ AI, đừng yêu cầu xây dựng cả một hệ thống; hãy chia dự án thành các lớp ngữ nghĩa, định nghĩa các “kỳ vọng chuẩn” (tests) và giao các tác vụ song song cho các agent phụ.
- Tập trung vào “Luồng công việc”, không phải “Câu trả lời”: Khi dùng AI để khắc phục sự cố, đừng hỏi “Tại sao điều này xảy ra?”. Thay vào đó, hãy yêu cầu AI “Thực hiện luồng công việc: giả thuyết và xác minh” để khu trú vấn đề.
- Ưu tiên lọc dữ liệu tại nguồn (Upstream Filtering): Giảm chi phí đo lường (telemetry) và nhiễu bằng cách trích xuất tín hiệu ngay tại nguồn thay vì gửi toàn bộ dữ liệu thô đến nền tảng quan sát (observability platform) ở hạ nguồn.
- Đầu tư vào tư duy kiến trúc: Khi cú pháp lập trình trở thành một thứ phổ biến (commodity), kỹ năng giá trị nhất của kỹ sư là “tư duy hệ thống” — khả năng xử lý sự phức tạp đa chiều và xác định ranh giới của vấn đề.
- Sử dụng “Kỳ vọng chuẩn” cho PR: Với lượng mã nguồn do AI tạo ra ngày càng tăng, quy trình review nên chuyển từ việc xem xét bản thân đoạn code sang việc xác thực nghiêm ngặt các bài kiểm tra và kỳ vọng đầu ra “chuẩn”.
撰寫一行程式碼與維護一個在生產環境中運行的系統之間,存在著一道複雜性的深淵,而 AI 尚未能完全跨越。雖然大型語言模型(LLM)已經精通了「語法」(syntax)——即邏輯的數位呈現——但它們在「語義」(semantics)方面仍顯吃力;在此情境下,語義指的是系統在執行時的實際行為。挑戰在於,一個程式的行為不僅僅是其程式碼的產物,更是其與不可預測的工作負載、硬體限制,以及隨數據增加而呈指數級擴張的狀態空間(state space)交互作用的結果。
Grepr 的執行長 Jad Naous 指出,AI 在編碼方面的成功,源於它是在一個可管理的人類撰寫程式碼之流形(manifold)上進行訓練的。然而,運作中的系統則是「厚尾」(heavy-tailed)且基於異常狀況的。Naous 主張,雖然 AI 現在能撰寫驚人的生產級程式碼,但運行一個系統需要對訓練數據中未包含的事項進行推理,例如特定伺服器的記憶體激增或流量模式的突然變化。他將 AI 的世界視為一種數位模擬,而這種模擬往往與基礎設施中混亂的物理現實格格不入。
Naous 與 a16z 之間的知識交流,核心在於這種運維差距(operational gap)是一道不可逾越的牆,還是一個可解決的工程問題。a16z 認為,前進之路不在於要求 AI 預測故障(因為這是計算不可還原的),而是在於利用 AI 來管理除錯的 工作流(workflow)。a16z 主張,將運維視為一系列確定性的步驟(偵測變化、形成假設、執行實驗),AI 就能模擬人類網站可靠性工程師(SRE)的角色,將近乎無限的狀態空間壓縮成可管理的規模。
Naous 以他在 Grepr 的工作來闡述這一轉型,他將其推向了超越簡單「可觀測性」(observability)的層面。他認為,企業過去將購買可觀測性工具視為可靠性的替代指標,但這項投資的邊際報酬已經趨於平緩。Grepr 的方法是在上游數據流中提取訊號,將成本降低高達 90%,然後將這些高保真訊號輸入 AI 層。這個 AI 不僅僅是發出警報,它還會透過訊號進行推理,以判斷新的日誌模式是有意義的異常還是僅僅是噪音。
對話中的很大一部分探討了 AI 為工程師提供的「槓桿」作用。Naous 聲稱,普通工程師與頂尖工程師之間的差距擴大了十倍。由於 AI 處理了語法問題,頂尖工程師的價值現在在於他們管理架構複雜性,以及將龐大問題分解為 AI 可以執行的任務的能力。Naous 分享了一個令人驚訝的例子:在十天內交付一個數據湖中複雜的「自動晉級」(auto-promotion)功能——而這個項目在以前需要一名工程師花費六個月才能完成。
最終,對話轉向關於 AI 極限的哲學辯論。a16z 依然樂觀地認為,AI 在程式碼方面的「分佈式」成功最終將擴展到運維領域。Naous 則較為謹慎,他認為某些問題在計算上是不可還原的——你只能運行系統才能看到結果。他建議,未來可能不是 AI 「解決」現實世界,而是人類改變現實世界,使其符合 AI 實際能管理的限制。
主要討論主題
軟體中的語法 vs. 語義
Naous 和 a16z 將程式碼的「語法」(輸入的字元)與「語義」(機器在執行時實際執行的動作)區分開來。他們認為 LLM 是語法大師,因為它們幾乎見過所有撰寫函數的可能性。然而,語義受外部因素(如 schema、數據形態和硬體)的影響,而這些因素對模型來說通常是不可見的。這種區別解釋了為什麼 AI 能寫出分佈式算法,卻無法告訴你應該為其分配多少 RAM。
工程領域的「槓桿差距」
Naous 觀察到資深架構師與初級開發人員之間的生產力差距正在擴大。由於 AI 處理了樣板程式碼(boilerplate)和常規實現,「瓶頸」已轉移到高層級的系統思考。維持分佈式系統的複雜心智模型並將其分解為提示詞(prompts)的能力,現在成了價值的主要驅動力,這使得一個小團隊(如 Naous 的十人團隊)能產出遠超其規模的組織成果。
傳統可觀測性的失效
Naous 批評目前業界將 5-20% 的基礎設施預算花在可觀測性工具上的趨勢。他認為更多的數據並不等於更高的可靠性,反而會造成「噪音」問題。目標應該從「滯後指標」(在激增後警報)轉向「上游訊號提取」,讓 AI 在環境變化演變成生產事故之前就將其識別出來。
計算不可還原性與模擬
a16z 與 Naous 辯論 AI 是否能完全取代人類操作員。a16z 主張,雖然系統的狀態空間實際上是無限的,但人類除錯的步驟是有限的且可以被建模。Naous 則以「計算不可還原性」(computational irreducibility)反駁——即某些系統無法被預測,必須透過模擬或即時運行才能找到答案,這為預測型 AI 設定了硬性限制。
驚人之見
- 10倍至20倍的生產力跳躍: 過去一名工程師需要六個月才能完成的生產級功能,現在利用 AI agent 大約十天即可交付。
- 可觀測性悖論: 在可觀測性工具上的投入已達到邊際報酬遞減的臨界點,數據收集成本的增長速度快於其提供的可靠性。
實踐啟發
- 從「警報」轉向「變更檢測」: 不要只監控指標是否飆升(滯後指標),而應利用 AI 檢測日誌中是否出現了全新的、未見過的模式(領先指標)。
- 為 Agent 分解複雜度: 為了最大化 AI 的槓桿效用,不要要求它設計整個系統;應將專案拆分為語義層 (semantic layers),定義「黃金預期」(golden expectations,即測試案例),並指派子 Agent 執行平行任務。
- 關注「工作流」而非「答案」: 使用 AI 進行故障排除時,不要問「為什麼會發生這個問題?」,而應提示 AI 「執行一套假設-驗證工作流」以限定問題範圍。
- 優先考慮上游過濾: 在源頭提取信號,而非將原始數據發送到下游的可觀測性平台,以此降低遙測成本並減少雜訊。
- 投資於架構思維: 當語法變得商品化(隨處可得)時,工程師最有價值的技能是「系統思維」——處理高維複雜度並定義問題邊界的能力。
- 在 PR 中使用「黃金預期」: 隨著 AI 生成程式碼的數量增加,審查流程應從審核程式碼本身,轉向嚴格驗證測試案例與「黃金」輸出預期。
L’écart entre l’écriture d’une ligne de code et la maintenance d’un système vivant en production est un gouffre de complexité que l’IA n’a pas encore pleinement franchi. Si les grands modèles de langage (LLM) ont maîtrisé la « syntaxe » — la représentation numérique de la logique — ils peinent avec la « sémantique », laquelle désigne ici le comportement réel d’un système lors de son exécution (runtime). Le défi réside dans le fait que le comportement d’un programme n’est pas seulement le produit de son code, mais le résultat de son interaction avec des charges de travail imprévisibles, des contraintes matérielles et un espace d’états qui s’étend exponentiellement à chaque bit de donnée ajouté.
Jad Naous, PDG de Grepr, soutient que le succès de l’IA dans le codage découle du fait qu’elle a été entraînée sur une variété gérable de l’ensemble du code écrit par l’homme. Cependant, les systèmes opérationnels sont caractérisés par des « queues lourdes » (heavy-tailed) et fonctionnent sur la base d’exceptions. Naous avance que si l’IA peut désormais écrire des quantités remarquables de code de production, faire fonctionner un système exige un raisonnement sur des éléments absents des données d’entraînement, comme un pic de mémoire sur un serveur spécifique ou un changement soudain des flux de trafic. Il perçoit le monde de l’IA comme une simulation numérique souvent discordante avec la réalité physique et désordonnée des infrastructures.
L’échange intellectuel entre Naous et a16z se concentre sur la question de savoir si cet écart opérationnel est un mur insurmontable ou un problème d’ingénierie soluble. a16z suggère que la voie à suivre n’est pas de demander à l’IA de prédire les pannes — ce qui est computationnellement irréductible — mais d’utiliser l’IA pour gérer le flux de travail (workflow) du débogage. En traitant les opérations comme une série d’étapes déterministes (détecter un changement, formuler une hypothèse, mener une expérience), a16z soutient que l’IA peut simuler le rôle d’un SRE (Site Reliability Engineer) pour contraindre un espace d’états quasi infini en quelque chose de gérable.
Naous illustre cette transition à travers son travail chez Grepr, où il dépasse la simple observabilité. Il affirme que les entreprises ont historiquement acheté l’observabilité comme un substitut à la fiabilité, mais que le rendement marginal de cet investissement a stagné. L’approche de Grepr consiste à extraire le signal du flux de données en amont, réduisant les coûts jusqu’à 90 %, pour ensuite injecter ces signaux de haute fidélité dans une couche d’IA. Cette IA ne se contente pas d’alerter ; elle analyse le signal pour déterminer si un nouveau modèle de log est une anomalie significative ou un simple bruit.
Une partie importante du dialogue explore le « levier » que l’IA offre aux ingénieurs. Naous affirme que la disparité entre les ingénieurs moyens et les ingénieurs d’élite a été multipliée par dix. Puisque l’IA gère la syntaxe, la valeur de l’ingénieur d’élite réside désormais dans sa capacité à gérer la complexité architecturale et à décomposer des problèmes massifs en tâches qu’une IA peut exécuter. Naous partage l’exemple frappant du déploiement d’une fonctionnalité complexe d’« auto-promotion » dans un lac de données en dix jours — un projet qui aurait auparavant nécessité six mois de travail pour un seul ingénieur.
Enfin, la conversation pivote vers un débat philosophique sur les limites de l’IA. a16z reste optimiste quant au fait que le succès « distributionnel » de l’IA dans le code s’étendra éventuellement aux opérations. Naous est plus prudent, suggérant que certains problèmes sont computationnellement irréductibles : il faut tout simplement faire tourner le système pour voir ce qui se passe. Il suggère que l’avenir ne réside peut-être pas dans l’IA « résolvant » le monde réel, mais dans les humains modifiant le monde réel pour l’adapter aux contraintes que l’IA peut réellement gérer.
Principaux thèmes de discussion
Syntaxe vs Sémantique dans le logiciel
Naous et a16z distinguent la « syntaxe » du code (les caractères saisis) et la « sémantique » (ce que la machine fait réellement lors de l’exécution). Ils soutiennent que les LLM sont passés maîtres dans la syntaxe car ils ont vu presque toutes les façons possibles d’écrire une fonction. Cependant, la sémantique est influencée par des facteurs externes — schéma, forme des données et matériel — qui sont souvent invisibles pour le modèle. Cette distinction explique pourquoi l’IA peut écrire un algorithme distribué mais ne peut pas vous dire quelle quantité de RAM lui allouer.
Le « fossé du levier » en ingénierie
Naous observe un écart de productivité croissant entre les architectes seniors et les développeurs juniors. Puisque l’IA gère le code répétitif (boilerplate) et l’implémentation courante, le « goulot d’étranglement » s’est déplacé vers la pensée systémique de haut niveau. La capacité à maintenir un modèle mental complexe d’un système distribué et à le décomposer en invites (prompts) est désormais le principal moteur de valeur, permettant à une petite équipe (comme l’équipe de dix personnes de Naous) de produire le travail d’une organisation beaucoup plus vaste.
L’échec de l’observabilité traditionnelle
Naous critique la tendance actuelle de l’industrie consistant à consacrer 5 à 20 % des budgets d’infrastructure aux outils d’observabilité. Il soutient que plus de données ne signifie pas plus de fiabilité ; au contraire, cela crée un problème de « bruit ». L’objectif devrait être de passer des « indicateurs retardés » (alerte après un pic) à « l’extraction de signaux en amont », où l’IA identifie un changement dans l’environnement avant qu’il ne se manifeste par un incident de production.
Irréductibilité computationnelle et simulation
a16z et Naous débattent de la possibilité que l’IA puisse un jour remplacer totalement un opérateur humain. a16z soutient que si l’espace d’états d’un système est effectivement infini, les étapes qu’un humain suit pour le déboguer sont finies et peuvent être modélisées. Naous oppose à cela l’idée d’irréductibilité computationnelle — la notion selon laquelle certains systèmes ne peuvent être prédits et doivent être simulés ou exécutés en temps réel pour trouver la réponse, imposant ainsi une limite stricte à l’IA prédictive.
Perspectives surprenantes
- Le saut de productivité x10-x20 : Des fonctionnalités de niveau production qui prenaient auparavant six mois pour un ingénieur peuvent désormais être déployées en environ dix jours grâce aux agents d’IA.
- Le paradoxe de l’observabilité : Les dépenses accrues dans les outils d’observabilité ont atteint un point de rendement décroissant où le coût de la collecte de données croît plus rapidement que la fiabilité qu’elle apporte.
Points clés pratiques
- Passer des alertes à la détection de changements : Au lieu de surveiller un pic de métrique (indicateur retardé), utilisez l’IA pour détecter l’émergence d’un nouveau modèle inédit dans les logs (indicateur avancé).
- Décomposer la complexité pour les agents : Pour maximiser l’effet de levier de l’IA, ne demandez pas un système complet ; divisez le projet en couches sémantiques, définissez les « attentes d’excellence » (tests) et assignez des sous-agents à des tâches parallèles.
- Se concentrer sur le « flux de travail » plutôt que sur la « réponse » : Lors de l’utilisation de l’IA pour le dépannage, ne demandez pas « Pourquoi cela s’est-il produit ? ». Demandez plutôt à l’IA d’« exécuter un flux de travail hypothèse-vérification » pour circonscrire le problème.
- Prioriser le filtrage en amont : Réduisez les coûts de télémétrie et le bruit en extrayant les signaux à la source plutôt qu’en envoyant des données brutes vers une plateforme d’observabilité en aval.
- Investir dans la réflexion architecturale : Alors que la syntaxe devient une commodité, la compétence la plus précieuse pour les ingénieurs est la « pensée systémique » — la capacité à gérer une complexité multidimensionnelle et à définir les limites d’un problème.
- Utiliser des « attentes d’excellence » pour les PR : Avec l’augmentation du volume de code généré par l’IA, le processus de revue doit passer de l’examen du code lui-même à la validation rigoureuse des tests et des attentes de résultats « étalons ».
Die Lücke zwischen dem Schreiben einer Zeile Code und der Wartung eines lebenden Systems in der Produktion ist ein Abgrund an Komplexität, den die KI noch nicht vollständig überbrückt hat. Während Large Language Models (LLMs) die „Syntax“ – die digitale Repräsentation von Logik – gemeistert haben, kämpfen sie mit der „Semantik“, was in diesem Kontext das tatsächliche Laufzeitverhalten eines Systems bezeichnet. Die Herausforderung besteht darin, dass das Verhalten eines Programms nicht nur ein Produkt seines Codes ist, sondern das Ergebnis seiner Interaktion mit unvorhersehbaren Workloads, Hardware-Beschränkungen und einem Zustandsraum, der mit jedem hinzugefügten Bit an Daten exponentiell wächst.
Jad Naous, CEO von Grepr, argumentiert, dass der Erfolg der KI beim Codieren daraus resultiert, dass sie auf einer handhabbaren Mannigfaltigkeit (Manifold) aller menschengeschriebenen Codes trainiert wurde. Betriebssysteme sind jedoch „heavy-tailed“ und ausnahmenbasiert. Naous vertritt die Ansicht, dass KI zwar mittlerweile bemerkliche Mengen an Produktionscode schreiben kann, der Betrieb eines Systems jedoch ein Nachdenken über Dinge erfordert, die nicht in den Trainingsdaten enthalten sind – wie etwa die Speicherspitze eines bestimmten Servers oder eine plötzliche Änderung der Traffic-Muster. Er sieht die Welt der KI als eine digitale Simulation, die oft im Widerspruch zur chaotischen, physischen Realität der Infrastruktur steht.
Der intellektuelle Austausch zwischen Naous und a16z konzentriert sich auf die Frage, ob diese operative Lücke eine unüberwindbare Mauer oder ein lösbares technisches Problem ist. a16z schlägt vor, dass der Weg nach vorne nicht darin besteht, die KI zu bitten, Ausfälle vorherzusagen – was rechentechnisch irreduzibel ist –, sondern die KI zu nutzen, um den Workflow des Debuggings zu steuern. Indem man den Betrieb als eine Serie deterministischer Schritte betrachtet (eine Änderung erkennen, eine Hypothese aufstellen, ein Experiment durchführen), argumentiert a16z, dass die KI die Rolle eines menschlichen SRE (Site Reliability Engineer) simulieren kann, um einen nahezu unendlichen Zustandsraum in etwas Handhabbares zu begrenzen.
Naous veranschaulicht diesen Übergang an seiner Arbeit bei Grepr, wo er über die einfache Observability hinausgeht. Er argumentiert, dass Unternehmen Observability historisch gesehen als Ersatz für Zuverlässigkeit gekauft haben, aber die Grenzerträge dieser Investition stagnierten. Der Ansatz von Grepr besteht darin, Signale bereits im Upstream des Datenstroms zu extrahieren, wodurch die Kosten um bis zu 90 % gesenkt werden, und diese hochpräzisen Signale dann in eine KI-Schicht einzuspeisen. Diese KI löst nicht einfach nur Alarme aus; sie analysiert das Signal, um zu bestimmen, ob ein neues Log-Muster eine bedeutsame Anomalie oder bloßes Rauschen ist.
Ein erheblicher Teil des Dialogs befasst sich mit dem „Hebel“ (Leverage), den die KI den Ingenieuren bietet. Naous behauptet, dass sich die Kluft zwischen durchschnittlichen und Elite-Ingenieuren verzehnfacht hat. Da die KI die Syntax übernimmt, liegt der Wert des Elite-Ingenieurs nun in seiner Fähigkeit, architektonische Komplexität zu managen und massive Probleme in Aufgaben zu zerlegen, die eine KI ausführen kann. Naous teilt ein beeindruckendes Beispiel: die Implementierung einer komplexen „Auto-Promotion“-Funktion in einem Data Lake innerhalb von zehn Tagen – ein Projekt, für das ein einzelner Ingenieur zuvor sechs Monate benötigt hätte.
Letztendlich dreht sich das Gespräch um eine philosophische Debatte über die Grenzen der KI. a16z bleibt optimistisch, dass sich der „distributionale“ Erfolg der KI im Bereich Code schließlich auf den Betrieb ausweiten wird. Naous ist vorsichtiger und weist darauf hin, dass einige Probleme rechentechnisch irreduzibel sind – man muss das System einfach laufen lassen, um zu sehen, was passiert. Er vermutet, dass die Zukunft nicht darin liegen wird, dass die KI die reale Welt „löst“, sondern dass Menschen die reale Welt so verändern, dass sie den Beschränkungen entspricht, die eine KI tatsächlich verwalten kann.
Zentrale Diskussionsthemen
Syntax vs. Semantik in der Software
Naous und a16z unterscheiden zwischen der „Syntax“ des Codes (den getippten Zeichen) und der „Semantik“ (dem, was die Maschine zur Laufzeit tatsächlich tut). Sie argumentieren, dass LLMs Meister der Syntax sind, da sie fast jede denkbare Art, eine Funktion zu schreiben, gesehen haben. Die Semantik wird jedoch von externen Faktoren beeinflusst – Schema, Datenform und Hardware –, die für das Modell oft unsichtbar sind. Diese Unterscheidung erklärt, warum eine KI zwar einen verteilten Algorithmus schreiben kann, Ihnen aber nicht sagen kann, wie viel RAM man ihm zuweisen muss.
Die „Leverage Gap“ im Engineering
Naous beobachtet eine wachsende Produktivitätslücke zwischen Senior-Architekten und Junior-Entwicklern. Da die KI den Boilerplate-Code und die Routine-Implementierung übernimmt, hat sich der „Engpass“ hin zum systemischen Denken auf hoher Ebene verschoben. Die Fähigkeit, ein komplexes mentales Modell eines verteilten Systems aufrechtzuerhalten und dieses in Prompts zu zerlegen, ist nun der primäre Werttreiber. Dies ermöglicht es einem kleinen Team (wie dem Zehn-Personen-Team von Naous), die Arbeitsleistung einer viel größeren Organisation zu erbringen.
Das Versagen traditioneller Observability
Naous kritisiert den aktuellen Branchentrend, 5–20 % der Infrastruktur-Budgets für Observability-Tools auszugeben. Er argumentiert, dass mehr Daten nicht mehr Zuverlässigkeit bedeuten, sondern stattdessen ein „Rauschproblem“ erzeugen. Das Ziel sollte die Verschiebung von „nachlaufenden Indikatoren“ (Alarmierung nach einer Spitze) hin zur „Upstream-Signalextraktion“ sein, bei der die KI eine Änderung in der Umgebung identifiziert, bevor sie sich als Produktionsvorfall manifestiert.
Rechentechnische Irreduzibilität und Simulation
a16z und Naous debattieren darüber, ob KI jemals einen menschlichen Operator vollständig ersetzen kann. a16z argumentiert, dass der Zustandsraum eines Systems zwar effektiv unendlich ist, die Schritte, die ein Mensch zum Debuggen unternimmt, jedoch endlich sind und modelliert werden können. Naous hält dem die Idee der rechentechnischen Irreduzibilität entgegen – die Vorstellung, dass einige Systeme nicht vorhergesagt werden können und in Echtzeit simuliert oder ausgeführt werden müssen, um die Antwort zu finden, was eine harte Grenze für prädiktive KI setzt.
Überraschende Erkenntnisse
- Der 10- bis 20-fache Produktivitätssprung: Features in Produktionsqualität, für die ein Ingenieur zuvor sechs Monate benötigte, können nun mithilfe von KI-Agenten in etwa zehn Tagen ausgeliefert werden.
- Das Observability-Paradoxon: Höhere Ausgaben für Observability-Tools haben einen Punkt abnehmender Grenzerträge erreicht, an dem die Kosten der Datenerfassung schneller steigen als die dadurch gewährleistete Zuverlässigkeit.
Praktische Erkenntnisse
- Wechsel von Alerts zur Änderungserkennung: Anstatt auf einen Anstieg einer Metrik zu achten (nachlaufender Indikator), nutzen Sie KI, um zu erkennen, wann ein neues, bisher unbekanntes Muster in den Logs auftritt (vorlaufender Indikator).
- Komplexität für Agenten zerlegen: Um den Hebeleffekt von KI zu maximieren, fordern Sie nicht ein gesamtes System an; unterteilen Sie das Projekt in semantische Schichten, definieren Sie die „Golden Expectations“ (Tests) und weisen Sie Sub-Agenten parallele Aufgaben zu.
- Fokus auf den „Workflow“, nicht auf die „Antwort“: Fragen Sie bei der Fehlerbehebung mit KI nicht: „Warum ist das passiert?“, sondern fordern Sie die KI auf, einen „Hypothesen-Verifizierungs-Workflow durchzulaufen“, um das Problem einzugrenzen.
- Priorisierung der Upstream-Filterung: Reduzieren Sie Telemetriekosten und Rauschen, indem Sie Signale direkt an der Quelle extrahieren, anstatt Rohdaten an eine nachgelagerte Observability-Plattform zu senden.
- Investition in architektonisches Denken: Da Syntax zu einer Commodity wird, ist die wertvollste Fähigkeit für Ingenieure das „Systems Thinking“ – die Fähigkeit, hochdimensionale Komplexität zu handhaben und die Grenzen eines Problems zu definieren.
- „Golden Expectations“ für PRs nutzen: Da das Volumen an KI-generiertem Code zunimmt, sollte sich der Review-Prozess von der Überprüfung des Codes selbst hin zu einer rigorosen Validierung der Tests und der „goldenen“ Erwartungen an den Output verschieben.
a16z General Partner Martin Casado sits down with Grepr CEO Jad Naous to ask what comes after AI learns to write code: can it also debug and operate the systems that code creates?
Jad shares how AI has transformed engineering inside his 10-person team, cutting some projects from six months to just 10 days. But operating production systems is a harder challenge, with unpredictable workloads, failures, and countless possible states.
They discuss whether AI can learn to diagnose problems, test hypotheses, and debug systems like a human engineer. They also explore AI SREs, security, query optimization, and why the best engineers may be gaining the most leverage from coding agents.
Resources:
Follow Jad Naous on X: https://x.com/jadtnaous
Follow Martin Casado on X:https://x.com/martin_casado
Learn more about Grepr: https://www.grepr.ai/
Stay Updated:
Find a16z on YouTube: YouTube
Find a16z on X
Find a16z on LinkedIn
Listen to the a16z Show on Spotify
Listen to the a16z Show on Apple Podcasts
Follow our host: https://twitter.com/eriktorenberg
Please note that the content here is for informational purposes only; should NOT be taken as legal, business, tax, or investment advice or be used to evaluate any investment or security; and is not directed at any investors or potential investors in any a16z fund. a16z and its affiliates may maintain investments in the companies discussed. For more details please see a16z.com/disclosures.
Hosted by Simplecast, an AdsWizz company. See pcm.adswizz.com for information about our collection and use of personal data for advertising.
-
Ben Horowitz and Travis Kalanick on Building Again
Ben Horowitz, Travis Kalanick, and Erik Torenberg take the stage at Atoms’ launch event for a candid fireside conversation about entrepreneurship, company building, and why Kalanick believes the next industrial revolution will be powered by…
-
The Two Ways to Sell AI: Lighthouse or Landgrab?
Elena Burger is joined by a16z’s Andy McCall and Joe Schmidt to break down two very different ways AI startups can go to market: the lighthouse and the landgrab. Should founders win a handful of…
-
Garry Tan on Taste, Agents and Founder Ambition
Anish Acharya is joined by Garry Tan, President and CEO of Y Combinator, for a conversation about how AI is rewriting the startup playbook, why founders should be more ambitious than ever, and what two…
-
The CISO Playbook for AI Agents | Datadog
a16z’s Joel De La Garza is joined by Emilio Escobar, Chief Information Security Officer at Datadog, to discuss what it takes to secure a company where nearly every employee is using AI and more than…
-
The Self-Improving Company | Kavak’s AI Playbook
Angela Strange and Gabriel Vasquez are joined by Alejandro Maza Ayala, Chief Product & AI Officer at Kavak, to unpack how the Latin American used-car marketplace rebuilt itself around AI agents, with 96% of customer…
-
The Reality of AI-Powered Cyberattacks | Truffle Security & Socket
Joel De La Garza is joined by Dylan Ayrey, co-founder and CEO of Truffle Security, and Feross Aboukhadijeh, founder and CEO of Socket, to discuss one of the biggest shifts happening in cybersecurity: AI models…
-
The Engine Powering Open-Source AI
Elena Burger and Matt Bornstein are joined by Simon Mo, co-founder and CEO of Inferact, the open-source inference engine powering many of today’s most advanced AI applications. Together, they explore how open-source AI evolved from…
-
Three Startups Reinventing Critical Infrastructure
This week, a16z American Dynamism Films premiered three short documentaries highlighting companies tackling some of America’s biggest industrial challenges: Ulysses, Mariana Materials, and Radiant. Before watching those films, we’re revisiting conversations with the founders behind…
-
OpenAI’s Joshua Achiam: Did We Already Reach AGI?
Theo Jaffee is joined by Joshua Achiam, Chief Futurist at OpenAI, for a conversation on AI cybersecurity, frontier model capabilities, and why he believes society may have already crossed the threshold into an AGI-era without…
-
Ruby Thelot on Internet Culture, AI, and the Future of Taste
Sophia Dew and Sofia Puccini are joined by Ruby Thelot, designer, artist, cyberethnographer, professor at NYU, and founder of 13101401, for a wide-ranging conversation about internet culture, AI, digital communities, and how technology is reshaping…
