rust-rebuilder_skill

Overview

This skill plans and executes incremental rewrites of existing projects into Rust using verifiable, roll-backable steps. It prioritizes behavioral equivalence and observability before performance or architecture optimizations. The workflow enforces dependency preflight, downstream synchronization with upstream GitHub sources, and explicit migration artifacts for every step.

How this skill works

Before any run it checks required integrations and pauses with installation guidance if dependencies are missing. It maps source modules, interfaces, and data models to Rust crates and modules, slices work into independently verifiable batches, and produces compile/test/benchmark pipelines plus parity checks. For backend targets it enforces a checklist of Rust backend guardrails and emits a mandatory output contract describing scope, equivalence strategy, design decisions, risks, and upstream sync notes.

When to use it

• Port a legacy service, library, or subsystem to Rust while preserving existing behavior
• Create a phased, auditable migration plan with per-batch verification and rollback criteria
• Validate use of recent Rust features while retaining a conservative fallback path
• Avoid common migration pitfalls like ownership misuse, Result-semantic loss, or concurrency anti-patterns
• Keep the Rust migration continuously synchronized with an active GitHub upstream repository

Best practices

• Run dependency preflight before every execution and follow the provided installer or manual install links if missing
• Define clear scope and acceptance criteria for each migration batch (compile + tests + metrics)
• Always copy semantics first then apply idiomatic Rust improvements in separate batches
• Provide both a latest-feature path and a conservative stable path for language/feature choices
• Maintain an explicit risk register and rollback plan for each batch

Example use cases

• Rewriting a monolithic backend API into Rust crates, preserving HTTP/DB behavior and gradually replacing internals
• Porting a critical data-processing pipeline to Rust with benchmark parity and stepwise optimization
• Creating a migration backlog mapped to upstream GitHub commits/PRs for a repo with active development
• Auditing and converting async job workers to idiomatic Rust with runtime-safe patterns and error-model consolidation