Chances are much higher than a model can figure out what the patterns are, decipher them, and retain that knowledge in a meaningful way it can reason about. Me and you might take years or months to do all of that on our own, with a "map" of the weight we might be able to discuss it, but not as effortlessly as an LLM.

Honestly, I had told a few different colleagues that reading a model is probably not that exclusive to frontier models. It's probably yet another reason OpenAI / Anthropic don't release any big open weight models, but thankfully Google and Microsoft release reasonably sized models. Imagine a new GPT open weight release, it would get dissected drastically.

Isn't that what this whole technology paradigm is about? How is it surprising?

Granted, it is cool. But I see so much of "look at this cool thing I did with LLMs" and honestly... we need more structured text, more explicit documentation, more ergonomic and intuitive CRUD applications.

The amount of "look at cool things" is growing way faster than before and they are all sort of low effort now because the "agentic" LLM-VM looping apparatus can do a lot of heavy lifting and run with our prompts.

And I mean, if one has jargon, knowledge, and intention, they can also leverage that into great structured text, ergonomic and intuitive CRUD apps etc, all of which add great value to our mundane pursuits of applied research, software products and services and so on.

Honestly, I begin to think the problem is people dazzling themselves instead of doing the housekeeping that is the bulk of life. Technology choice is entirely secondary.

In TFA case, given that they were able to guess what the weights did (which the researchers knew in advance and could cross-check) and to even tweak and improve them, the answer is yes.

Why do this without testing? Why would you assume that?

Qwen3.8-Flash_Next should be in the running for that title as well. It's astonishingly good. I use both of them. If I need more memory on the machine for other things I run 27B, If I can get by with much less RAM I run QFN (takes about 102GB on my Strix Halo box with 262,144 context). QFN runs quite a bit faster on my hardware - about 50t/s. 27B with MTP starts out around 22t/s but degrades over time as the context fills up. Both are great models, but I'd give QFN a bit of an edge (at least for the coding projects I've worked on). But both feel on par with Claude Opus 4.6 - 4.8.

How do you validate and verify that outcome?

Or does Qwen-3.8-27B do the validation and verification for you as well? If so, how do you ensure that's correct?

The only reason Qwen is more popular is because it can run decently fast on MLX, while Gemma needs a discrete GPU with 24gb of ram to run at usable speeds.

Also, theoretically speaking, any small model can be as good as a big model if all they have to do is summarize text. Back before agents were a thing, we had prototype coders running of local inference models from Mistral for ai dev. The workflow was to generate llm summaries of the codebase, and a summary of changes to be made. Then we would grab search results from the web, feed it to an llm to summarize, and then finally combine all of that context into a final inference run which would generate code, then the codebase would be run automatically, any errors would be llm analyzed, and an llm would generate the next change to be made in the above cycle.

Nowdays, we can do that with pi coding agent and Gemma4:31b. But we still have plenty of custom harnesses for things.

What frontier models are you using? I'm literally sitting with Qwen 3.8 27B locally and trying my damnest to get it to work at least 80% of the quality Astra et al have, and can't get close to it. It keeps being so verbose, regardless of inference parameters, system prompts, reasoning effort, and keeps going on tangents. I'm running the BF16 weights via vLLM, can't imagine how much worse the experience must be with the quantized weights people run with the average consumer GPU.

Even with tight guiding, as I guess you could say I do more "AI pair-programming" than vibecoding, it just loses the plot to often and waste time, enough that it's clearly not an alternative to today's frontier models.

The future is going to be wild.

I think your use case of incorporating novel data probably calls for training, but I'm sure there are use cases where you can tweak the weights to get what you want (say I wanted to tweak the model to be less sycophantic, or found a way to shrink it by removing weights associated with a language that I don't ever use)

You can optimize a model by randomly changing its weights and validating results on your task. A monkey can type a book given enough attempts.

My first reaction to your question (rhetorical?) was uncharitable... so, I am curious what you meant that it was "easy."

  > the 2x2 pixel grid that the input pixel should be replaced for a (width2)x(height2) upscale.

I called it a paper here because it's by people with an academic affiliation and is of comparable quality (if not better than) many of the other "papers" we see.

I also like it when a paper isn't a PDF. PDFs are a bad way of communicating information.

(I will note that the authors themselves didn't call it a paper, their own BibTeX reference calls it a "blog post":)

  @misc{takehi2026weightspace,
    title        = {{Sparks of Weight-Space Programming: LLMs can natively read \& write neural network weights}},
    author       = {Takehi, Rikiya and Teoh, Jayden and Zhang, Alex and Khattab, Omar},
    year         = {2026},
    month        = nov,
    howpublished = {\url{https://rikiyat.github.io/blog/weight-space-programming/}},
    note         = {Blog post}
  }