Rust instead of Node.js: 5-10x CLI acceleration

Migrating CLI Scripts from Node.js to Rust: 5-10x Speed Boost with AI

Node.js 18 CLI scripts processed project files: recursive directory traversal, line counting by extension, and Markdown parsing with front matter extraction. On an M4 MacBook, execution took 2 seconds. On an Intel Core i5-1035G1 with 8GB RAM, it took 8 seconds. This difference becomes critical with repeated runs.

Rewriting in Rust with an AI assistant (Claude Code) delivered a 5-10x speedup. Code was generated iteratively: the Rust compiler flagged errors, and the AI fixed them without manual intervention.

Technical Context & Use Cases

Scripts handled typical tasks:

• Recursive traversal via glob, aggregating line-count statistics across files.
• Markdown parsing, front matter extraction, and index generation.

Bottleneck: sequential promise execution and unoptimized globbing. Node.js could have been optimized, but Rust excels at file traversal and CPU-bound operations—much like how ripgrep or fd outperform grep/find by 10-20x.

The experiment focused on straightforward tasks: roughly 200 lines of code each, with no network calls, multithreading, or complex business logic.

AI-Assisted Migration Process

• Fed the original source code to Claude Code with instructions to port it to Rust.
• The compiler caught type mismatches and lifetime issues; the AI iteratively patched them.
• Final code review: spent 20 minutes verifying logic and comparing it against the original.

The resulting Rust code was surprisingly readable. Strict typing created a tight feedback loop: precise compiler errors acted as automated code review for the AI. No manual debugging or deep Rust expertise was required.

Distributing Binaries

Rust binaries are platform-specific, making Git storage inefficient. The solution mirrors esbuild: npm packages bundling precompiled binaries for each platform. npm install fetches the correct binary without exposing source code.

Benchmarks

| Machine | Node.js 18 | Rust | Speedup |

|---------------------|------------|----------|-----------|

| i5-1035G1, 8GB RAM | ~8 s | 1-1.5 s | 5-7x |

| MacBook M4 | ~2 s | ~0.3 s | ~6x |

These results are typical for file I/O combined with CPU-heavy aggregation. Similar to tools like ccusage, which can see up to 1000x gains on specific operations.

Limitations & Caveats

Task Suitability:

• Network or DB calls: no performance gain (Rust won't speed up I/O waits).
• Scripts under 1s: not worth the effort.
• Always profile first: use node --prof or time.

AI Generation Constraints:

• Only for simple scripts. Complex architectures (traits, async) are out of scope.
• AI-maintained code accumulates technical debt.
• Teams without AI access will struggle to understand or modify the code.

Key Takeaways

• Rust + AI delivers a 5-10x speedup for file traversal and CPU-bound CLI tasks.
• The Rust compiler automates debugging for AI-generated code.
• Distributing via npm with platform-specific binaries is a practical approach.
• Profile before migrating; this only makes sense for simple, isolated scripts.
• Technical debt warning: heavy reliance on AI for future refactoring.

This approach scales well to similar utilities where Node.js hits I/O or CPU bottlenecks.

— Editorial Team