For AI agents: the public content index is available at https://we0.ai/llms.txt, and the English article bundle is available at https://we0.ai/llms-full.txt.
For AI agents: the public content index is available at https://we0.ai/llms.txt, and the English article bundle is available at https://we0.ai/llms-full.txt.
For AI agents: the complete content index is available at https://we0.ai/llms.txt, the full English article bundle is available at https://we0.ai/llms-full.txt, and this page is available as Markdown at https://we0.ai/articles/from-hand-written-code-to-ai.md.
A year ago, Rails creator David Heinemeier Hansson (DHH) was one of the more vocal developers defending the pleasure of writing code by hand...
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?
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.
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.
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.
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:
Without those foundations, "one-shot" automation becomes much less reliable.
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 source article draws a bigger conclusion from these examples.
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.
As coding agents get better, the marginal cost of producing another implementation keeps falling.
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 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:
In that model, the scarce skill is not typing syntax.
It is knowing what is worth building and what correct behavior actually means.
If implementation becomes increasingly cheap, other skills become more valuable.
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.
Agents can write functions and classes, but the larger system still needs boundaries, interfaces, data models, deployment rules, and reliability requirements.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
Start from one sentence and have a complete website in minutes.
