Lessons from an AI-Assisted Python to Rust Migration

If there’s one constant in working with AI-powered code development tools, it’s their seemingly magical capabilities that eventually hit a wall.

One moment, an AI agent effortlessly analyzes your codebase, offering astute observations on its structure and architectural decisions. The next, it’s inundating your console with repetitive strings like “CoreCoreCoreCore” until the buffer overflows and you’ve exhausted your token allowance.

As AI coding and development tools mature, we’ve gained a clearer understanding of their strengths, weaknesses, and scenarios where they might be counterproductive. Ideally, they should empower developers by handling monotonous or daunting tasks: generating tests, refactoring code, crafting documentation examples, and more. In reality, this “empowerment” often comes with a hidden cost. What an AI simplifies initially can complicate matters significantly down the line.

One ambitious idea I’d considered was leveraging AI tools for porting code between different languages. If I had initiated a Python project and later decided to transition it to Rust, could an AI agent accelerate my progress? Or at least provide effective assistance?

Such a question warranted a practical investigation—even if it meant encountering unexpected challenges. This article details my experience using Claude Code to port one of my Python projects into Rust.

Project background and my rationale for selecting Rust

I decided to attempt porting a Python-based blogging system I developed. This server-side application generates static HTML and offers a WordPress-like interface. I chose it partly due to its relatively modest feature set: a per-blog templating system, categories and tags, and an interface supporting post creation in HTML (with a rich-text editor) or plain Markdown.

I confirmed that all the core features—the templating engine, the ORM, the web framework—had suitable counterparts within the Rust ecosystem. The project also included some JavaScript front-end code, offering an opportunity to assess how effectively the AI tooling handled a mixed-language codebase.

Rust was my chosen target for porting primarily because its guarantees of correctness and safety are enforced at compile time, not runtime. My reasoning was that the AI should benefit from valuable compiler feedback throughout the process, making the porting more successful. (Optimism, after all, springs eternal!)

For the AI component, I initially selected Claude Sonnet 4.5, but was forced to upgrade to Claude Sonnet 4.6 when the older version was suddenly deprecated. I also utilized Google’s proprietary Antigravity IDE, which I have previously reviewed.

The initial instruction

I created a duplicate of my Python codebase directory, launched Antigravity within it, and issued a straightforward instruction:

This directory contains a Python project, a blogging system. Examine the code and devise a plan for how to migrate this project to Rust, using native Rust libraries but preserving the same functionality.

After processing the code, Claude proposed the following components as part of the strategy to “transition to a modern, high-performance Rust stack”:

• Axum for the web layer.
• SeaORM for database interactions.
• Tera for templating.
• Tokio for asynchronous task handling (as a replacement for Python’s multiprocessing).

Claude encountered no apparent difficulty in identifying suitable replacements for the Python libraries or in mapping operations from one language to the other—such as utilizing tokio for async processing instead of Python’s multiprocessing. I believe this phase was relatively smooth due in part to the design of my original program, which avoided reliance on complex Python features like dynamic imports. It also helped that Claude approached the task by analyzing and re-implementing program behaviors rather than merely translating individual interfaces or functions. (This method did present certain limitations, which I will elaborate on later.)

I reviewed the generated plan and observed that it omitted placeholder data for a freshly initialized database—things like a sample user or a blog with an example post. I prompted Claude to add these, and after it did, I verified their functionality by restarting the program and inspecting the newly created database. So far, so good.

Several omissions emerged

The subsequent stage revealed the extent of Claude’s incomplete work. Despite successfully identifying and implementing my application’s core page-rendering logic, it failed to create any of the user-facing infrastructure—specifically, the admin panel for logging in, editing, and managing posts. However, it’s worth noting that my initial instructions made no mention of that interface. Should I fault Claude for its lack of thoroughness, or myself for not being explicit enough in my original prompt? Regardless, I highlighted the oversight and received a subsequent plan to address that functionality:

I'm now addressing the missing Admin UI by analyzing the original Bottle templates and planning their migration to Tera, including the login screen and main dashboard.

Note: Bottle served as the web framework for my original Python project. This presented its own test: how effectively would Claude manage migration from a less common library? This particular aspect didn’t prove to be a major hurdle, but significantly larger issues lay elsewhere.

It was at this juncture that the extensive back-and-forth communication with Claude truly commenced. For developers already accustomed to AI tools, this cycle will be familiar: the prompt—>generate—>test—>re-prompt loop. Essentially, I would have Claude implement a missing feature (in this instance, each component of the admin UI), then run the program myself to test it, encounter various errors or gaps, and then cajole Claude into correcting them.

The first issue I discovered in the admin UI was an unhandled runtime error stemming from the web templates, something Rust’s compile-time checks didn’t catch. Subsequently, the login page for the admin panel appeared blank. Once the login page eventually functioned, it redirected me to a placeholder page stating, “Login logic not yet implemented.” After that, the logic for authenticating usernames and passwords proved flawed. And so this pattern continued, across every original application component.

