From Hand-Written Code to AI-Managed Software: DHH's Claude Rewrite of a Python Library

Introduction

A year ago, Rails creator David Heinemeier Hansson (DHH) was one of the more vocal developers defending the pleasure of writing code by hand.

Now his position looks very different.

After spending more time with Claude Code and Codex, DHH recently used Claude Fable 5 to rewrite the Python library TerminalTextEffects in Rust. According to the source article, the project consumed about 11 million tokens and was completed largely as a hands-off agent workflow.

The result was striking: startup time reportedly fell from 87 ms to 2 ms, while rendering became roughly 9.6× faster.

The experiment also triggered a bigger question. If an experienced programmer can hand a substantial rewrite to an AI agent and get a working result with little direct intervention, what exactly will programmers be doing five years from now?

Put the Keyboard in AI's Hands, and Retire?

The contrast with DHH's position from last year is hard to miss.

In May 2025, he published “Coding should be a vibe!”, arguing that AI should remain closer to a pair programmer: useful for checking APIs, answering questions, and helping with specific problems, but not replacing the act of writing code itself.

The source article quotes an even stronger position: if developers eventually had to give the keyboard completely to AI, DHH said he would rather retire.

In a six-hour conversation with Lex Fridman, DHH also described the feeling of losing "muscle memory" when AI repeatedly generated code for him.

One example involved building a Linux distribution. He asked AI to generate the same Bash conditional several times, only to realize that because he had not physically typed the statement himself, he did not feel that he had truly learned it.

That raised a deeper question for him: could AI-assisted programming eventually weaken the way developers learn software engineering?

But by April 2026, according to the source article, his position had shifted toward an agent-first workflow.

And now he is openly asking what software development looks like when the keyboard is no longer the main interface.

Claude Fable 5 Takes a Python Library Apart and Rebuilds It in Rust

The project DHH chose was TerminalTextEffects (TTE), a terminal visual-effects engine that can be used both as a command-line application and as a Python library.

TTE provides effects for text movement, colors, gradients, animations, and other terminal visuals. Its public repository describes it as a terminal visual-effects engine and documents both CLI and Python-library usage.

The source article says DHH asked Claude to rewrite the project in Rust.

The resulting Rust project, called ttfx, was placed under DHH's Omarchy organization. According to the article, the new version could run 37 effects and was packaged as a roughly 3 MB executable, eliminating the need for a Python runtime.

The reported execution time was about 3 hours and 11 minutes.

The Rust implementation contained around 21,000 lines of main code, close to the size of the original Python codebase.

The workflow was also very different from traditional "AI autocomplete."

The source article says eight agents worked in parallel on separate branches. They independently read code, generated implementations, compiled the results, ran tests, fixed failures, and moved into the next round.

In that sense, the "one-shot" description does not mean the AI produced everything from a single completion. It means DHH handed over the task and let the agents carry the development loop themselves.

Codex Was Given the Same Job

DHH repeated the experiment with Codex.

According to the source article, a single prompt was enough to produce another strong result. However, the Codex version reportedly took about 30% longer and cost around $43, or roughly ¥290.

The comparison is useful because it shifts attention away from the simplistic idea that AI coding is either "magic" or "bad."

Two different coding agents can be given the same broad task and produce working results while differing in speed, cost, and workflow behavior.

The Anthropic team also noticed the experiment.

Claude Code creator Boris Cherny reportedly reacted publicly to the result, while Anthropic researcher Thariq asked DHH about how much planning or workflow design had gone into the rewrite.

DHH's answer was arguably the most surprising part.

He said he essentially let Claude make the plan and then left it alone.

There was no elaborate prebuilt workflow, no long list of manually defined milestones, and no continuous steering.

The approach was deliberately hands-off.

One-Shot Does Not Mean Blind

There is an important distinction here.

A fully autonomous coding task still depends on the agent having enough information to decide what success looks like.

The source article says DHH first asked Claude to formulate the plan, and then allowed the agents to execute, test, and iterate.

That is closer to delegating a software-engineering project than to asking an autocomplete system for the next ten lines of code.

This style of agentic development relies heavily on:

A repository with an understandable structure.
A strong automated test suite.
Clear build and run commands.
The ability to create branches and merge changes.
Agents that can inspect failures and try again.

Without those foundations, "one-shot" automation becomes much less reliable.

The Bigger Demonstration: Bun's Million-Line Migration

TerminalTextEffects is still a relatively small project.

The source article therefore points to a much larger example: Bun, the JavaScript runtime created by Jarred Sumner.

Bun has historically been built around Zig. In 2026, its codebase underwent a major migration toward Rust with extensive use of AI coding agents.

The source article describes the effort as a roughly million-line migration that was completed in under two weeks.

Later public records confirm that Bun's Rust rewrite was merged into its main repository. GitHub's pull request for the rewrite was merged on May 14, 2026, and the migration replaced the previous Zig-first build path with a Rust-first architecture.

The engineering story behind the migration is more nuanced than a simple "AI rewrote Bun."

