Large Lamentation Model

I think I'm finally done with my main contract of the year (at least, I really hope I am) and am starting to get back to my emulation projects! I've done a little bit of work on my PlayStation emulator this week, and as with any emulator for a system that's already well-emulated, there's a lot of repetitive labor concerning already-well-researched/documented components. I have my reasons for re-inventing the wheel and not necessarily going out of my way to make the wheel better than any other wheel that's come before it. Personal satisfaction derived from the work itself and the imprints the work leaves on my brain (to later help with proper reverse engineering) are not small parts of the equation, and I don't concern myself with the petty ego-driven fears of my work being irrelevant/obsolete at any point in its existence. (we will all, along with all we hold dear, one day descend into oblivion) Nonetheless, some of that repetitive labor led me to wonder if "AI" was good enough to start incorporating into my own work in careful and ethically-considered ways; after a little bit of investigation, I determined that it absolutely is not. In surveying the landscape of frontier agentic capability this week, though, I have thoughts. I figured I might as well share them here!

Most of the holdouts in my sphere seem to finally be giving in to LLM's lately, programmers and businesses alike. In my most recent experience, even the frontier models are still shit at producing work to my standards. Agentic workflows are just a band-aid for hard LLM limitations in both context and output: even if you have the physical resources to bloat the LLM's context, every model to date starts spewing utter bullshit when trying to shove something like even a relatively small codebase into its context window. The "solution" for that is to establish an iterative approach (while leveraging various forms of RAG), but that invariably results in unnecessary bloating and other undesirable properties in the final output even if some sense of "efficiency" is part of the completion metric. So I'm not incorporating LLM's into my workflow at all for my personal work, because even outside of the ethical considerations, the results are just never good enough.

Agentic LLM capabilities are now at the point where unskilled people can use agents to do work they have no business doing (those people might even be so unskilled that they have no idea how bad the end result is, leading them to think AI has truly arrived), and skilled people can use agents to do a worse version of the work they could've done themselves. (but possibly faster) The latter usually means just as much (if not collectively more, after the cost of babysitting agents) labor time if the goal is to polish the work to the previous standards of the skilled human laborer. This means that when prioritizing time, the work getting done is often objectively worse across the board. I think I've generally been escaping the consequences of all of this by being faster while yielding higher work quality than most of my peers in my current domains, but I'm expecting the day to come soon that a client starts bitching at me over a time/cost estimate because someone can do it faster via LLM and the client doesn't care about any of the trade-offs.

This is a pretty depressing point to be at. I think there will come a day when AI, having correctly overcome the inherent limitations of today's models which companies are using stupid band-aids to try to work around, will easily surpass my coding abilities. I hope that when that day comes, it will also be possible to ethically source training data, truly and wholly eliminating any reason to do the work I'm currently doing by hand. I kind of doubt that ethically sourcing data will ever be a concern for this dumpster fire of a society, but it'll be nice if that's an option for the tiny minority of people who still care. In any case, I'd much rather be at that point and have my skills rendered worthless for the purposes of any of my "output" which could conceivably be sought after by society. Again, oblivion will not be denied. This point in time, by contrast, has trapped us in a "worst of both worlds" situation: many sources of demand have begun to discourage us from doing our own best work for a "good enough" version. Predictable labor dynamics, especially under any any form of capitalism. I can see why some people would be depressed by thinking their skills are now worthless, but I'm not one of those people. The part that's depressing to me is the gratuity of it all, having to continue operating in a society which forsakes the entire experience of life and all more desirable illusions of meaning/worth so that it may more efficiently serve a few disgusting masters.

For those who didn't do very good work to begin with (which isn't necessarily to fault them, there are many reasons a person may not be afforded the opportunity or ability to wholly refine a skill), or who didn't work in areas where those fine measures of quality were especially visible, this point in time and that hypothetical future point in time I just referred to are pretty indistinguishable. To those people, "hand coding" is already a practice of the luddite. Those people certainly aren't aware that by telling us that we don't need to code by hand anymore, they're really just telling us they were never very good at what they do. The same is true for those who are preaching in the present day about how much better the best can be by leveraging agentic coding capabilities. The best case at the moment is that the best programmer in a given domain will be able to get something done a little bit faster without sacrificing any metric of quality, but the reality is that it's highly subject to the task at hand. The result is likely to be inferior in some regard without extreme diligence, and the time invested can easily dip into the net negative when leveraging any given LLM (e.g. it can take more time to coax a good function out of an LLM than to write the function) for any given task.

Indeed, I do routinely use today's LLM's for throwaway work or menial local tasks. I know better than to use them for anything that matters within my own domain of expertise, and I know better than to use them to produce any form of work product in a domain where I lack expertise.

This goes hand in hand with the flood of agentic slop taking reverse engineering (especially decompilation) communities/projects by storm lately. It's easier than ever to peek into a binary and think you know what's going on. It's not necessarily easier to be right about it, but being right about how a sea of binary translates back into source code is equal parts technical correctness and human intuition. It should be the kind of thing AI is exceptionally good at, except that today's LLM's are better at hallucinating bullshit than at anything else; asking a model to construct the entire narrative of what a disassembled function represents, without giving it any ground truth outside of its pitifully limited context, is going to deliver you a whole pile of insane bullshit. I can see how this would be utterly maddening to those with actual skill when clueless people apply it to any form of reverse engineering. The bottom line at the moment is that if you weren't reverse engineering binary before LLM's, you're more than welcome to do it with LLM's in the privacy of your own home, but no one should be inflicting that shit on the world.

As I mentioned, there will come a time when AI is genuinely better than humans at programming, reverse engineering, and probably most/all forms of cognitive workload. That's going to send a lot of talented people into emotional spirals, largely stemming from the ego complexes our society has coaxed them into in order to extract the fruits of their labor. That's a little bit ironic, and makes me glad I invested so much emotional energy into holding a pillow over my ego's face over the last decade or two. Many of those people will be shouting against the tides of progress, and many of them already are. But don't confuse the two causes: there are plenty of non-ego-based reasons to fight against today's tide of LLM's. Those reasons include ethical considerations (especially as it concerns how training data has been sourced for every competitive model to date) as well as practical considerations. At the moment, both factors can be summed up easily as the reason I'm continuing to avoid LLM's in my own work: they're shit (in my domain), and the people pushing them the hardest are shit. (in every domain)