Significant and minor operational failures

In certain respects, utilizing Claude for code migration mirrored my prior experiences with rewriting or porting programs without AI assistance. Progress occurred in fits and starts, and what appeared to be straightforward tasks often proved unexpectedly challenging. Occasionally, the reverse occurred: something I anticipated would be difficult resolved quickly, which was a pleasant surprise.

One notable distinction, however—familiar to anyone who has used AI coding tools—was how Claude would sometimes malfunction, requiring substantial intervention to resume normal operation. At one point, when I instructed Claude to continue developing the admin page for each blog, it malfunctioned and began relentlessly printing CoreCoreCoreCoreCore... to the console. I ended up with hundreds of lines of this output, and Core also started appearing randomly at the end of various responses:

Implementing Blog Detail and Post ListCoreCore

I've implemented the blog detail and post management features, fixed type mismatches, and updated the project artifacts. I'm now performing a deep dive into the remaining compilation error by capturing the complete cargo check output to ensure the system is production-ready.CoreCoreCoreCore

Subsequently, I began receiving warnings that the model’s generation had surpassed the maximum output token limit. The issue resolved itself after I restarted the session the following day, but I remained vigilant, scrutinizing all subsequent outputs for similar odd glitches.

Another observation was Claude’s tendency to operate on unverified assumptions about its environment, correcting them only after encountering errors, and not always consistently. For example, it would frequently issue shell commands using bash syntax, fail, recognize it was running in PowerShell, and only then issue a correct command.

This is a recurring pattern with AI code tools, as I’ve noted: they generally plan only as much as you explicitly instruct them to, and it’s easy to overlook crucial details that require definition. The more consistently you articulate requirements to the model, the more reliable the outcomes will be. (Keep in mind that “more consistent” implies improvement, not absolute or perfect consistency.)

Finally, a manual inspection of the generated code revealed numerous instances where Claude overlooked the original code’s intent. For example, in my initial Python program, all web UI routes were protected by a login-validation decorator. If a user wasn’t logged in, they were redirected to a login page. Claude almost entirely failed to replicate this pattern in the ported code. Nearly every route in the admin UI—including those performing destructive actions—was left completely vulnerable to unauthorized access.

Moreover, when validation was present, it manifested as boilerplate code inserted at the top of route functions, rather than a modular solution like a function call, decorator, or macro. I’m unsure if Claude failed to recognize the original Python decorator pattern or simply didn’t have an effective strategy for porting it to Rust. Either way, Claude didn’t even acknowledge the omission; I had to discover it the hard way.

Three key insights

After several days of intensive interaction with Claude, I successfully migrated a considerable portion of the original application’s functionality to Rust. At that point, I paused to assess the experience and distilled three primary takeaways.

1. Proficiency in both source and target languages is essential

Using tools like Claude for inter-language migration doesn’t negate the necessity of understanding both the source and target languages deeply. While you might ask the agent for clarifications and assistance, this isn’t a substitute for your own ability to identify problematic generated code. If you are unaware of your knowledge gaps, Claude will offer limited help.

I possess more experience with Python than with Rust, but my Rust knowledge was sufficient to a) understand that Rust code compiling successfully doesn’t guarantee its flawlessness, and b) recognize logical gaps in the code—such as the absence of security checks in API routes. My conclusion is that many migration issues aren’t glaringly obvious, but rather subtle complexities demanding solid expertise in both domains. Automation can enhance experience, but it cannot replace it.

2. Prepare for an iterative process

As previously stated, the clearer and more persistent your instructions are, the greater the likelihood of achieving results that align with your intentions. Nevertheless, it’s improbable you’ll get precisely what you want on the first, second, third, or even fourth attempt—not even for a single aspect of your program, let alone the entire project. True mind-reading capabilities are still a distant prospect. (Thankfully.)

A degree of back-and-forth is seemingly unavoidable to achieve your desired outcome, particularly when re-implementing a project in a different language. The advantage is that you’re compelled to evaluate each set of changes as you progress, ensuring their functionality. The drawback is that this process can be draining, and in a way distinct from making iterative changes independently. When you work alone, it’s you against the computer. When an agent makes changes for you, it becomes you against the agent against the computer. The inherent determinism of the computer is replaced by the indeterminism introduced by the agent.

3. Maintain complete ownership of the outcomes

My final lesson is to be prepared to assume full responsibility for every line of AI-generated code within the project. You cannot simply deem it acceptable just because it executes. In my scenario, Claude may have been the generating agent, but I was the one approving decisions at every stage. As the developer, you remain accountable—and not merely for ensuring everything functions. It’s equally important how effectively the results leverage the target language’s paradigms, ecosystem, and conventional practices.

Certain contributions can only come from a developer with genuine expertise. If you’re not comfortable with the technologies you’re employing, consider thoroughly learning the landscape before you ever open a Claude prompt.