AI-Native Series · Field notes

The Other Road: Reverse-Engineering Closed Products Into Open Ones

By Paul Jialiang Wu · agentic-portfolio-lovat.vercel.app · 2026-08-05

Here's a model you can re-run tomorrow without this essay: most AI products are vending machines. You put money in, a thing comes out, and you own neither the machine nor — often — the thing. Type a prompt into a closed music generator, get a song you can't build a catalog on. Upload a script to a closed avatar tool, get a video and a subscription that ends the day you stop paying. The machine works. That was never the problem. The problem is that you don't own the loop.

The work I want to describe isn't "cloning" those machines. Cloning copies the vending machine and inherits every constraint that made it a cage. What we do is quieter and, I think, more interesting: reverse-engineer the loop the machine withholds, and rebuild the open, owned version of it. Not "how is this coded" — that's a lawsuit and a dead end. "What outcome does this deliver, what compounding loop does it deny me, and can I build that loop clean-room, spec-first, in a form I own?" Three products came out of asking that question. None of them started by looking at anyone's source code.

The three

Song of Songs — the other road around a closed song generator. A closed generator makes you a track and stops; it's a vending machine with a great voice. Song of Songs is the flywheel version: type a sentence, get a finished, mastered song built on license-clean open models (so the catalog is legally yours to release), then package → market → sell → and let the ♥ it earns decide what you make next. The reverse-engineering wasn't of anyone's weights. It was of the category's missing loop: closed generators deliberately stop at "output" because ownership + distribution + audience feedback is exactly the flywheel that would let you leave. It's live — you can make a song in a browser right now.

ByeGen — the honest teardown of an avatar-video tool. This one is not a shipped consumer product, and saying otherwise would be the exact dishonesty the project exists to prevent. ByeGen is a teardown: we specced a commercial talking-avatar product from its public behavior, mapped each module to a license-clean open-source alternative, and built a term-by-term scorecard — lip-sync, face-similarity, speech accuracy — using metrics with real research behind them. The punchline is the lesson (below): most of those quality cells came back "not measured," because measuring them honestly needs a GPU we didn't have, and the scorecard refuses to print a number it didn't earn. A teardown that fabricated its own benchmarks would be worse than no teardown.

renovate-anything — reverse-engineering a process, not a product. Not every closed system is software. The kitchen-renovation pipeline is a black box too: you don't know your square footage, your ROI, or whether a quote is fair, so you defer to whoever's holding the tape measure. renovate-anything reverse-engineers that process into an agent that works for the homeowner — snap photos, get a send-ready contractor request, a budget-fit verdict that tells you what a $3,000–$6,000 budget genuinely can't do (spoiler: not new cabinets — replacement alone runs well past it), and a sourced ROI range instead of a salesman's number. Its first loop went live this week.

The pattern (and the anti-pattern)

Pattern: reverse-engineer the outcome and the withheld loop; rebuild it spec-first, clean-room, open, and owned, wrapped in an honesty scaffold. Anti-pattern: reverse-engineer the implementation — copy the UI, the code, the weights. That path is a legal minefield and, worse, hands you the original's constraints for free.

The mechanism that makes the pattern safe and repeatable has three parts. (1) Spec-first clean-room: observe public behavior → write a specification → rebuild without copying anyone's expression. This is the same principle that made interoperable software legal in the first place. As the Electronic Frontier Foundation's Reverse Engineering FAQ states it, "Courts have found that reverse engineering for interoperability, for example, can be a fair use" [1]. The landmark rulings — Sega v. Accolade (9th Cir., 1992) [2] and Sony v. Connectix (9th Cir., 2000) [3] — turned on exactly this: the intermediate copying done to discover an interface was fair use, and what shipped was the builder's own independent implementation. Building a compatible capability is not copying a work. (2) An honesty scaffold: a claim can't be stated as fact without evidence; an unmeasured thing is reported "not measured," never a fake pass; money, hiring, and publishing are human-gated. (3) A free-LLM survival chain, so the owned thing also runs at roughly $0 and never dies when one provider does.

First principle, one sentence: own the loop, not the output — because a tool you can't audit or own is a tool that owns you.

Lessons learned (the ones that transfer)

