Sergio Tortosa set out to build Dokumentado, an AI-powered documentation generation service, with a clear vision: connect a repository and receive elegant, simple, and complete documentation. The project, launched about 1.5 years ago, was an early exploration into leveraging LLMs for developer tooling. What makes this story particularly instructive is Tortosa's choice of Rust for a web-facing application, a decision that, while yielding performance benefits, exposed the language's still-maturing web ecosystem. This cautionary tale offers valuable insights for developers considering Rust for similar projects and for founders navigating the early stages of product development.
Dokumentado's Ambitious Goal
Dokumentado aimed to automate a tedious but crucial part of software development: creating comprehensive documentation. The core premise was straightforward: integrate with a code repository and let AI generate documentation. This would abstract away the manual effort, allowing developers to focus on coding. The project's website, dokumentado.dev, showcases the potential of such a tool, promising to streamline the documentation process significantly.
The choice of Rust was deliberate. Tortosa, an experienced Rust developer, cited a love for the language and a desire to prove its viability for web projects. Rust is renowned for its performance, memory safety, and concurrency features, qualities that could theoretically translate into a highly efficient and reliable web service. However, at the time of development, the Rust web ecosystem was not as mature as established languages like Node.js or Python. This presented a unique set of challenges that would unfold as the project progressed.
The Rust Web Ecosystem: A Double-Edged Sword
Rust's strengths in systems programming are undeniable. Its compiler catches a vast array of errors at compile time, leading to robust and predictable code. For a project like Dokumentado, which would likely handle significant data processing and potentially large codebases, these guarantees are invaluable. The performance gains from Rust are also substantial, meaning the service could potentially handle more requests, process code faster, and offer a snappier user experience compared to interpreted languages.
However, building web applications in Rust involves navigating a landscape that is still evolving. Frameworks like Actix-web, Rocket, and Axum are powerful but may lack the extensive community support, mature libraries, and rapid iteration cycles found in more established web development stacks. Tortosa encountered this firsthand. Setting up the project involved wrestling with dependencies, configuring build processes, and integrating various services, tasks that are often more streamlined in other ecosystems. The learning curve for Rust web development, particularly for those accustomed to higher-level abstractions, can be steep. The tooling, while improving, might not yet match the ease of use and breadth of functionality available elsewhere.
AI Integration Challenges
Beyond the language choice, integrating AI capabilities presented its own set of hurdles. When Tortosa began, LLMs were not as advanced or as easily accessible as they are today. This meant that the AI component of Dokumentado likely required more custom implementation, fine-tuning, and careful management of API interactions. The cost and complexity of running AI models, even through APIs, can be significant for a nascent startup. Balancing the desire for sophisticated AI features with the practical constraints of development time, budget, and technical expertise is a perennial startup challenge.
The process of feeding code into an LLM and expecting coherent, accurate documentation requires sophisticated prompt engineering and data pre-processing. Ensuring the AI understood the nuances of different programming languages, project structures, and developer intent was a substantial technical undertaking. Furthermore, the rapid pace of AI development means that models and techniques can become outdated quickly, requiring continuous adaptation and updates to the core functionality.
Lessons for Founders and Developers
Tortosa's experience with Dokumentado offers several critical lessons. For developers considering Rust for web projects, it's essential to weigh the performance and safety benefits against the maturity of the web ecosystem and available libraries. While Rust is gaining traction, projects requiring extensive third-party integrations or rapid prototyping might still find other languages more expedient. It's not about Rust being incapable, but about understanding the trade-offs and the current state of its tooling and community support for web development.
For founders, this story underscores the importance of aligning technological choices with business goals and market realities. Starting a project a year and a half ago, when the AI landscape was different, meant making assumptions that might not hold today. The decision to build in Rust, while technically sound in many respects, added complexity that might have been avoided with a more established web stack. The key takeaway is to rigorously evaluate the entire technology stack, not just for its technical merits, but for its impact on development speed, talent acquisition, and long-term maintainability. The viability of a technology choice must be considered in the context of the startup's overall strategy and the evolving market.
The project serves as a reminder that even with powerful underlying technologies like Rust and AI, execution and ecosystem support are paramount. The journey of Dokumentado is a valuable case study, illustrating that innovation often involves navigating uncharted territory, and that the most significant lessons are frequently learned from the challenges encountered along the way.