What happened
An AI wrote 180,000 lines of code to solve a problem that had blocked a popular Windows application for over a decade. Rick Brewster, the developer behind Paint.NET, revealed that Anthropic's Claude built a complete, from-scratch, clean-room reverse-engineered rewrite of Microsoft's Direct2D graphics library so Paint.NET could finally run properly on WINE, the compatibility layer that lets Windows software run on Linux.
The blocker was Direct2D itself. WINE's own implementation of the graphics API was never going to be complete enough for Paint.NET's needs, and Brewster couldn't simply disable the feature — Paint.NET depends on it. So instead of waiting for WINE to catch up, Claude built a standalone replacement, packaged in a file called PaintDotNet.Windows.Direct2D1.Managed.dll, triggered by a `/wine` flag.
### The scale of the code
180,000 lines is not a small patch. For comparison, Brewster says the rest of Paint.NET — a codebase he's maintained for more than 20 years — totals around 700,000 lines. That means Claude generated code equal to roughly a quarter of two decades of human-written work, for a single subsystem, in a fraction of the time.
### Why this had stalled for years
Direct2D reimplementation was, in Brewster's words, always "the biggest hurdle" for Paint.NET on WINE. Reverse-engineering a proprietary Microsoft graphics API — including the math behind its built-in visual effects — is exactly the kind of grinding, detail-heavy work that discourages solo maintainers from ever starting.
Why it matters
This case matters because it's a rare, concrete data point on what an AI coding agent can do unsupervised on a hard, narrowly scoped engineering problem — not a demo, but shipped code in a real, widely used application with millions of downloads.
It also reframes what "AI-assisted coding" can mean. This wasn't autocomplete or a few generated functions reviewed line by line. Brewster is explicit that most of the code is "vibe coded" — written with trust rather than full review, because reviewing 180,000 lines by hand simply isn't feasible for one person.
### A decade-old problem, solved in weeks
The key fact here isn't just the line count — it's that a problem which sat unsolved for years, because no human had the time or appetite to reverse-engineer an entire graphics API, got resolved once an AI agent was pointed at it directly. That's a different kind of unlock than speeding up code a developer was already going to write.
### The trust trade-off
Brewster's own description — "trust me bro" style code — is the honest part of this story. He's not claiming full confidence in every line; he's saying the alternative (nobody ever writing this) was worse than shipping AI-generated code he couldn't fully audit.
How to use it today
For teams facing their own "decade-old problem" — a legacy integration nobody wants to touch, an undocumented file format, a compatibility layer no one has time for — the practical takeaway is to scope the AI agent narrowly around one blocking subsystem rather than the whole codebase, and let it run with real autonomy instead of reviewing every line in real time.
Brewster's account also shows what active supervision still looks like in practice: he caught Claude skipping proper reference counting (the COM equivalent of AddRef) on shared objects, and had to correct architecture and design decisions along the way. The lesson is that autonomy doesn't mean absence of oversight on the parts that are cheap to check — memory management, resource lifecycles, and structural decisions — even when full line-by-line review is off the table.
Teams experimenting with AI coding agents on smaller, well-defined tasks — writing a script, converting a data format, prototyping a feature — can get a feel for this workflow using free tools like the AI utilities at [mykreatool.com](https://mykreatool.com) before committing an agent to something as large as a 180,000-line subsystem.
Who benefits
Open-source and small-team software maintainers stand to gain the most. Projects with a single maintainer, like Paint.NET, are exactly where large, unglamorous engineering debt piles up — the kind of work that never gets prioritized because it's expensive in time, not money. An AI agent that can independently tackle a 180,000-line reverse-engineering project changes the math on which of those problems are worth attempting at all.
Developers who work on compatibility layers, legacy format support, or protocol reimplementation also benefit directly — this is precisely the class of problem (large surface area, tedious detail work, low day-to-day motivation) where an autonomous coding agent's stamina matters more than raw cleverness.
### Linux and WINE users
End users running Paint.NET on Linux through WINE are the most immediate beneficiaries: a feature that was structurally blocked for years is now functional, without waiting on either Microsoft or the WINE project to close the gap.
Risks
The central risk is exactly what Brewster names: unreviewed code shipping in production software. 180,000 lines that haven't been fully audited is a real attack surface and a real bug surface, even from a capable AI agent. Brewster himself found and fixed a reference-counting bug that could have caused memory leaks or crashes had it gone unnoticed.
There's also a reproducibility risk worth naming plainly: Brewster describes Claude's output quality as inconsistent — "working with the fury of 10 freshly unshackled Einstein genius-level 10x coders" at times, and "not so much" at others. Teams adopting this approach should expect variable output quality within the same project, not a uniform standard, and budget review time accordingly for the weaker stretches.
Conclusion
Claude writing 180,000 lines of code to solve a problem Paint.NET's maintainer had lived with for over a decade is a concrete signal that AI coding agents can now take on large, self-contained engineering problems with real autonomy — not just assist with small edits. The catch, by the developer's own account, is that this code was largely unreviewed and required active human correction on critical details like resource management. For teams evaluating this approach, the opportunity is real, but so is the need to keep a human in the loop on the parts that are cheap to check and expensive to get wrong.
Comments 0