Jarred Sumner's public account, summarized by Simon Willison, describes a sophisticated agentic workflow that included dynamic task decomposition, trial runs, adversarial review, and repeated validation.

That is a useful distinction.

Large-scale AI-assisted software migration still requires substantial engineering structure. The difference is that much of the implementation work can now be delegated to agents once the surrounding system is designed well enough.

The Marginal Cost of Code Is Moving Toward Zero

The source article draws a bigger conclusion from these examples.

As coding agents get better, the marginal cost of producing another implementation keeps falling.

Free · Use We0 AI

Build a showcase site and grow leads in minutes

Describe your idea once, and We0 AI can generate a showcase site, pages, and CMS, then help you attract customers and traffic after launch.

One complete project generation for free registration

Best for trying one complete generation flow and seeing a first project draft quickly.

Untitled-1

Layout

Fill

Radius

Generating

Generating code is becoming cheaper.

Testing, refactoring, porting between languages, and iterating over bugs can increasingly be performed by agents in parallel.

That changes the economics of software development.

The question is no longer simply:

How many developers can we hire to write this code?

It increasingly becomes:

How many useful software tasks can one developer delegate to a group of AI agents?

This is the transition from AI-assisted programming to AI-managed software development.

The Next Programmer May Be More Like a Dragon Trainer

The obvious fear is that if fewer people write or read code directly, programmers will disappear.

The source article argues that this conclusion is too simple.

"Nobody writes code by hand" does not mean "there are no programmers."

The job can shift.

Instead of spending most of the day implementing functions line by line, developers may spend more time on:

Defining what needs to be built.
Setting constraints and interfaces.
Designing the test system.
Reviewing architecture and trade-offs.
Checking whether the AI-generated code is actually correct.
Deciding what should and should not be automated.

In that model, the scarce skill is not typing syntax.

It is knowing what is worth building and what correct behavior actually means.

What Becomes Valuable When AI Writes the Code?

If implementation becomes increasingly cheap, other skills become more valuable.

Product Judgment

Someone still needs to decide what problem is worth solving.

An AI can generate ten implementations quickly, but that does not tell you which problem has commercial value, which trade-off matters, or which feature should be built first.

System Design

Agents can write functions and classes, but the larger system still needs boundaries, interfaces, data models, deployment rules, and reliability requirements.

Testing

The more code an AI can generate, the more important automated tests become.

Without a strong validation layer, increasing coding speed simply increases the amount of code that can be wrong.

Technical Direction

Someone has to tell the agents what constraints to respect.

That includes performance budgets, compatibility requirements, security boundaries, dependencies, and long-term maintenance goals.

In other words, the human role moves upward in the abstraction stack.

The Future May Be Less About Coding and More About Steering

The examples in the source article point toward a different definition of programming.

A developer may still need to understand code deeply, but the primary output is no longer necessarily the source file itself.

The output is the system of requirements, constraints, tests, and judgments that causes the right software to emerge.

That is why experienced engineers may remain valuable even as manual coding becomes less central.

The people who understand architecture, failure modes, user needs, and system behavior will be better positioned to direct autonomous coding agents.

常见问题

Did DHH really rewrite a Python library with AI?

According to the source article, yes. Rails creator David Heinemeier Hansson used Claude Fable 5 to rewrite TerminalTextEffects from Python to Rust with a largely hands-off, multi-agent workflow.

What is TerminalTextEffects?

TerminalTextEffects, or TTE, is a terminal visual-effects engine that can also be used as a Python library. Its public documentation describes effects for text movement, colors, gradients, animations, and other terminal visual treatments.

How did the Rust rewrite differ from normal AI coding?

The source article describes multiple agents working on separate branches, compiling the code, running tests, fixing failures, and merging results. The key difference is that the AI handled much of the development loop rather than merely suggesting individual lines of code.

Did Codex also complete the rewrite?

The source article says DHH gave Codex the same broad task and obtained another strong result. It reportedly took about 30% longer and cost around $43.

Was Bun also rewritten with AI agents?

Yes. Bun's major Zig-to-Rust rewrite was carried out with extensive AI-agent assistance, and the rewritten Rust-first code was merged into the main repository in May
2026.

Will programmers disappear if AI writes most of the code?

Not necessarily. The likely change is that programmers spend less time typing implementation details and more time defining requirements, constraints, architecture, tests, and acceptance criteria.

What skills matter most in an AI coding workflow?

Strong system design, testing, debugging, product judgment, and the ability to define clear constraints become especially important. Knowing how to review and verify AI-generated code is also critical.

Summary

DHH's TerminalTextEffects experiment is a useful example of how AI coding agents are changing the unit of software work. Instead of asking an AI to write one function at a time, developers can increasingly delegate entire refactors and migrations to agent teams.

The Bun rewrite points in the same direction at a much larger scale: AI can now participate in broad, multi-step software engineering when the repository, tests, tooling, and workflow are strong enough.

The biggest change may not be that AI writes more code. It may be that the programmer's job moves from writing code to defining what the code should accomplish and proving that it does.