Zylos LogoZylos
2026-10-03

Renaming Without Drift: A Field Guide to Terminology Migrations in Specs and Code

ai-agentsdocumentationsoftware-engineeringrefactoringdeveloper-toolsterminology

Executive Summary

A terminology rename looks like the safest change you can make. Nothing in the behavior of the system changes; you are only replacing one word with another, everywhere it appears. That appearance of safety is exactly what makes renames dangerous. A word in a design spec or a codebase is rarely a single, unambiguous token — it is a position in a network of meaning, shared across prose, code identifiers, database schemas, CLI flags, and diagrams, and the same spelling is frequently reused for more than one concept. Treating a rename as mechanical text substitution, rather than as a change to the domain model itself, is how a "pure rename" commit quietly changes what a sentence means, collides a new name with an existing one, or leaves old terminology stranded in exactly the document most readers see first.

This piece works through why renames are semantic changes rather than mechanical ones (via Domain-Driven Design's idea of a ubiquitous language and bounded contexts), how several large, well-documented engineering efforts have actually handled terminology migrations at scale, the compatibility mechanics that make a rename safe to roll out gradually, the tooling available for both code-level and prose-level renaming, a concrete review discipline for rename diffs, and what changes when the renaming is being done — or reviewed — by an AI agent. It closes with a practical checklist.

The failure modes

Consider a recent case from our own design work, generalized here: an AI-agent system's design specs used a term — call it the "channel key" — as the central identifier for a logical grouping of related work. The team decided the name was misleading and renamed the concept to "session group" across roughly six long-lived specification documents, including the identifiers, schema names, and CLI flags those specs define. The rename was deliberately isolated into its own commit, separate from any semantic edits, specifically so it could be reviewed on its own. An independent review of that pure-rename commit still surfaced three distinct problems, each instructive in its own way:

1. The mis-rename from polysemy. The old word, "channel," turned out to have two unrelated meanings in the same document set: it was both the name of the concept being renamed and, separately, the name of an unrelated system component (a communication channel). A mechanical find-and-replace that matched the string "channel" without regard to which sense was intended rewrote a sentence that was actually about the component, not the concept — silently changing that sentence's meaning while leaving it grammatically fluent and easy to skim past. This is the textbook risk of homonyms: the same token, two referents, and a substitution tool that cannot tell them apart because it operates on text, not meaning.

2. The collision with an existing symbol. The new name introduced a short variable or field letter that happened to already be in use elsewhere in the document for a different quantity. The rename didn't just introduce a new term; it introduced a new symbol, and nobody checked that symbol against the existing namespace before adopting it. This is a problem a naming change shares with picking any new identifier: the search space you need to check is "everything already in scope," not just "everywhere the old name appeared."

3. The residue in the overview. After the rename propagated through the detailed specs, a top-level overview document — the one most readers would open first — still contained the old term. Partial propagation is an almost universal property of manual or semi-manual renames across multiple documents: the detailed, frequently-edited files get caught, and the summary document that's "basically stable" and rarely opened for editing is exactly the one that gets missed.

Beyond these three, the same class of system tends to produce a few other recurring mismatches worth naming explicitly:

  • Code identifier vs. prose term drift. The prose settles on "session group," but the code cannot simply use sessionGroup as the variable name, because sessionGroup (or an equivalent camelCase form) was already claimed elsewhere in the code for the fully-qualified identifier of that same entity (e.g., a composite id string). The result is a deliberate, documented mismatch — code says groupName, prose says "session group" — which is a legitimate outcome of a rename, but only if someone decided it on purpose and wrote it down, rather than it emerging as an accident that confuses the next reader.
  • Schema- and interface-level names. Database columns and indexes, environment variables, CLI flags, and public API field names all encode the old term too, and each has a different blast radius and a different safe-migration mechanic (covered below) — a prose rename and a column rename are not the same operation even though they start from the same decision.
  • Stale derived artifacts. Diagrams, generated reference tables, and other artifacts derived from the source material don't update themselves: a generated table stays stale until it is regenerated from the renamed input, and a separately maintained diagram keeps its old labels until someone edits or re-draws it.

Why a rename is a semantic change, not a mechanical one

The underlying reason all of the above happens is that a name is not decoration on top of a concept — in a well-run project, the name is the interface to the concept, and changing it changes the interface. This is the core insight behind Eric Evans' idea of a ubiquitous language in Domain-Driven Design. In Martin Fowler's summary, it is "a common, rigorous language between developers and users" that "should be based on the Domain Model used in the software - hence the need for it to be rigorous, since software doesn't cope well with ambiguity" [1]. Fowler adds that Evans treats using the language in conversations with domain experts as "an important part of testing it," and the Evans passage quoted on the same page frames the vocabulary as something to be actively maintained: "Domain experts should object to terms or structures that are awkward or inadequate to convey domain understanding; developers should watch for ambiguity or inconsistency that will trip up design" [1]. A glossary, under this view, isn't documentation written about the system after the fact; it is closer to the source of truth the system's vocabulary is supposed to conform to, and a rename is an edit to that source of truth, which then has to be propagated — correctly — to every place that currently reflects the old version of it.

DDD's companion idea, the bounded context, explains why the same word can legitimately mean two different things in two different parts of a system without that being a bug: each bounded context has its own model and its own local ubiquitous language, and a term's meaning is only guaranteed to be consistent within a context, not across all of them. That is precisely the shape of failure mode #1 above — "channel" as a component name and "channel" as the renamed concept were, in effect, two different local meanings sharing one spelling, and a pure find-and-replace has no notion of context boundaries at all. It treats the whole document set as one giant string, when the people who wrote it were implicitly treating it as several.

This is also why residue and collisions are not edge cases but the default outcome of naive renaming. A text substitution tool matches spelling; a vocabulary consists of references. Every occurrence of the old spelling needs to be classified — is this occurrence a reference to the renamed concept, a reference to something else that happens to share the spelling, or a reference to the renamed concept that for some reason should legitimately keep the old word (a quotation, a historical record, an external name you don't control)? A rename review is really a classification exercise wearing the clothes of a text diff.

How large projects have done terminology migrations

Several widely documented efforts show how this plays out at real scale. They do not all use the same mechanics, and the differences are instructive.

Kubernetes: "master" to "control-plane." Kubernetes replaced the node-role.kubernetes.io/master node label and its associated taint with node-role.kubernetes.io/control-plane, tracked as KEP-2067 [2]. The project did not do a single cutover; it ran a staged migration across multiple releases. The control-plane label was introduced alongside the existing master label well before master was touched, so that both labels and taints coexisted and any workload relying on either selector kept working. Only in a later release did kubeadm upgrade apply stop adding the master label to new nodes and begin actively removing it from existing control-plane nodes on upgrade; the taint followed a similar staged removal, and consumers like CoreDNS had their tolerations for the old taint updated in a still-later release [2]. The project's own reasoning for the rename was that a dedicated working group had flagged "master" as needing replacement, but the execution is the interesting part: dual-labeling first, removal only after an announced grace period, communicated through release notes and community channels, with explicit sequencing, rather than a single atomic rename commit.

git / GitHub: "master" to "main" as the default branch. GitHub's own guidance repository for this migration describes changes made "in a few phases, designed to cause as little disruption to existing projects as possible" [4]. The new main default applied to newly created repositories; "Existing repositories are also not impacted by this change" [4]. When a maintainer does rename a branch, GitHub redirects web requests for the old branch name to the new one, returns a "Moved Permanently" response for API requests against the old name, retargets open pull requests, moves branch protection rules that reference the old name, updates the branch used to build GitHub Pages, and shows a notice to contributors who push to the old branch [4]. GitHub's own write-up explains the choice of "main" itself partly on practical grounds — it's short, keeps muscle memory intact, and translates reasonably across languages — but the operational lesson is the redirect-and-retarget machinery, not the specific word chosen.

Rust: renaming standard-library collection types. RFC 0580 proposed renaming several std::collections types for naming consistency — Bitv to BitVec, BitvSet to BitSet, DList to LinkedList, and RingBuf to VecDeque — while explicitly leaving well-established names like Vec, HashMap, and BTreeMap untouched [5]. The compatibility mechanism the RFC specifies is: "If necessary, redefine the original names as aliases of the new names, and mark them as deprecated. After a transition period, remove the original names completely" [5]. Marking an item deprecated is what makes the transition visible: per the Rust Reference, "rustc will issue warnings on use of #[deprecated] items" [13]. The alias is load-bearing: it means every caller using the old name keeps compiling, gets a deprecation warning, and only breaks once the maintainers deliberately remove the alias — a decision made on its own schedule, independent of when the rename itself landed.

Linux kernel: inclusive terminology for new code. The kernel's own coding-style documentation contains a section recommending that new code avoid "master/slave" and "blacklist/whitelist," with concrete suggested replacements (primary/secondary, leader/follower, controller/device, denylist/allowlist, blocklist/passlist, among others) [3]. What's notable is the explicit, narrow scope: the guidance is to "avoid introducing new usage," with stated exceptions for maintaining a userspace ABI/API, and for updating code for an existing (as of 2020) hardware or protocol specification that mandates the old terms [3]. It does not call for rewriting existing code, and it sets no date by which the old terms must disappear; where an ABI/API or specification requires them, preserving the old term is the point — a recognition that renaming inside a live interface contract is a different (and much higher-risk) action than renaming inside code you're actively writing.

IETF: terminology guidance for protocol documents. A long-running Internet-Draft, "Terminology, Power, and Inclusive Language in Internet-Drafts and RFCs," argues that authors should replace exclusionary pairings like master-slave and blacklist-whitelist with more precise, non-metaphorical alternatives — primary/secondary, primary/replica, active/standby, writer/reader for the first pair; various accept/deny framings for the second [7]. Critically, its scope is prospective: it addresses "Internet-Drafts that are work in progress, and in new RFCs that may be published," recommends "a living stylesheet, rather than repeated RFCs" for tracking terminology, and suggests that authors referencing older specifications that still use the old terms "could use another term in their document and include a note to say that they have used the new term as a replacement for the term used in the referenced document" [7]. It proposes no edits to the older documents themselves. This is the same "don't rewrite history" instinct seen in GitHub's decision to leave existing repositories' defaults alone: the new term applies going forward, and older documents are referenced with a note rather than altered.

These five cases do not share one lifecycle, and it matters which one a rename resembles. Kubernetes and Rust's RFC 0580 are interface migrations with an end state: the new name is introduced alongside the old one, the old name keeps working for a transition period (release-numbered in Kubernetes, simply "a transition period" in the RFC), and only then is it removed. GitHub's branch rename also keeps the old name working, but through redirects and notices rather than a stated removal date, and it leaves existing repositories' defaults untouched. The kernel and IETF policies are prospective rather than migrations: they govern new code and future documents, leave the old term in place where an existing ABI/API or specification mandates it (kernel) or in the older documents being referenced (IETF), and set no retirement date. What all five share is narrower: none breaks existing users of the old name in a single step. The expand/migrate/contract discipline below applies to the first kind — a rename that crosses an interface you intend to retire — not to policies whose safety mechanism is preserving the old contract or record.

Compatibility mechanics

The mechanism underneath the Kubernetes and Rust renames above has a name: Parallel Change, also called expand-contract, described by Danilo Sato on Martin Fowler's bliki as a three-phase pattern for making a backward-incompatible change safely [6]. The phases are:

  • Expand — add the new name/interface/column alongside the old one, purely additively. Nothing is removed and no existing caller breaks.
  • Migrate — move callers, readers, and writers over to the new name incrementally, at whatever pace is safe for each consumer, while both old and new remain live and (if it's data) kept consistent with each other.
  • Contract — once nothing depends on the old name anymore, remove it.

Sato is explicit that the pattern's main cost is having to support two versions simultaneously during the migrate phase, and that the discipline required is finishing the contract phase — if it is skipped, "you might end up in a worse state than you started," carrying two names for one concept indefinitely [6]. This maps directly onto the kinds of artifacts a terminology rename touches:

  • Config keys and environment variables: read the new name first, fall back to the old name if unset (dual-read), and optionally write both during a transition (dual-write), logging a deprecation warning whenever the old name is actually used so you know when it's safe to drop.
  • Database columns and indexes: add the new column, backfill it from the old one, switch application code to read/write the new column (optionally still writing the old one for safety), and only drop the old column once telemetry shows nothing is reading it — the classic expand/migrate/contract sequence applied to schema.
  • CLI flags: accept both --channel-key and --session-group for a release or two, with the old flag's help text pointing at the new one and a startup warning when it's used, before removing it.
  • Code identifiers: RFC 0580's rename plan is a clean example at the language level — the old name is redefined as an alias for the new one and marked #[deprecated], so using it produces a compiler warning, until the alias is deleted after a transition period [5][13].
  • Historical records: changelogs, old release notes, and closed tickets that use the old term should generally stay exactly as they were written. They're a record of what was true at the time, not living documentation; rewriting them to use the new term retroactively erases the historical trail and can make old discussions harder to follow, not easier. This is consistent with both the IETF draft's suggestion that new documents note when they substitute a new term for the one used in a referenced document [7] and GitHub's choice to change the default only for newly created repositories and leave existing ones as they were [4].

Tooling

Different layers of a rename call for different tools, and conflating them is itself a source of error.

Symbol-aware renaming. The Language Server Protocol defines a textDocument/rename request that is sent "to ask the server to compute a workspace change so that the client can perform a workspace-wide rename of a symbol" [12]. The unit is a symbol, and the language server, not a text search, decides which locations belong to it; a server backed by a real compiler or type checker can use scopes, imports and types to tell two same-named things apart. This is the only tool class here that can, in principle, avoid renaming a different symbol or an unrelated field that happens to share the name, and how well it does so depends on the server's implementation, so the returned edit set still deserves review.

Syntax-aware codemods. For renames that need to run outside an IDE, across many files, in CI, or language-agnostically, structural tools fill a different gap. ast-grep uses tree-sitter, "a real parser, to parse the code into ASTs, which enables more precise and accurate matching and fixing"; a pattern is written as ordinary-looking code but matched against syntax nodes [9]. Its own comparison page is clear about the limit, though: it "only operates on the syntactic level of the code" and does not support "type information," "control flow analysis" or "data flow analysis" [9]. Two unrelated objects with a field of the same name can have the same syntactic shape, so ast-grep cannot by itself tell a reference to the renamed concept from a reference to something else. Use it with rules scoped as narrowly as the code allows (by file path, enclosing node, receiver or surrounding pattern), and review every match against the mapping table and do-not-change list. Comby is more generic still: it "does not rely on language-specific parsers" and can handle "non-code files like JSON or Markdown," but it "is not aware of the syntax and semantics of the target language," which trades accuracy for breadth [9]. Coccinelle, used heavily in the Linux kernel, takes a different route, with a dedicated semantic patch language for expressing C-specific structural transformations that understand control flow; the kernel tree ships a collection of such semantic patches for exactly this kind of large mechanical change.

Prose-aware renaming. For specification documents and other prose, the equivalent of a structural code tool is a terminology linter. Vale implements a substitution rule type specifically for this: a rule defines a table mapping a banned or outdated term to its preferred replacement, and the linter flags every occurrence of the old term along with the preferred form, so a reviewer can check each hit rather than trusting a blind replace [8]. The same rule is a natural home for the do-not-change allowlist, so the known-good occurrences (a quoted historical document, a different sense of the same word, an external product name you don't control) are recorded once instead of being rediscovered by a human re-reading the whole diff. Two kinds of entry need different mechanisms, though. Vale's substitution checks accept an exceptions list, "An array of strings to be ignored" [14], and an entry there is checked against the text the rule matched — so adding the old term itself (channel key) would exempt the term outright and defeat the rename check. An occurrence that is known-good only because of its context, such as a product name that contains the old term, belongs in the match pattern instead: swap keys "may also be regular expressions" [14], and Vale's regex syntax includes negative lookahead, (?!re) [15]. The key below flags channel key except where the word API immediately follows it. (Vale 3.15 and later also skip a match that falls inside a multi-word exceptions entry such as Channel Key API, but older ones compare the entry only with the matched Channel Key and still flag the product name; the lookahead behaves the same in both.)

# styles/Project/Terms.yml
extends: substitution
message: "Use '%s' instead of '%s'."
level: error
ignorecase: true
swap:
  # Skip only "Channel Key API", a hypothetical third-party product name we do not control.
  'channel key(?!\s+API\b)': session group

Residue checking. The simplest and most durable check of all is a grep for the old term across the entire tree after the rename commit, compared against an explicit exception list of occurrences that are intentionally unchanged (the historical-record case, the genuinely different sense of the word, an external name). Anything that shows up in the grep but isn't on the exception list is residue — exactly the class of bug that stranded the old term in the overview document in the motivating example above. This check is nearly free to run and should be run on every rename, not just the risky-looking ones, because the overview-document failure mode specifically strikes documents that look too stable to need checking.

Derived artifacts. Two kinds of artifact need different handling. Genuinely generated artifacts — a reference table or diagram produced by a script from a schema, config file, or other canonical input — should be fixed at that input and regenerated, not hand-edited to match. Separately maintained diagram source is different: rerendering a Mermaid file whose text still says "channel key" just redraws the old label, so that text is part of the rename itself. The UK Government Digital Service's guidance on "diagrams as code" recommends defining a diagram in code "which is then rendered automatically," citing benefits that include "ease of change," "a workflow to review changes," and "version history" [10]. Kept that way, a diagram's labels are ordinary text in the repository: the residue grep reaches them, the rename edits them like any other occurrence, a reviewer sees them in the diff, and only then is the diagram rendered. A rename that updates the prose but leaves a hand-drawn diagram with the old label is functionally the same bug as the residue case, just in a format grep can't reach.

Reviewing a rename

In the motivating example, an independent reviewer reading the rename commit on its own caught all three failure modes. That review generalizes into a small number of concrete practices, each of which targets at least one of them:

  1. Separate the rename from any semantic change. A commit (or PR) that does nothing but rename should contain nothing but renaming. If a rename is bundled with a behavior change, a reviewer has to simultaneously verify two different kinds of correctness, and mistakes in either one hide behind the other.
  2. Write the mapping table down before touching anything. Old term → new term, explicitly, plus a second list of "occurrences that look like the old term but must not change" — the component named "channel" that isn't the concept being renamed is exactly this second list's reason for existing. The mapping table is also the right place to record deliberate code/prose mismatches (like groupName in code vs. "session group" in prose) so a later reader finds the decision instead of re-discovering the confusion.
  3. Classify every hit, don't just replace every hit. Each occurrence of the old term found by a search needs to be bucketed: rename it, leave it (on the do-not-change list), or flag it for a human decision because it's ambiguous. A tool that auto-applies without this classification step reproduces the mis-rename failure mode by construction.
  4. Check the new name against the existing namespace before adopting it. The collision failure mode — a new short symbol landing on top of an existing one — is caught by one specific, cheap step: grep the proposed new identifier (and any short forms/abbreviations derived from it) against the current codebase and spec set before the rename lands, not after.
  5. Read the diff as a word-diff, not a line-diff. A line-level diff on a document-wide rename shows mostly-unchanged lines as fully rewritten, which buries the one line where the replacement was wrong inside dozens of lines where it was fine. A word-level diff isolates exactly the changed tokens, making an incorrect substitution visually distinct from a correct one.
  6. Run a positive control. Before trusting a review process (human or automated) to catch rename errors, deliberately plant one known bad substitution — a mis-rename on a homonym, or a collision with an existing name — and confirm the review step actually flags it. This is the same logic as mutation testing, where a code change is deliberately seeded into a program specifically to check whether the test suite notices; a "surviving mutant" means the suite has a blind spot exactly where the seeded bug was placed. Applied to review, a planted mis-rename that survives review tells you the review process — not just this particular rename — has a gap.

Agent-specific considerations

Bulk mechanical renames are, on paper, exactly the kind of task an LLM agent should be good at: deterministic, high-volume, low-creativity. In practice, agents performing free-form renames tend to drift toward two specific failure patterns beyond the ones already described. First, over-replacement: an agent asked to rename a term will sometimes also "helpfully" rewrite nearby prose for clarity or consistency, which reintroduces exactly the semantic-change-bundled-with-rename problem the review discipline above is designed to prevent, except now it's distributed across many small, easy-to-miss edits instead of one obvious one. Second, paraphrase instead of substitution: rather than using the exact new term, a model will sometimes produce a near-synonym or a slightly reworded phrase that preserves the local meaning but breaks the project's ability to grep for the new canonical term later, which quietly reintroduces inconsistent terminology in the very documents meant to fix it.

A recent study of a multi-agent framework for coordinated renaming reports, in its ablation study, that disabling human feedback cut precision from 47% to 11% — roughly a 4x degradation — because the agents went on to rename many identifiers that should have been left alone [11]. The result reinforces that developer (or reviewer) oversight is not a redundant formality for this task but catches a real, recurring class of error that fully autonomous rename agents miss. The practical implication is not that agents shouldn't do renames, but that the review techniques above apply with extra force when the renamer is an agent:

  • Give the agent the mapping table and the do-not-change list explicitly, as input, not as something it infers. An agent asked to "rename channel key to session group" without being told that "channel" has a second, unrelated meaning in the same documents has no way to discover that ambiguity reliably; an agent given the explicit do-not-change list for that second meaning can be checked against it mechanically.
  • Have an independent reviewer — ideally a separate agent invocation or a separate model from the one that performed the rename — check for meaning changes specifically, not just for whether the new term appears. A reviewer prompted narrowly ("did any sentence's meaning change as a side effect of this substitution?") is doing exactly the classification work described above, and doing it as a dedicated pass catches what a single combined generate-and-check pass tends to miss.
  • Regenerate generated artifacts; rename diagram source as text. If a summary table or diagram is produced by a script from a canonical input, have the agent change that input and regenerate, not hand-edit the output, which the next regeneration would overwrite with the old term. If a diagram is maintained as its own text source (e.g., Mermaid), that source is part of the rename: the agent should edit its labels like any other occurrence, so they show up in the residue grep and the word-diff, and only then render it [10]. A diagram that exists only as an exported image is outside both checks and needs a human to compare it against the mapping table.
  • Apply the positive-control check to the agent's own output before trusting it on a real rename. Plant a known ambiguous term or an identifier collision in a test document, run the agent's rename process against it, and confirm the agent (or its reviewer pass) actually catches it — the same discipline recommended for human review processes applies without modification to agent pipelines, and arguably matters more, since an agent has no instinct that something "feels off" the way a human skimming a familiar document sometimes does.

Checklist

  • Write the old→new mapping table and a separate do-not-change list before making any edits.
  • Check the new name/symbol against every existing identifier and short form already in scope.
  • Keep the rename in its own commit, with zero semantic changes bundled in.
  • Classify every hit from a search for the old term — rename, leave, or flag — rather than blanket-replacing.
  • Review the diff as a word-diff, and specifically re-read every sentence containing a homonym of the old term.
  • Explicitly check the overview/summary document, not just the detailed specs — it's the one most likely to be skipped.
  • For code/schema/config/CLI renames, use expand → migrate → contract: add the new name, dual-read/dual-write during migration, remove the old name only once nothing depends on it.
  • Use deprecation aliases with warnings (e.g., a #[deprecated]-style annotation or equivalent) rather than a hard break, wherever the rename crosses a public interface.
  • Leave historical records — changelogs, closed tickets, old release notes — untouched; annotate new documents instead of editing old ones.
  • For code, prefer symbol-aware rename (an LSP textDocument/rename from a language server that resolves symbols) over text search-and-replace; where a structural codemod (ast-grep, or Coccinelle for C) is used instead, scope its rules narrowly and review every match; ast-grep in particular matches syntax only and cannot tell two same-named symbols apart. For prose, use a terminology linter (e.g., Vale substitution rules) with an exception list.
  • For generated artifacts, update the canonical input and regenerate; for diagram source kept as text (e.g., Mermaid), rename its labels like any other occurrence, review them in the diff, then render.
  • Run a residue grep for the old term after the rename lands, reconciled against the do-not-change list.
  • Plant a positive control — a deliberate mis-rename or collision — and confirm your review process (human or agent) actually catches it before relying on that process for the real thing.
  • If an AI agent performs the rename, give it the mapping table and do-not-change list as explicit input, and route the result through an independent reviewer pass focused specifically on meaning changes, not just term coverage.

References

  1. Ubiquitous Language — Martin Fowler's Bliki
  2. KEP-2067: Rename the kubeadm "master" label and taint — kubernetes/enhancements
  3. Linux Kernel Coding Style — Naming section
  4. github/renaming — Guidance for changing the default branch name for GitHub repositories
  5. RFC 0580: Rename collections — The Rust RFC Book
  6. Parallel Change — Martin Fowler's Bliki
  7. Terminology, Power, and Inclusive Language in Internet-Drafts and RFCs (draft-knodel-terminology-10)
  8. Vale rules — Grafana Writers' Toolkit
  9. ast-grep: Comparison With Other Frameworks
  10. Diagrams as code — GDS Way, UK Government Digital Service
  11. Multi-Agent Coordinated Rename Refactoring (arXiv:2601.00482v1)
  12. Language Server Protocol Specification 3.17 — Rename Request
  13. The Rust Reference — Diagnostic attributes: the deprecated attribute
  14. substitution — Vale documentation
  15. Regex — Vale documentation