A couple of months ago I started using AI for various research tasks related to what my actually established domain expertise is, which is automotive aftermarket engine management. While I do math and spreadsheets and correlate relationships to things, I’m not a programmer. I made games in Basic and QBasic 1.1 when I was young, and made a couple webpages when HTML was new, and can install Linux and use command line only systems, but those things a long time ago do not make me a competent and useful programmer. (without AI as adaptive tooling and proper instructions metered out in planned steps)
Against a typical search engine, I realized that I enjoyed how various AI systems found information and correlated relationships, and began centering conversations around specific technical documents, like processor ISA manuals. I then began to ask about how to get the same information into other formats, for AI project folder ingestion, and began to develop a system of files to ground the project to my specific processor family and assembly language.
essentially, I wanted to be able to reduce errors and focus the LLM into the subject matter, so that I could effectively build my own dissassembler/decompiler and other machinations. AI can code python, all I need to do is test it as the human in the loop and sometimes change wording or notes in the programs, small things. Dictate the goal in metered steps and test, test, test.
At first, I didn’t know any terms for anything, I was totally just learning it as I was doing it and asking the various AI systems for perspectives. Of course I encountered assembly coding related hallucination at first. I didn’t know what that term meant at first, I just knew it would sometimes fill in the blank with a bad .word or two. (that’s a pun) My favorite was B3 3F F4 CE. Of course I’m not naïve enough to happen-stance “the brickening” upon myself and “vibe code” my way to an unusable (difficult to recover) ECU, carefully review EVERYTHING. Eventually I settled on a system, and then I thought “If I want to make another one of these for something else, I should probably just build python files to automate the process”. Through the process of refining the toolkit maker, I refined the assembly toolkit, until both were done. Several speed runs of making the assembly kit happened. Then I started work on the disassembler.
That was four weeks ago that I started building the software steps to make python files for the Domain Expert toolkit creator, with ChatGPT/Claude/Grok. I would need to replace the process I was using AI for, to turn PDF/text into chunked ML files. (uses Pydif2 with special filtering options) One week ago I basically finished the system to full version 1. With the recent update for Gemini, I found that it’s really good at analyzing the code and it’s functions, offering pen-testing sorts of help.
As I was nearing the end of developing the full toolkit maker, my conversations with the various AIs started to include words I was unfamiliar with and attributing terms I didn’t know to my setup. As time went on, I eventually began to have an idea of what I have created, but only a little bit and only in it’s own context. WIthout knowing what others do, or what is standard, old, new, or whatever - how could I know what I’ve done if I don’t know what it isn’t? A few months ago I didn’t know what hallucination was, and a couple weeks ago I didn’t know what RAG was or what REG is, or anything. I just thought in incremental steps “I should get it to this point” and then asked the various AIs about how I could get the files I was becoming familiar with to do the things I wanted to do, and wound up making this systematic process. Sometimes it made top recommendations to things that would have complicated the whole process. If I would have followed the recommendations it made, it would probably be grounded RAG with vectors from .parquet and DuckDB was suggested alot? But it isn’t.
Essentially, I went from wanting to make AI do a specific complex thing well, to creating a toolkit that makes “Domain Experts” out of the AI you’re using, in 20 to 25 files (your $20 subscription here or there) in the file size limits those subscriptions impose, in order to get more tooling effect out of it. This is how a non-programmer used AI to build a command line only, single language disassembler in python that is under 200KB in 6 days (from when the assembly toolkit was finished in it’s final form), already competes with Radare2 in features, and is planned to add GUI/emulation/recompiling eventually. A better coder who also can actually program on their own, would have done it faster utilizing the same kit though. The python disassembler does a full disassembly in one minute with one core/thread on an N5000 laptop with 8GB RAM+SSD, from a 1MB ROM. an extra 4 minutes for the xref/graphs. Command line only, but I wanted the outputs to compete with Ghidra and IDA Pro, and especially without the bloat.
The setup (in the domain expert toolkits) I’ve come to use is what I call GREG. Grounded REG (with functional RAG and fidelity enforcement). It’s entirely REG, but through careful orchestration of files, it mimicks RAG’s retrieval and generation without normal vectors through symbolic mechanisms, and does so without having to state anywhere in any files to let the AI system know it’s a feature. It figures it out. I did this through only a few file types. Nothing new in the filetypes themselves or how they are named, just layered and purposed in a way that is purportedly new/different.
Giving Claude the files, it calls it just RAG (question Claude about REG vs RAG, and if it doesn’t search outside it doesn’t really know what REG is). Give ChatGPT the files, and it calls it REG with Grounded RAG, and Grok calls it Grounded REG with functional RAG. The only thing they all agree on uniformly is it’s grounded nature and well guardrail-ed generative nature, with symbolic vectoring, rules, requiring citations, semantic layers, modes, and anti-hallucinatory measures. “The best of REG, with the benefits of RAG, and without the potential downsides of RAG.” I had no idea that’s what I was doing, but that’s the sort of statement AI gives me about the projects and their structure. If I make the kit only part way and don’t add the symbolic semantic layering, it always comes back as “Pure grounded REG, just shy of RAG implementation”. Or, Sonnet 4.5 without using external sources says it’s a couple hundred lines of code and an extra generated file, just shy of RAG.
Anyways, in questioning the various AIs, they all agreed this was the place to look up the various styles of REG/RAG varieties as of current. I wanted to be able to really understand what it is that I’m doing and just how different it is from what others are doing. I will probably mostly be reading and cruising the forums until I find out if this “Domain Expert LLM Toolkit” has enough novelty (GREG is a byproduct of the toolkit’s specific novelties not mentioned) to actually patent the system. It’s a ten to twelve step process involving human in the loop over python files (without AI), and once you know what you’re doing, can speed run making hyper focused toolkits around specific technical domains (law/medical/electronic) to under an hour. A few hundred pages to several thousand pages of documents, processed offline fairly quickly, and assembled into machine language files to be structured just right for the intended purpose. Then you test your schemas and semantic glue, reinforce or modify your guardrails, dos and don’ts, and adjust how citations are needed until the kit performs the way you intended. Or, learn that you didn’t structure things the way you should to get the effect you want, and retry.
It also allows for recursive learning. Whatever toolkit is created from the “Domain Expert LLM Toolkit”, should ideally be designed to have output that is in the form of ML files, so that it can be reprocessed into the toolkit that was used to make it, to form an augmented toolkit. Oh, you want more semantic glue or extra REG artifacts? That’s just a matter of application of the data.
Unfortunately, while I want to talk about GREG (with functional RAG), the way it’s implemented is specifically unique from what I can find anyone else has done in particular. (so far) I’m going to wait to see if it actually has the novelty that the chatboxes have suggested it has. If it does, I’m going to either license it’s use (it’s intrinsic to the kit, I would patenting the kit) or sell the patent. If it doesn’t pass Alice, then I’m going to share my system with the community.
Anyways, I just wanted to get AI to assist me with assembly language and went from having it look through PDFs to making me python programs that would semi-automate making domain specific toolkits with specific technical subject expertise.
That is how I stumbled into LLMs and anything machine learning at all. I started wanting to get it to assist me with low level adjustments for my car’s ROM, and to better understand assembly. “How many CAN mailboxes are being used in this ROM” or “What scheduler is the upstream heater control on” - cites documentation from the group files, shows a code stub, and explains it.
Attached is a picture of graphs made from xrefs, of functions from disassembly (my proof of work) It’s a sub 50MB .html file. The .CSV output has 26 fields, and it’s just over 60MB. The disassembler is still WIP. (table data is listed as .word, c.code is basic, functions aren’t named, still plenty of polishing to go)
