Rust implements an LLM (AI) policy

[Isaac Eiland-Hall]

I thought it was an interesting take. Not sure we have to deal with the issue, but if we ever do:

https://blog.rust-lang.org/inside-rust/2026/08/05/rust-langrust-is-adopting-an-llm-policy/

Essentially, they allow LLM usage in regard to understanding the code, helping others with technical issues, everything except writing code. "If we wanted an LLM's opinion, we'd've asked ourselves" - the idea being that to suggest new features or write new code by using an LLM is not a Good Thing™, because humans need to plan for how the code should work and prepare for the future.

I think they came up with some good principles here.

Oh, and forgot to mention - one of the things they do praise LLMs for is helping translate between languages when international folks are talking. So kinda like I've started to use LLMs instead of Google Translate when I occasionally post in a language I don't speak (or step in to help translate). I think LLMs do a better job translating, as far as I can tell.

So it seems like a good policy: Use them for what they're good for, and don't use them for what they're not.

[prissi]

I would agree. Verbatim LLM code, at least for simutrans (but also for much simplier tasks) usually require several iteration or, even better, manual refinement for all but the simpliest problems.

Reviewing code  is a very thankless task, and, especially for a compiler, is extremely challenging as the output is quite interconnected and the whole compiler is likely too large for any LLM to be parsed as tokens in tis entirely. (W\The latter is true for Simutrans as well.)

I think the rust policy is well formulated.

[victor_18993]

I think this is a very interesting topic, especially because LLMs are already changing many industries and also the way we work in programming. In open source communities, their role is still not completely clear either.

My position is not against the use of LLMs. On the contrary, I think they can be very useful tools for understanding a project better, investigating problems, writing code, reviewing ideas, documenting things or translating. For me, the problem is not the tool itself, but how it is used.

An LLM can help a lot, but it does not replace the knowledge, judgement or responsibility of the person using it. If someone does not understand the problem they are trying to solve, cannot evaluate the code they receive, or simply copies and pastes an answer without understanding it, having access to a more powerful model does not solve that problem. It only allows them to produce results faster without necessarily understanding what they are doing.

That is why I think the person still has to be responsible for defining the problem properly, questioning what the model returns, recognising when something does not make sense, testing the changes and understanding how they fit into the project. The LLM can become another actor in the workflow and take on tasks that might previously have been done by another person, but final responsibility for the result should not disappear.

I also think there is another risk that is discussed less often. The more we automate the execution of our work, the more important it becomes to preserve spaces where the person still has to think, question things and make decisions. If we use automation to remove that part as well, we can end up becoming mentally more passive and too dependent on the tool.

So for me, the discussion should not simply be reduced to "LLMs yes" or "LLMs no". The more interesting question is how they are integrated, which tasks are delegated to them, and how much understanding and responsibility is still kept by the person using them.

I think LLMs can contribute a great deal to open source when they are used well. The problem starts when they are used as a substitute for judgement and knowledge, rather than as a tool to extend them.

[Yona-TYT]

Oh, and forgot to mention - one of the things they do praise LLMs for is helping translate between languages when international folks are talking. So kinda like I've started to use LLMs instead of Google Translate when I occasionally post in a language I don't speak (or step in to help translate). I think LLMs do a better job translating, as far as I can tell.

Perhaps this could be implemented in online games; many games currently use text translators in their chat interfaces. It would be interesting to have this in Simutrans, and combined with the new chat window, it would be a dream come true. 

[isidoro]

My view somewhat differs for yours, but somewhat not.

Yesterday (literally, because LLMs are quite recent) we had:
  problem -> (human) -> solution

Now we have:
 problem -> (AI, optional) -> (human) -> solution

A lot of people I talk to refer that the part (human) is nowadays very important to check the AI solution, and that the AI helps a lot in productivity if rightly used.  In that I agree with you.  Other people say that they were gardeners and now they can program... ?!!??!

But I'm amazed the way this is evolving and I foresee that in the near future the (human) part will dilute more and more and, eventually, will disappear (translated: not economically feasible).  For me, it's only a question of scale.  The more neurons to the AI model the more it can get or offer.

I cannot clearly separate the answers from AI models and the answers from a human being apart.  It "understands" me and reacts exactly to my requirements, just the way (well in fact usually better) a human being would.

You may say: "AI LLMs are only word mixers".  There's no intelligence there whatsoever.

But what if we, the humans, are only big, big word mixers based on Carbon.  What would be the difference?  How can we be sure that we are not?

And here we reach to more philosophical questions...  Are AIs beings, subjects of rights?  When I shut off an AI, am I killing it?  Those questions seem absurd, but weren't not as absurd questions as slaves being human beings and subjects of rights not so far away in time (some centuries)?  And I don't think that anyone can think that nowadays.  Isn't there some "machinism" in your answers?

[makie]

Yesterday (literally, because LLMs are quite recent) we had:
  problem -> (human) -> solution

Now we have:
 problem -> (AI, optional) -> (human) -> solution

But I'm amazed the way this is evolving and I foresee that in the near future the (human) part will dilute more and more and, eventually, will disappear (translated: not economically feasible). 

The bigger problem. These days, you often only get answers from AI. So, if you have an unusual problem that the AI isn't prepared for, you'll just get nonsense in response. It is no longer possible to get through to a human being with a brain.

That was my experience with PayPal. Fortunately, the error worked out in my favor. PayPal had automatically—and wrongfully—clawed back the money from the parcel service. Thank goodness the packages arrived anyway; the parcel carrier's automated systems were presumably not set up to handle an error on PayPal's part.

[prissi]

The AI part strongly hides that considerable intelligence sits in front. AI without a prompt will not do anything. Showing an image to an AI will at best invoke a random action (if instructed to act automatically), but chances are low to invoke the right one.

AI is very good at pattern recognition. That is only half of programming, decide if there is already a good solution. But AI will not come up with a new quantum-safe encryption algorithm derived from some obscure mathematical theorem. At least not the current LLMs.

AI is also not so good at efficient data Organisation. It cannot really guess that for certain value 16 bit may be enough without knowledge that costs of goods per tile will not exceed this value for a meaningful game balance.

It would be nice if LLMs could relieve some of bugfixing and routine algorithms already.

On the other hand, IT because less and less sustainable. We start a Webbrowser that Downloads a huge framework to emulate gui elements and a Visual Basic interpreter to word a text file. Word processors with a memeory and processing footprint of a 1990ies supercomputer and capabilities close to their 1990ies counterparts. LLMs supercharge this antisustaibability.