Glossary Updates16 new terms added to the glossaries · November 12, 2026, 21:23 CET
AI TechDocKnowledge

Glossary · Automation software engineering and architecture

Hybrid codebase (human and AI authorship)

Also known as: Hybrid code authorship, Mixed-authorship codebase, AI-assisted codebase

German: hybride Codebasis

In software engineering, a hybrid codebase is a body of source code whose content originates partly from human authors and partly from AI assistants or agents, usually with no visible boundary between the two inside the resulting files. Its distinguishing problem is not quality as such but attribution: origin, review status and responsibility have to be recorded deliberately — in commit trailers, pull requests, review records or an internal register — because the code itself no longer shows them. Accountability remains with people: project policies such as the Linux kernel's AI coding assistants document state that AI agents must not add a Signed-off-by tag, that only humans can certify the Developer Certificate of Origin, and that the human submitter reviews everything the assistant produced.

  • Software engineering
  • Technical documentation

In one sentence

A hybrid codebase mixes human- and AI-written code in the same files, so origin, review status and responsibility must be recorded explicitly.

Example

After a migration sprint the team could no longer tell which of the 400 changed files contained assistant output, so they introduced an attribution trailer in every commit plus a mandatory second review for AI-assisted changes before the next release.

How it applies

  • What makes a codebase hybrid: Not the use of a tool, but the mixing inside the artifact. Assistant output is edited, human code is rewritten by an agent, and the result is committed as one change. After a few iterations, line-level origin is no longer reconstructable from the files — only from the records your process kept.
  • Record origin where the history lives: Commit trailers and pull request metadata are the cheapest durable place for provenance. The Linux kernel's process documentation asks contributions made with AI assistance to carry an Assisted-by trailer naming the assistant (and, in the documented format, optional analysis tools such as coccinelle or sparse); the exact field layout has been revised since the document was merged, so copy it from the current page rather than from a blog post. Whatever convention you choose, write it into your contribution guide and enforce it in the pull request template, not in tribal memory.
  • Keep certification human: The kernel policy is explicit that AI agents must not add Signed-off-by tags, because only a human can legally certify the Developer Certificate of Origin, and that the human submitter is responsible for reviewing all AI-generated code, for licensing compliance and for the contribution as a whole. Mirror that split in your own repositories: a machine may propose, a named person accepts.
  • Review load shifts, it does not disappear: Code review of assistant output is review of plausible-looking code without an author who can explain intent. Ask reviewers to check behavior against the requirement, not style; pair review with static code analysis, tests and code coverage so that the review is not the only filter.
  • Dependencies and licensing: Treat every package an assistant introduces as an unverified software dependency: confirm it exists, is the one you meant, and is approved. For copyright, the US Copyright Office's January 2025 report on copyrightability restates that protection requires human authorship and that purely AI-generated material is not protected, while a work containing AI-generated material can be protected in its human-authored parts — which makes a documented record of who wrote what a legal asset, not paperwork.
  • No general labeling law to lean on: As of 2026-10-07, the duty to mark AI-assisted source code comes from project contribution policies, customer contracts and internal rules, not from a general source-code labeling obligation. In regulated development (safety-related software, medical devices, machinery) the usual evidence requirements — specification, review, test, configuration management — apply unchanged; using an assistant that its vendor documents as compliant says nothing about the compliance of your deliverable.
  • Detection tools are research, not a control: Work on line-level authorship detection exists (for example a 2026 preprint presenting a benchmark dataset for the task, which describes industrial codebases as increasingly a hybrid of AI- and human-authored code), but accuracy claims from preprints are not an audit mechanism. Provenance that was recorded at commit time beats provenance guessed afterwards.
  • Technical debt: Volume grows faster than comprehension. Track technical debt items that originate from unreviewed or lightly reviewed assistant output separately, and budget refactoring for them; otherwise the first maintenance incident pays for the throughput gain.
  • Documentation side: The same mixing happens in manuals, API references and release notes. Decide per information type who signs off, and keep the sign-off visible in the source, not in a chat thread.
  • Measurement: AI usage telemetry tells you how much assistance was used; it does not tell you which lines shipped. Keep the two questions apart and answer the second one in your version control system.

Hybrid codebase vs. generated code

Automatic code generation produces code from a model or specification with a known generator and version: the output is regenerable, usually confined to marked files or protected regions, and its origin is documented by the generator configuration. A hybrid codebase is the opposite case — assistant output is probabilistic, not regenerable from any stored input, and interleaved with hand-written lines in the same function. Treating assistant output like generator output ("don't edit, regenerate") fails; treating it like hand-written code without recorded provenance loses the attribution you need for licensing, review evidence and incident analysis.

External references