Summary & Insights
We don’t actually want artificial general intelligence; we want systems that reliably solve specific problems. This provocative stance from Omar Khattab, MIT professor and creator of DSPy, frames a fundamental critique of the current AI race. While many obsess over scaling model parameters to reach AGI, Khattab argues the real bottleneck isn’t capability but specification—how humans clearly communicate their complex, nuanced intents to machines. Natural language is too ambiguous, and traditional code is too rigid, creating a gap that must be bridged by new abstractions.
The conversation centers on moving from viewing LLMs as monolithic “oracles” to treating them as components within programmable systems. Khattab observes that the frontier labs have already pivoted from a pure scaling playbook to building intricate pipelines involving retrieval, tool use, and agent training. This shift acknowledges that raw model intelligence is insufficient; the real challenge is constructing reliable, maintainable, and composable systems around these models. He introduces the concept of “Artificial Programmable Intelligence” (API) as a more pertinent goal than AGI, drawing an analogy to computer history: just as more transistors didn’t make software obsolete but enabled it, more capable models should empower better systems, not replace the need for them.
Khattab’s framework, DSPy, is presented as a potential solution—a “C language for AI systems.” Its core innovation is the signature, a structured way to declare the input-output behavior of an LLM-powered function without being entangled in prompt wording or model specifics. This abstraction allows developers to isolate ambiguity into manageable pieces, compose modules imperatively like standard code, and apply automated optimizers that adapt the underlying prompts and inference strategies. The goal is portability and maintainability: your system’s intent remains constant even as underlying models and optimization algorithms evolve.
Ultimately, the discussion posits that the future of AI engineering hinges on this kind of disciplined abstraction. The choice isn’t between chatbots and code, but about recognizing when each is appropriate. For complex, repeatable tasks where reliability and structure matter, we will need systems built with formalizable intent. The work on frameworks like DSPy is an attempt to provide the foundational tools for this new era of software development, where intelligence is a cheap commodity, but directing it purposefully remains the hard part.
Surprising Insights
- Nobody wants intelligence, period. The ultimate goal isn’t to create a general intelligence, but to build specific systems that solve human problems. Intelligence is merely a powerful component in that larger engineering endeavor.
- The “bitter lesson” might be misapplied to systems. While scaling compute and data often beats over-engineered AI algorithms, this lesson doesn’t extend to the systems built with AI. Over-engineering the system architecture with the right abstractions is essential for maintainability and reliability.
- AGI may be less relevant than API (Artificial Programmable Intelligence). The philosophical pursuit of human-like general intelligence distracts from the more practical aim of creating intelligences that can be formally programmed and composed into larger systems.
- The bottleneck is specification, not capability. Even with infinitely capable models, the fundamental challenge is how humans can precisely specify their often ambiguous, complex, and trade-off-laden desires in a way the machine can execute reliably.
- Prompt engineering is a dead-end abstraction. Relying on natural language prompts to evoke model capabilities is inherently limiting and brittle. The future lies in higher-level, structured abstractions that separate intent from implementation.
Practical Takeaways
- Think in terms of systems, not just models. When building an AI application, design a system architecture with clear modules and data flow. Use the LLM as a powerful component within this system, not as the entire system itself.
- Separate the “what” from the “how.” Clearly declare the task (the signature) in a structured way, decoupling it from the specific prompts, model choices, or inference strategies (like chain-of-thought) used to implement it. This makes your system more adaptable and future-proof.
- Use data not just for training, but for compilation. Frameworks like DSPy allow you to use small datasets to automatically optimize or “compile” your program’s prompts and reasoning structures for higher quality, reducing the need for manual prompt tweaking.
- Avoid using a chatbot interface for structured tasks. If you need repeatable, structured outputs that integrate into a larger process, don’t rely on an open-ended conversational interface. Build a program with defined functions and control flow.
- Embrace composite AI systems. Don’t wait for one model to do everything. Combine specialized components (retrievers, tools, code executors) with LLMs using a structured framework to build more capable and reliable applications than any single model could provide.
Cuộc thảo luận tập trung vào việc chuyển từ việc xem LLM như những “nhà tiên tri” độc lập sang coi chúng như những thành phần trong các hệ thống có thể lập trình được. Khattab nhận xét rằng các phòng thí nghiệm tiên phong đã chuyển hướng từ lối chơi thuần túy mở rộng quy mô sang xây dựng các quy trình phức tạp liên quan đến truy xuất, sử dụng công cụ và đào tạo tác nhân. Sự thay đổi này thừa nhận rằng trí thông minh thô của mô hình là không đủ; thách thức thực sự là xây dựng các hệ thống đáng tin cậy, có thể bảo trì và có thể kết hợp xung quanh các mô hình này. Ông giới thiệu khái niệm **”Trí tuệ Nhân tạo có thể Lập trình” (API)** như một mục tiêu thiết thực hơn AGI, vẽ ra một phép loại suy với lịch sử máy tính: cũng như nhiều bóng bán dẫn hơn không làm phần mềm lỗi thời mà cho phép nó phát triển, các mô hình mạnh mẽ hơn nên trao quyền cho các hệ thống tốt hơn, chứ không thay thế nhu cầu về chúng.
Khung làm việc DSPy của Khattab được trình bày như một giải pháp tiềm năng — một **”ngôn ngữ C cho các hệ thống AI”**. Đổi mới cốt lõi của nó là *chữ ký (signature)*, một cách có cấu trúc để khai báo hành vi đầu vào-đầu ra của một chức năng dựa trên LLM mà không bị vướng vào cách diễn đạt lời nhắc hoặc chi tiết cụ thể của mô hình. Sự trừu tượng này cho phép các nhà phát triển tách sự mơ hồ thành các phần có thể quản lý được, kết hợp các mô-đun một cách mệnh lệnh như mã tiêu chuẩn và áp dụng các bộ tối ưu hóa tự động điều chỉnh các lời nhắc cơ bản và chiến lược suy luận. Mục tiêu là tính di động và khả năng bảo trì: ý định của hệ thống của bạn vẫn không đổi ngay cả khi các mô hình cơ bản và thuật toán tối ưu hóa phát triển.
Cuối cùng, cuộc thảo luận giả định rằng tương lai của kỹ thuật AI phụ thuộc vào loại trừu tượng có kỷ luật này. Sự lựa chọn không phải là giữa chatbot và mã code, mà là nhận ra khi nào mỗi thứ phù hợp. Đối với các nhiệm vụ phức tạp, lặp đi lặp lại mà độ tin cậy và cấu trúc là quan trọng, chúng ta sẽ cần các hệ thống được xây dựng với ý định có thể hình thức hóa. Công việc trên các khung như DSPy là một nỗ lực cung cấp các công cụ nền tảng cho kỷ nguyên phát triển phần mềm mới này, nơi trí thông minh là một hàng hóa rẻ tiền, nhưng việc định hướng nó một cách có mục đích vẫn là phần khó khăn.
### Những Hiểu Biết Đáng Ngạc Nhiên
* **Không ai muốn trí thông minh, chấm hết.** Mục tiêu cuối cùng không phải là tạo ra một trí thông minh phổ quát, mà là xây dựng các hệ thống cụ thể giải quyết các vấn đề của con người. Trí thông minh chỉ đơn thuần là một thành phần mạnh mẽ trong nỗ lực kỹ thuật lớn hơn đó.
* **”Bài học cay đắng” có thể bị áp dụng sai cho hệ thống.** Trong khi việc mở rộng quy mô tính toán và dữ liệu thường đánh bại các thuật toán AI được thiết kế quá mức, bài học này không mở rộng đến các *hệ thống* được xây dựng bằng AI. Việc thiết kế quá mức *kiến trúc hệ thống* với các khái niệm trừu tượng phù hợp là điều cần thiết cho khả năng bảo trì và độ tin cậy.
* **AGI có thể kém quan trọng hơn API (Trí tuệ Nhân tạo có thể Lập trình).** Việc theo đuổi triết học về trí thông minh phổ quát giống con người làm chúng ta sao nhãng khỏi mục tiêu thực tế hơn là tạo ra những trí thông minh có thể được lập trình một cách chính thức và kết hợp thành các hệ thống lớn hơn.
* **Nút thắt là sự xác định rõ ràng, không phải năng lực.** Ngay cả với các mô hình có năng lực vô hạn, thách thức cơ bản là làm thế nào con người có thể xác định chính xác những mong muốn thường mơ hồ, phức tạp và chứa đầy sự đánh đổi của họ theo cách mà máy móc có thể thực thi một cách đáng tin cậy.
* **Kỹ thuật lời nhắc (Prompt Engineering) là một khái niệm trừu tượng không lối thoát.** Việc dựa vào các lời nhắc bằng ngôn ngữ tự nhiên để gợi lên khả năng của mô hình vốn dĩ có giới hạn và dễ vỡ. Tương lai nằm ở các khái niệm trừu tượng ở cấp độ cao hơn, có cấu trúc tách biệt ý định khỏi việc triển khai.
### Bài Học Thực Tiễn
* **Suy nghĩ theo hướng hệ thống, không chỉ mô hình.** Khi xây dựng một ứng dụng AI, hãy thiết kế một kiến trúc hệ thống với các mô-đun và luồng dữ liệu rõ ràng. Sử dụng LLM như một thành phần mạnh mẽ trong hệ thống này, không phải là toàn bộ hệ thống.
* **Tách biệt “cái gì” khỏi “như thế nào”.** Hãy khai báo rõ ràng nhiệm vụ (chữ ký) một cách có cấu trúc, tách nó khỏi các lời nhắc cụ thể, lựa chọn mô hình hoặc chiến lược suy luận (như chuỗi suy nghĩ) được sử dụng để triển khai nó. Điều này làm cho hệ thống của bạn linh hoạt hơn và có thể chống chọi với tương lai.
* **Sử dụng dữ liệu không chỉ để đào tạo, mà còn để biên dịch (compile).** Các khung như DSPy cho phép bạn sử dụng các bộ dữ liệu nhỏ để tự động tối ưu hóa hoặc “biên dịch” các lời nhắc và cấu trúc lý luận của chương trình của bạn để đạt chất lượng cao hơn, giảm nhu cầu điều chỉnh lời nhắc thủ công.
* **Tránh sử dụng giao diện chatbot cho các tác vụ có cấu trúc.** Nếu bạn cần đầu ra có cấu trúc, lặp lại được và tích hợp vào một quy trình lớn hơn, đừng dựa vào một giao diện trò chuyện mở. Hãy xây dựng một chương trình với các chức năng và luồng điều khiển được xác định.
* **Chấp nhận các hệ thống AI tổng hợp.** Đừng chờ đợi một mô hình làm mọi thứ. Hãy kết hợp các thành phần chuyên biệt (bộ truy xuất, công cụ, trình thực thi mã) với LLM bằng một khung có cấu trúc để xây dựng các ứng dụng mạnh mẽ và đáng tin cậy hơn bất kỳ mô hình đơn lẻ nào có thể cung cấp.
事實上,我們需要的並非通用人工智慧,而是能可靠解決特定問題的系統。麻省理工學院教授兼 DSPy 創建者奧馬爾·哈塔卜提出的這個挑釁性觀點,構成了對當前人工智慧競賽的根本性質疑。當許多人執著於擴展模型參數以實現通用人工智慧時,哈塔卜指出真正的瓶頸不在於能力,而在於規範——即人類如何清晰地向機器傳達複雜且細緻的意圖。自然語言過於模糊,傳統程式碼又過於僵化,這種鴻溝需要新的抽象層次來彌合。
討論的核心在於將大型語言模型從單一的「預言機」視角,轉變為可編程系統中的組件。哈塔卜觀察到,前沿實驗室已從純粹追求規模擴展,轉向構建包含檢索、工具使用與智能體訓練的複雜管道。這種轉變承認原始模型智能並不足夠,真正的挑戰在於圍繞這些模型構建可靠、可維護且可組合的系統。他提出「人工可編程智能」的概念,認為這比通用人工智慧更為切合實際,並以電腦發展史類比:正如更多電晶體並未淘汰軟體反而使其蓬勃發展,更強大的模型應催生更完善的系統,而非取代系統建構的需求。
哈塔卜開發的 DSPy 框架被視為潛在解決方案——堪稱「AI 系統的 C 語言」。其核心創新在於簽章,這是一種結構化聲明大型語言模型函數輸入輸出行為的方式,無需糾結於提示詞措辭或模型細節。這種抽象化讓開發者能將模糊性隔離成可管理的單元,像標準程式碼般靈活組合模組,並運用自動化優化器調整底層提示與推理策略。目標在於實現可移植性與可維護性:即使底層模型與優化演算法持續演進,系統的核心意圖仍能保持穩定。
最終,這場討論確立了人工智慧工程的未來將取決於此類嚴謹的抽象化。關鍵抉擇不在於聊天機器人與程式碼二選一,而在於辨明兩者各自的適用場景。對於重視可靠性與結構性的複雜重複性任務,我們需要建構具有可形式化意圖的系統。DSPy 等框架的研發,正是為了替軟體開發的新時代提供基礎工具——在這個時代,智慧將成為廉價商品,而如何有目的地引導智慧,才是真正的難題。
顛覆性洞見
- 根本沒人需要「智慧」本身。終極目標並非創造通用智慧,而是建構能解決人類問題的特定系統。智慧僅是這場宏大工程中的強大組件。
- 「苦澀教訓」可能誤用於系統層面。雖然擴展運算能力與資料量常勝過過度設計的人工智慧演算法,但此教訓不適用於以人工智慧建構的系統。以適當抽象化對系統架構進行精細設計,對可維護性與可靠性至關重要。
- 人工可編程智能可能比通用人工智慧更具現實意義。對類人通用智慧的哲學追求,反而模糊了更實際的目標:創造能被形式化編程並組合成大型系統的智慧體。
- 瓶頸在於規範而非能力。即使擁有無限能力的模型,根本挑戰仍在於人類如何精確規範自身模糊、複雜且充滿權衡取捨的需求,並讓機器可靠執行。
- 提示工程是條死胡同。依賴自然語言提示來激發模型能力,本質上具有局限性與脆弱性。未來屬於更高層次、結構化的抽象方法,能將意圖與實作徹底分離。
實踐啟示
- 以系統思維取代單一模型思維。建構人工智慧應用時,應設計具清晰模組與資料流的系統架構,將大型語言模型視為系統內的強大組件,而非系統本身。
- 分離「做什麼」與「怎麼做」。用結構化方式明確宣告任務目標(簽章),使其與具體提示詞、模型選擇或推理策略(如思維鏈)脫鉤,這將增強系統適應性與未來兼容性。
- 讓資料不僅用於訓練,更用於編譯。如 DSPy 等框架允許透過小型資料集自動優化(或稱「編譯」)程式的提示詞與推理結構,提升輸出品質,減少手動調整提示詞的需求。
- 避免以聊天介面處理結構化任務。若需可重複、結構化的輸出結果以整合至大型流程,不應依賴開放式對話介面,而應建構具明確函數與控制流程的程式。
- 擁抱複合式人工智慧系統。無需等待單一模型具備所有能力。透過結構化框架結合專業組件(檢索器、工具、程式執行器)與大型語言模型,能建構比任何單一模型更強大可靠的應用。
No queremos realmente inteligencia artificial general; queremos sistemas que resuelvan problemas específicos de manera fiable. Esta postura provocadora de Omar Khattab, profesor del MIT y creador de DSPy, enmarca una crítica fundamental a la actual carrera de la IA. Mientras muchos se obsesionan con escalar los parámetros de los modelos para alcanzar la AGI, Khattab sostiene que el verdadero cuello de botella no es la capacidad, sino la especificación: cómo los seres humanos comunican con claridad a las máquinas sus intenciones complejas y llenas de matices. El lenguaje natural es demasiado ambiguo, y el código tradicional es demasiado rígido, lo que crea una brecha que debe cerrarse con nuevas abstracciones.
La conversación se centra en pasar de ver los LLM como “oráculos” monolíticos a tratarlos como componentes dentro de sistemas programables. Khattab observa que los laboratorios de vanguardia ya han dejado atrás un enfoque puramente basado en el escalado para construir canalizaciones complejas que implican recuperación de información, uso de herramientas y entrenamiento de agentes. Este cambio reconoce que la inteligencia bruta del modelo es insuficiente; el verdadero desafío es construir sistemas fiables, mantenibles y componibles alrededor de estos modelos. Él introduce el concepto de “Inteligencia Artificial Programable” (API) como una meta más pertinente que la AGI, trazando una analogía con la historia de la informática: así como tener más transistores no volvió obsoleto al software, sino que lo hizo posible, unos modelos más capaces deberían potenciar mejores sistemas, no reemplazar la necesidad de ellos.
El marco de trabajo de Khattab, DSPy, se presenta como una posible solución: un “lenguaje C para sistemas de IA”. Su innovación central es la firma, una forma estructurada de declarar el comportamiento de entrada y salida de una función impulsada por un LLM sin quedar enredado en la redacción del prompt ni en detalles específicos del modelo. Esta abstracción permite a los desarrolladores aislar la ambigüedad en partes manejables, componer módulos de forma imperativa como en el código estándar y aplicar optimizadores automáticos que adaptan los prompts subyacentes y las estrategias de inferencia. El objetivo es la portabilidad y la mantenibilidad: la intención de tu sistema permanece constante incluso mientras evolucionan los modelos subyacentes y los algoritmos de optimización.
En última instancia, la discusión plantea que el futuro de la ingeniería de IA depende de este tipo de abstracción disciplinada. La elección no es entre chatbots y código, sino reconocer cuándo cada uno es apropiado. Para tareas complejas y repetibles, donde importan la fiabilidad y la estructura, necesitaremos sistemas construidos con una intención formalizable. El trabajo en marcos como DSPy es un intento de proporcionar las herramientas fundamentales para esta nueva era del desarrollo de software, en la que la inteligencia es una mercancía barata, pero dirigirla con propósito sigue siendo la parte difícil.
Ideas sorprendentes
- Nadie quiere inteligencia, sin más. El objetivo último no es crear una inteligencia general, sino construir sistemas específicos que resuelvan problemas humanos. La inteligencia es solo un componente poderoso dentro de ese esfuerzo de ingeniería más amplio.
- La “lección amarga” podría estar aplicándose mal a los sistemas. Aunque escalar cómputo y datos suele superar a algoritmos de IA excesivamente sofisticados, esta lección no se extiende a los sistemas construidos con IA. Sobreingenierizar la arquitectura del sistema con las abstracciones adecuadas es esencial para la mantenibilidad y la fiabilidad.
- La AGI puede ser menos relevante que la API (Inteligencia Artificial Programable). La búsqueda filosófica de una inteligencia general similar a la humana distrae del objetivo más práctico de crear inteligencias que puedan programarse formalmente y componerse en sistemas más grandes.
- El cuello de botella es la especificación, no la capacidad. Incluso con modelos infinitamente capaces, el desafío fundamental es cómo los seres humanos pueden especificar con precisión sus deseos —a menudo ambiguos, complejos y llenos de compensaciones— de una manera que la máquina pueda ejecutar de forma fiable.
- La ingeniería de prompts es una abstracción sin salida. Confiar en prompts en lenguaje natural para evocar las capacidades del modelo es inherentemente limitado y frágil. El futuro está en abstracciones estructuradas de más alto nivel que separen la intención de la implementación.
Conclusiones prácticas
- Piensa en términos de sistemas, no solo de modelos. Al construir una aplicación de IA, diseña una arquitectura de sistema con módulos claros y flujo de datos definido. Usa el LLM como un componente poderoso dentro de ese sistema, no como el sistema completo.
- Separa el “qué” del “cómo”. Declara claramente la tarea (la firma) de forma estructurada, desvinculándola de los prompts específicos, de las elecciones de modelo o de las estrategias de inferencia (como la cadena de pensamiento) usadas para implementarla. Esto hace que tu sistema sea más adaptable y esté mejor preparado para el futuro.
- Usa los datos no solo para entrenar, sino también para compilar. Marcos como DSPy te permiten usar pequeños conjuntos de datos para optimizar o “compilar” automáticamente los prompts y las estructuras de razonamiento de tu programa para lograr mayor calidad, reduciendo la necesidad de ajustar prompts manualmente.
- Evita usar una interfaz de chatbot para tareas estructuradas. Si necesitas salidas repetibles y estructuradas que se integren en un proceso más amplio, no dependas de una interfaz conversacional abierta. Construye un programa con funciones definidas y flujo de control.
- Adopta sistemas de IA compuestos. No esperes a que un solo modelo lo haga todo. Combina componentes especializados (recuperadores, herramientas, ejecutores de código) con LLM mediante un marco estructurado para construir aplicaciones más capaces y fiables de lo que cualquier modelo por sí solo podría ofrecer.
Na verdade, não queremos inteligência artificial geral; queremos sistemas que resolvam problemas específicos de forma confiável. Essa posição provocativa de Omar Khattab, professor do MIT e criador do DSPy, estabelece uma crítica fundamental à atual corrida da IA. Enquanto muitos estão obcecados em ampliar os parâmetros dos modelos para alcançar a AGI, Khattab argumenta que o verdadeiro gargalo não é a capacidade, mas a especificação — como os humanos comunicam de forma clara suas intenções complexas e cheias de nuances às máquinas. A linguagem natural é ambígua demais, e o código tradicional é rígido demais, criando uma lacuna que precisa ser preenchida por novas abstrações.
A conversa se concentra na transição de enxergar os LLMs como “oráculos” monolíticos para tratá-los como componentes dentro de sistemas programáveis. Khattab observa que os laboratórios de ponta já abandonaram uma abordagem puramente baseada em escala para construir pipelines intrincados envolvendo recuperação de informação, uso de ferramentas e treinamento de agentes. Essa mudança reconhece que a inteligência bruta do modelo é insuficiente; o verdadeiro desafio é construir sistemas confiáveis, sustentáveis e componíveis em torno desses modelos. Ele introduz o conceito de “Inteligência Artificial Programável” (API) como um objetivo mais pertinente do que a AGI, traçando uma analogia com a história da computação: assim como mais transistores não tornaram o software obsoleto, mas o viabilizaram, modelos mais capazes devem capacitar sistemas melhores, e não substituir a necessidade deles.
O framework de Khattab, o DSPy, é apresentado como uma possível solução — uma “linguagem C para sistemas de IA”. Sua inovação central é a assinatura, uma forma estruturada de declarar o comportamento de entrada e saída de uma função baseada em LLM sem ficar presa à formulação do prompt ou às especificidades do modelo. Essa abstração permite que os desenvolvedores isolem a ambiguidade em partes gerenciáveis, componham módulos de forma imperativa como no código tradicional e apliquem otimizadores automáticos que adaptam os prompts subjacentes e as estratégias de inferência. O objetivo é portabilidade e manutenção: a intenção do seu sistema permanece constante mesmo à medida que os modelos subjacentes e os algoritmos de otimização evoluem.
Em última análise, a discussão propõe que o futuro da engenharia de IA depende desse tipo de abstração disciplinada. A escolha não é entre chatbots e código, mas sim reconhecer quando cada um é apropriado. Para tarefas complexas e repetíveis, nas quais confiabilidade e estrutura importam, precisaremos de sistemas construídos com intenção formalizável. O trabalho em frameworks como o DSPy é uma tentativa de fornecer as ferramentas fundamentais para essa nova era do desenvolvimento de software, em que a inteligência é uma commodity barata, mas direcioná-la de forma intencional continua sendo a parte difícil.
Insights Surpreendentes
- Ninguém quer inteligência, por si só. O objetivo final não é criar uma inteligência geral, mas construir sistemas específicos que resolvam problemas humanos. A inteligência é apenas um componente poderoso dentro desse esforço maior de engenharia.
- A “lição amarga” pode estar sendo mal aplicada aos sistemas. Embora ampliar computação e dados frequentemente supere algoritmos de IA excessivamente elaborados, essa lição não se estende aos sistemas construídos com IA. Elaborar em excesso a arquitetura do sistema, com as abstrações corretas, é essencial para manutenção e confiabilidade.
- A AGI pode ser menos relevante do que a API (Inteligência Artificial Programável). A busca filosófica por uma inteligência geral semelhante à humana distrai do objetivo mais prático de criar inteligências que possam ser programadas formalmente e compostas em sistemas maiores.
- O gargalo é a especificação, não a capacidade. Mesmo com modelos infinitamente capazes, o desafio fundamental é como os humanos podem especificar com precisão seus desejos, muitas vezes ambíguos, complexos e cheios de trade-offs, de uma forma que a máquina consiga executar com confiabilidade.
- A engenharia de prompts é uma abstração sem futuro. Depender de prompts em linguagem natural para evocar as capacidades do modelo é algo inerentemente limitante e frágil. O futuro está em abstrações estruturadas de nível mais alto que separem intenção de implementação.
Conclusões Práticas
- Pense em termos de sistemas, não apenas de modelos. Ao construir uma aplicação de IA, projete uma arquitetura de sistema com módulos claros e fluxo de dados bem definido. Use o LLM como um componente poderoso dentro desse sistema, e não como o sistema inteiro.
- Separe o “o quê” do “como”. Declare claramente a tarefa (a assinatura) de forma estruturada, desacoplando-a dos prompts específicos, das escolhas de modelo ou das estratégias de inferência (como chain-of-thought) usadas para implementá-la. Isso torna seu sistema mais adaptável e preparado para o futuro.
- Use dados não apenas para treinamento, mas também para compilação. Frameworks como o DSPy permitem usar pequenos conjuntos de dados para otimizar ou “compilar” automaticamente os prompts e as estruturas de raciocínio do seu programa em busca de maior qualidade, reduzindo a necessidade de ajustes manuais de prompt.
- Evite usar uma interface de chatbot para tarefas estruturadas. Se você precisa de saídas repetíveis e estruturadas que se integrem a um processo maior, não dependa de uma interface conversacional aberta. Construa um programa com funções definidas e fluxo de controle.
- Adote sistemas compostos de IA. Não espere que um único modelo faça tudo. Combine componentes especializados (recuperadores, ferramentas, executores de código) com LLMs usando um framework estruturado para construir aplicações mais capazes e confiáveis do que qualquer modelo isolado poderia oferecer.
The Stanford PhD who built DSPy thought he was just creating better prompts—until he realized he’d accidentally invented a new paradigm that makes LLMs actually programmable.
While everyone obsesses over whether LLMs will get us to AGI, Omar Khattab is solving a more urgent problem: the gap between what you want AI to do and your ability to tell it, the absence of a real programming language for intent. He argues the entire field has been approaching this backwards, treating natural language prompts as the interface when we actually need something between imperative code and pure English, and the implications could determine whether AI systems remain unpredictable black boxes or become the reliable infrastructure layer everyone’s betting on.
Follow Omar Khattab on X: https://x.com/lateinteraction
Follow Martin Casado on X: https://x.com/martin_casado
Check out everything a16z is doing with artificial intelligence here, including articles, projects, and more podcasts.
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.
Stay Updated:
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.

Leave a Reply
You must be logged in to post a comment.