On 5/6/26 03:44, Nguyễn Gia Phong via Development of GNU Guix and the
GNU System distribution. wrote:
I meant it does not really assist with determining the latest/desired
version to update to, autocompleting the checksum, pointing to
the patches' URLs, or rebasing them for the version to be packaged.
There can be tools wrapping around LLM but at it's more effective
to write one that behave semantically instead.
Yes, you'd need an Agent to do those things. But that is somewhat
implied; people using LLM's for coding mostly do that through an agent.
But those agents are really good in "determining the latest/desired
version, autocompleting the checksum, pointing to patches" etc. They
can even write the patches. I invite you to try them out.
They can call `guix refresh` (after reading its documentation), call
`guix build`, inspect the logs, determine 'root cause' of the error, add
a missing dependency, write a patch, rebuild, etc. Within a minute;
limited primarily by build time.
There are still many packages failing to build due to earlier incomplete
migrations (e.g. to a newer gcc, newer Python, etc). It doesn't have to
be this way, technically we can easily automate that.
I envision just telling an agent to "Upgrade Python to 3.13 and
refresh/fix any dependent package that fails to build". Then come back
the next morning, tick of the 90% of the packages that went well, fix up
9% that worked but had stylistic problems (e.g. replacing a patch with a
`-Wno..` compiler flag, fixing a commit message), and then spend human
intellect on the 1% that require it (still a lot of work by the way).
And after that, improve the agent to do even better next time.
I have not done such a large scale experiment yet, because if
successful, I would have a working Python 3.13 (or whatever) that I
(currently) would not dare to share back with the community. Maybe I
should try it on a language ecosystem that I do not care much about.
Hugo
Disclaimer:
I emphasize that I think it is paramount to 'own' the code. The
contributor should have read and understood everything they plan to
contribute. That bar is probably even higher than for code you wrote
yourself.
(As in, I can see myself submitting "I took this patch from NIX but I
don't fully understand it", but I would not submit "I vibe coded this
patch but don't fully understand it", even if the patch would be
identical.)
And I strongly believe that any communication towards humans should be
done by humans. Any back and forth with the reviewer should be done by
a human. (I think this is clear, it would disgust me to do otherwise; I
just don't want to be misunderstood.)
