The moral of my personal story in this context is probably somewhere near the intersection of "not all cancers are the same", "you can always find an anecdote which suggests something", and "luck is a factor in life".

If I were to go through it again I'd still probably get a second opinion and go to a better place even if it was a straightforward type though because why not if it's covered the same in the end.

That's completely orthogonal to whether you can still find tasks which require more accuracy or not (except for the sole case someone claims it's 100%).

Maybe the next time I spend some tokens on it I'll ask for it to convert the implementation to a "proper" runtime rip where the user can provide the source ROM and it extracts those assets live.

Last weekend I had it decompile the "Kitten Cannon" Flash game and then ran (what I believe was) an exhaustive check of the 36 trillion reachable launch+power+rng combinations to see what the longest run was (I got a little over 11k feet, successfully replayed in the Flash version).

It's so cool to see modifications/enhancements to nostalgic things appear for next to no effort as much as I want rather than be limited by the time I have for it.

I've been at a company that went through Chapter 11 and still work with (at the new place) a few folks hired during that time.

The thing to note here isn't supposed to be that 1.5 TB/s is record breaking/astounding though, even the consumer 5090 GPU has higher bandwidth than that, it's just capacity@bandwidth is what defines the usefulness of an AI accelerator and this is good on both sides instead of just one. I.e. there are a lot of "cheap" low-capacity@high-bandwidth devices and a lot of "cheap" high-capacity@low-bandwidth devices. What makes this accelerator interesting is not that it has 480 GB of LPDDR5X, it's that it has 480 GB of LPDDR5X at a speed worth having that much for, which has normally been the realm of the likes of Nvidia/AMD and their AI/DC options.

There's also the matter of "90% compared to what". If it was 90% per attempt compared to a calculator then I'd just use a calculator. If it was 90% per attempt for something I have a 10% chance of getting right per attempt then it's not really so bad. OTOH if it's 90% per attempt at keeping my car in the lane then it's obviously quite bad. I.e. there isn't one "reliable percentage" to target which is why I'm comparing the curve instead of just the most stringent things I can think of in isolation.

But the way you find out which kind of scenario is by getting the loss and savings data and comparing it, not wondering what could be true and declaring it be the saddest one.

Newer APIs are also more flexible, making fewer assumptions about how things in the pipeline should run. E.g. the way a buffer clamps or overflows compared to the PS2 may be hardcoded in OpenGL 2.1 meaning you have to write emulation of that feature inside the older API to then run the code to emulate the buffer. In OpenGL the shaders types are limited in this manner, in WebGPU you can just use arbitrary compute shaders instead of having any assumptions at all about the rendering pipeline.

There are tradeoffs to selecting the older APIs just as there are tradeoffs selecting the newer APIs. Generally, the latter is easier on the implementation side for emulators.

That doesn't necessarily stop you from pointing an LLM at it and getting a working WebGL 1 version of course, it's just not a universal answer to "how should someone spend their tokens.

I.e. it's precisely when you look at these chained that the difference is actually very large. It's really only the 1st turn or two of prompts where the difference seems negligable.