• Reverse-engineer the loop, not the code. The valuable, legal, durable target is the compounding loop a closed product withholds — not its source. Song of Songs beats a song generator not by generating better songs but by owning make → release → earn → learn.
• Honesty is structural, not aspirational. "Not measured" is a first-class answer. ByeGen's most valuable output was the cells it refused to score. Build the system so the dishonest path fails the build, rather than asking the model to be honest.
• Human-gate the irreversible. Money, hiring a contractor, publishing under your name — the agent recommends; a named human decides. renovate-anything will assemble a contractor request all day, but it will not send it without you.
• Free-first, and probe before you trust. The week renovate-anything's agent went live, the paid API key was dead on arrival and a second paid key had exhausted its credits — and the run shipped anyway, on a free model, because the fallback chain assumed exactly that. The expensive providers failed; the free one did the work.
• Ports + fake/real backends. Every external dependency sits behind a seam with a deterministic fake for offline tests and a real backend for production — and the real one raises rather than silently degrade to the fake. The silent fallback is the bug; a loud failure is the feature.
• Name your blind spots, then close them. The honest edge you document this week is the hole you fix next week — otherwise the documentation just makes you feel responsible while the hole stays open.

The surprise

We set out, more than once, to build a "killer" of a slick commercial tool. The single most valuable sentence any of these systems has ever produced was not a stunning render or a chart-topping hook. It was "I don't know — not measured." It turns out the hardest thing to reverse-engineer out of a polished AI product isn't the model. It's the confidence. The closed tools are never unsure, which is precisely why you can't trust them — and building one that will look you in the eye and say "I can't verify that yet" was, embarrassingly, the whole innovation.

What's next

• Climb the ladder on renovate-anything — from the single loop to the chained pipeline: a visual preview of your kitchen with different countertops, contractor quote-comparison, and photo-based quality-control gates during the job.
• Give ByeGen its missing numbers — the "not measured" cells become real the day the teardown runs on a provisioned GPU. Until then they stay honestly blank.
• Productize the pattern itself — "point me at a closed product, get back a spec for the open, owned alternative," as a repeatable move with the clean-room and honesty scaffolds built in.

Patterns / Anti-patterns

• Pattern: reverse-engineer the withheld loop; rebuild it open and owned.
• Pattern: honesty is structural — "not measured" beats a fake pass, and it's enforced by the build, not by good intentions.
• Pattern: free-first LLM chain, so the owned thing runs at ~$0 and survives any one provider dying.
• Anti-pattern: cloning the implementation (UI/code/weights) — legal risk, and you inherit the cage.
• Anti-pattern: a confident number with no evidence behind it — precision laundering a guess.
• Anti-pattern: the silent fallback — degrading to a fake backend without saying so.

Provenance — what's verified and what's mine

The EFF quotation was verified verbatim against its source at publication; the two court cases are cited by name and reporter. The Cost-vs-Value ROI figures are from the 2025 report. Song of Songs is my own public product (live studio linked). ByeGen and renovate-anything are my private systems, described at capability level only — ByeGen honestly as a teardown/evaluation, renovate-anything as a first working loop verified end-to-end this week. This essay is not legal advice, and all trademarks belong to their owners; no affiliation is implied.

References

1. Electronic Frontier Foundation. Coders' Rights Project Reverse Engineering FAQ — "What U.S. Copyright Law Doctrines Allow Reverse Engineering?" (quote verified verbatim 2026-08-04). eff.org/issues/coders/reverse-engineering-faq
2. Sega Enterprises Ltd. v. Accolade, Inc., 977 F.2d 1510 (9th Cir. 1992) — intermediate copying to discover interface specs for interoperability held fair use. en.wikipedia.org/wiki/Sega_v._Accolade
3. Sony Computer Entertainment, Inc. v. Connectix Corp., 203 F.3d 596 (9th Cir. 2000) — reverse-engineering a console to build an independent emulator held fair use. caselaw.findlaw.com
4. Zonda. 2025 Cost vs. Value Report — minor kitchen remodel recoup ≈ 96%→113% (2025) vs ~38% for a major kitchen remodel; the basis for citing an ROI range, not a point. zondahome.com/2025-cost-vs-value-report
5. Song of Songs — live studio. huggingface.co/spaces/wjlgatech/song-of-songs-studio

Field notes from building open, owned alternatives to closed AI products. Clean-room and spec-first throughout; the EFF quote was verified verbatim by fetch at publication (2026-08-04). — Paul Jialiang Wu · agentic-portfolio-lovat.vercel.app