Why Rust Powered My Startup’s AI Docs Tool—And What I Learned in the Process

Sergio Tortosa didn’t set out to build a Rust-based startup when he started Dokumentado 18 months ago. He set out to create an AI tool that could generate clean, complete documentation from a simple repository connection. What he ended up with was a crash course in both the promise and pitfalls of using Rust for early-stage projects—and a front-row seat to how quickly the tech landscape can shift.

A Rust-powered vision for automated documentation

Dokumentado’s core idea was straightforward: link your codebase to a service that produces elegant, self-contained documentation without requiring manual comment entries. Tortosa built it entirely in Rust, a language he adored but also knew would shape the project’s long-term stability. His reasoning wasn’t just aesthetic—though he did joke about announcing “another 3D widget I made in Rust” to friends. Rust’s type system, minimal runtime overhead, and resistance to dependency rot promised lower maintenance and fewer surprises down the road.

The gamble paid off in many ways. Dependency updates, once a headache in his earlier JavaScript dabbling, became routine thanks to automated tools. The compiler caught issues early, and once code passed its checks, crashes in production were rare. But Rust’s strengths also introduced new complexities, especially when bridging systems with fundamentally different operating models.

The async abyss: why Rust’s concurrency model broke my flow

The project’s biggest technical hurdle wasn’t algorithmic complexity—it was integrating Salesforce’s per-file API with a per-project workflow across a single Rust codebase. Layer on Rust’s generics, lifetimes, and async ecosystem, and that hurdle became a cliff.

At the heart of the struggle was Rust’s AsyncStream, a trait-based abstraction that lets functions pause, resume, and resume again without losing state. When a future hits .await, Rust saves the function’s entire context—variables, stack, everything—and resumes later. That’s powerful: it avoids thread swapping, reduces memory churn, and lets the compiler optimize aggressively.

But when AsyncStream itself needed custom trait implementations, the illusion of simplicity shattered. The compiler’s safety guarantees didn’t help when the trait’s requirements forced low-level boilerplate that felt anything but zero-cost. Debugging state resumption across multiple async layers became a nightmare, and “usually” stopped being a word Tortosa could rely on.

async fn send_file_through_http(path: &Path) -> Result<()> {
    let file = tokio::fs::read(path).await?;
    if !verify_file(&file) {
        return Err(Error::WrongFile);
    }
    my_http::send_file(file).await?;
    println!("Sent file correctly");
    Ok(())
}

That snippet hides two hidden save points—two moments where the runtime can pause execution and return control to the scheduler. When AsyncStream entered the picture, those pauses no longer aligned with Rust’s compiler magic. The code still ran safely, but reasoning about it alive in production felt like navigating a maze with a blindfold.

Integration overload and the curse of perfectionism

Even after solving the async puzzle, Dokumentado’s release slipped for a reason beyond code: platform sprawl. The tool had to speak to GitHub, GitLab, Bitbucket, Salesforce, and half a dozen documentation formats. Each integration required custom API bindings, OAuth flows, and idempotent retries—tasks Rust doesn’t always streamline.

Tortosa’s own perfectionism exacerbated the delay. He rebuilt parsers, rewrote serializers, and chased edge cases that real users never encountered. The result? A polished system that arrived too late for its own market moment.

Timing, traction, and the ghost of zero users

When the first usable version shipped, the AI wave had already reshaped expectations. Users saw Dokumentado not as a niche Rust tool but as just another AI documentation generator. Even the hundred-plus beta testers Tortosa expected never materialized. Zero users greeted launch day.

He places part of the blame on timing. By the time the product stabilized, LLMs had commoditized what once felt like a unique value proposition. He also admits to a classic founder trap: waiting for the “perfect” product instead of shipping early and iterating.

Rust itself didn’t doom the project. But Rust in 2023 still lacked battle-tested web scaffolding compared to ecosystems like Node.js or Python. Building integrations from scratch added months of hidden work. Tortosa’s takeaway is clear: language choice matters less than timing and market fit. A great idea in the wrong window is still a missed opportunity.

The future: LLMs, Rust, and second chances

Ironically, it’s the same AI wave that eroded Dokumentado’s original edge that now offers a glimmer of hope. Tortosa now sees Rust as a viable choice—not because it’s inherently better for startups, but because modern tooling and LLMs can automate much of the boilerplate that once made Rust painful.

He’s not alone. More founders are pairing Rust’s safety with AI-assisted code review, dependency updates, and even async pattern generation. The language’s ecosystem has matured, and its zero-cost abstractions finally align with the demands of AI-native tooling.

Rust can still power a startup—but only if founders pair it with velocity, empathy for users, and a willingness to ship early. The tech stack is no longer the bottleneck. The real question is whether the idea still matters when the world moves on.