Europe 2026
Why Rust is the Ideal Language for Vibe-Coding — Daniel Szoke, Sentry
Overview
This talk argues that Rust is a superior language for agentic coding, often referred to as vibe coding, despite conventional wisdom favoring languages like Python and TypeScript. The speaker contends that while dynamic languages are easier for LLMs to generate initially, this ease comes at the cost of increased error potential. Rust's strict compiler and numerous constraints, though posing a steeper learning curve for LLMs, provide deterministic guardrails that significantly reduce bugs and improve code reliability.
Who should watch
- AI engineers building agentic systems
- Developers seeking to improve code quality and reduce bugs in AI-assisted development
- Those exploring alternative languages for AI coding beyond Python and TypeScript
- Engineers interested in the trade-offs between LLM ease-of-generation and code robustness
Key takeaways
- Python, JavaScript, and TypeScript are popular for agentic coding due to their familiarity, extensive libraries, and ease of scaffolding, making them simple for LLMs to generate.
- The flexibility of these dynamic languages, while beneficial for LLM generation, also makes them prone to subtle and obvious errors that can be hard to detect.
- Relying solely on tests and code review agents is insufficient, as tests may not cover all edge cases, and LLMs can generate flawed tests or code.
- Rust's compiled nature and strict compiler enforce invariants like type safety, memory safety, and fearless concurrency, catching many potential bugs at compile time.
- While Rust is harder for LLMs to write initially, its compile-time error messages are informative, aiding AI agents in fixing issues autonomously.
- The deterministic guardrails provided by Rust's compiler are crucial for mitigating LLM fallibility and preventing bugs in production code.
- *Rust's strict compiler ensures that if code compiles, many types of bugs are absent.*
- The trade-off for Rust's constraints is a higher initial barrier for LLMs, but this leads to more robust and reliable code, especially in autonomous agent loops.
Notable quotes
Daniel Szoke: *The importance of it being easy for the model to write the language is overstated.*
Daniel Szoke: *Anything that can go wrong will go wrong eventually at some point.*
Daniel Szoke: *Every compile error is potentially a bug that you avoid in your production code.*
Unofficial community note. Prefer the recording for nuance.