The Linux kernel is regarded as one of the most strictly organised software projects in the world: every patch, i.e. every single code change, goes through a public review by so-called maintainers, who are responsible for individual sub-areas. It is therefore all the more closely watched how this project deals with AI-assisted programming.

At present, a decision is emerging there that is surprising at first glance: the labelling for contributions created with the help of AI tools is to be dropped again. The tag intended for this purpose, Assisted-by – a line in the commit description that documents the use of an aid – is, according to the maintainers' assessment, simply set too rarely.

A label that hardly anyone uses

The argument is pragmatic. A marker that only a small proportion of submitters use does not create a reliable picture. On the contrary: it can be misleading. Anyone who sets the tag appears to be a special case, even though the use of assistance tools is likely to have long been widespread. Anyone who omits it goes unnoticed. A data situation from which conclusions could be drawn about the quality or origin of code does not arise in this way.

Added to this is a problem of demarcation that intensifies with every generation of tools. Where does AI assistance begin? With the fully generated function? With autocompletion in the editor? With the search for a suitable kernel API in a chat window? The more deeply language models move into everyday development environments, the harder it becomes to draw a dividing line that could be mapped cleanly in a single metadata line.

Torvalds also works with language models

The fact that even Linus Torvalds, the initiator and to this day central person responsible for the kernel, now works with large language models (LLMs) underlines this development. The use of such tools is no longer a marginal phenomenon in professional development teams, nor is it an indicator of a lack of experience.

As a result, the question "Was AI used here?" loses its sharpness. More interesting is the question that is in any case the focus in projects such as the kernel: Is the change correct, understandable, maintainable – and is there someone with a name who stands behind it?

Responsibility remains with people

This is precisely the decisive point for practice. The kernel process has long known signature lines with which developers and maintainers take responsibility for a change. This responsibility does not shift just because a model helped with the formulation. Anyone who submits a patch is professionally liable for the result – regardless of which tool was at the beginning.

For companies, a sober attitude can be derived from this: it is not the origin of a line of code that decides its quality, but the procedure it has to pass through. A review that reliably checks AI-generated code also reliably checks hand-written code. A review that only looks at plausibility will let errors through in both cases – with AI code, however, with a higher probability, because generated sections often appear linguistically clean and therefore arouse less suspicion.

What makes sense in projects now

Some derivations for one's own organisation can be drawn from the kernel example, without adopting its decision one-to-one:

  • Review depth instead of origin label: Check whether your code reviews actually cover logic, edge cases and security aspects – or primarily formalities.
  • Expand automated safeguards: Tests, static analysis and dependency checks have an effect regardless of who or what wrote the code.
  • Clarify responsibilities: Define who is professionally responsible for a change and who approves it. This role cannot be delegated to a tool.
  • Treat licensing and legal questions separately: Questions about copyright and licence compliance cannot be solved via a voluntary label, but via binding rules in the development process.
  • Labelling only where it has consequences: A marker that nobody evaluates and nobody demands creates effort without benefit.

Labelling is not an end in itself

The debate in the kernel environment shows that well-intentioned transparency rules can fail if they are voluntary and the labelled state becomes the normal case. That is not a fundamental argument against documenting the use of AI – but it is an argument for coupling it to concrete purposes: to audits, to regulatory requirements, to traceability in safety-critical areas. Where such a purpose is lacking, what remains above all is additional process ballast.

For web and software projects, this means: proof of quality continues to shift away from the question of the tool and towards robust testing processes. Anyone who invests today in tests, review culture and clear responsibilities is better protected against the next generation of tools than with any labelling requirement. And in tenders or acceptance procedures, it is worth asking not about the AI share, but about how a change was checked and who is responsible for it.

Sources