Anders Hejlsberg's AI Arc: Porting 500,000 Lines Without Letting AI Drive (1983–2026)

Case study run on 2026-09-21 against templates/research/pre-llm-elite-programmer-ai-adaptation.md, as the third cohort case after the DHH study and the Torvalds study. It is built on the evidence dossier from the earlier run the same day; every quote used here was re-fetched and verified live during this session, and one 2023 interview surfaced by this run’s search retry is newly added. Evidence layers: the Microsoft TypeScript devblogs, the typescript-go repo state and the GitHub API are the direct layer; the Aarthi & Sriram transcript (2023), the GitHub Blog interview write-up (2026-01-27), DevClass’s report of the same interview (2026-01-28), tech.hub.ms’s video summary (2026-03-04) and the Command Line write-up of The Peterman Pod (2026-08-17) are the self-report layer — with a provenance caveat stated up front: GitHub Blog and Command Line are Microsoft-owned company pages (GitHub is a Microsoft subsidiary), so the quotes they carry are self-report as published by his own company, not transcripts; DevClass is journalist-mediated. The VS Code team’s measured numbers are external observation (an independent team measurement, though inside the same company). What could not be verified is labeled as such, not guessed.

Why this case (template Section 2 screen)

Hejlsberg passes the template’s inclusion criteria on every count:

• Publicly recognized before 2023 for technical work: Turbo Pascal was released 20 November 1983, “originally developed by Anders Hejlsberg at Borland,” and he “was the architect for all versions of the Turbo Pascal compiler and the first three versions of Borland Delphi” (Turbo Pascal, Wikipedia — secondary source, labeled as such). Microsoft’s own archived bio: he joined Microsoft in 1996 and is “the chief designer of the C# programming language and a key participant in the development of the Microsoft .NET framework,” with C# “since its initial release in 2000” standardized by ECMA and ISO (archived Microsoft Technical Fellow bio, primary for the roles). TypeScript arrived in 2012 as “a typed superset of JavaScript” (Microsoft Learn archive, 2012-10-03).
• Reputation grounded in programming ability, not executive status: his GitHub bio today reads “Microsoft Technical Fellow and lead architect of TypeScript. Original designer of C#, Delphi, and Turbo Pascal” (GitHub API), and he told the Aarthi & Sriram show in 2023: “I’ve never been a people manager. I’ve never risen up the ranks.”
• Post-2023 public evidence is abundant: a dated 2023 podcast transcript, a 2025 announcement he authored, three 2026 interview write-ups, a shipped 10x compiler, and a closed staging repo.
• He actually encountered AI coding tools — and the record shows the template’s required pattern, with one unusually sharp twist: famous programmer → encounters AI coding → his team’s practice demonstrably changes while his personal boundary stays fixed (documented below).

The template’s caution — “uses AI” ≠ “changed how they program” — is the load-bearing wall of this case. Almost everything the record documents about his AI use is what the TypeScript team does; what he personally does with AI day-to-day is not documented in any fetched source. That distinction is kept explicit throughout.

Pre-2023 baseline (template Section 3)

What made him unusually good? Two attributes recur across four decades, both in his own words. First, compiler/semantic fidelity: the type checker “has a whole bunch of behaviors that are not captured anywhere but in the exact semantic behavior of that code” (DevClass, 2026-01-28, self-report via journalist); the Turbo Pascal 2.0 hash-table story — reading Wirth, implementing, “boom, the compiler went twice as fast. There’s Turbo Pascal version 2.0” — is the origin myth of that mindset (Aarthi & Sriram, 2023). Second, fast feedback loops: “When you typed your code, you wanted to run it immediately” (GitHub Blog, 2026-01-27, blockquote attributed to him in the write-up); the same page: Turbo Pascal’s impact “came from shortening the feedback loop.”

His 2023 self-description of the personal setup, from the same podcast: “I’m actually a pretty simple guy. I don’t have a super, multi monitor, fancy, gaming setup. I like to work on laptops” — a laptop the transcript renders as “Pad P1” with a 4K touchscreen (the host’s reply in the same exchange, “Lenovo makes the best keyboards still,” indicates the Lenovo ThinkPad line — our derivation, labeled as such), Windows, Windows Terminal, “I, of course, use Visual Studio heavily. My color scheme is Monokai,” and both printf-style debugging and profilers. This is a pre-agentic-era self-report, cited to establish the baseline; it is not evidence of any AI tooling.

Comparative advantage carried forward (derivation from the facts above): compiler semantics plus fast feedback loops. Both land exactly where AI-era tooling needs them — which is his own framing of the 2025 port (below) — and neither is a typing skill.

The adoption timeline (template Section 4)

Phase 1 — 2023 (ChatGPT / GPT-4 era): found this run

The prior dossier found no 2023–24 AI comments in its fetched sources and flagged that its search tooling was degraded. This run’s search retry surfaced one: The Aarthi and Sriram Show, EP 34, published 2023-02-11, whose show notes list an “AI and LLMs” section and publish a full transcript (the transcript contains artifacts — [inaudible], [unintelligible] markers — so quotes are given exactly as published, via the show’s own site). His February 2023 position, in his own words:

• On language design: “Language design, no. Language design moves very slowly.” On tooling: “I do think it’s going to change the way we construct tooling. Absolutely. Copilot is one example of that.”
• On the models: “These large language models are at one time mind-blowing in their capability and mind-blowing in their time stupidity” (as transcribed), endorsing Tim Sweeney’s characterization: “ChatGPT is like a person with encyclopedic knowledge and the writing skills of an English professor but with the reasoning abilities of a first-grader.”
• On his own reasoning: “I don’t arrive at my solution to my algorithm by thinking about what the next token is.”
• The line that prefigures his 2026 position: “maybe we’re at the moment of peak truth right now… from here on out, we’re going to be training AI models on a bunch of AI-generated garbage that is just regurgitation of their own hallucinations.” And the boundary, already present in 2023: “It does not absolve you from understanding what the code does. I don’t think that you can get away with not being a programmer just because you have something like an LLM.”

This partially fills the 2023 cell of the timeline; 2024 remains empty — no fetched source documents any 2024-dated AI comment from him, and that gap is labeled as such, exactly as the sibling posts do.

Phase 3 — 2025: the announcement

2025-03-11: “A 10x Faster TypeScript,” authored by Hejlsberg (TypeScript devblog), announces “a native port of the TypeScript compiler and tools” with the promise to “drastically improve editor startup, reduce most build times by 10x, and substantially reduce memory usage.” Its AI framing is explicit and motivating, not incidental: “New experiences powered by AI benefit from large windows of semantic information that need to be available with tighter latency constraints,” and the port “will enable the next generation of AI tools to enhance development, powering new tools that will learn, adapt, and improve the coding experience.” Note the timing derivation: on the Command Line write-up in August 2026 he says “We started this project two years ago” — placing the start of the work around mid-2024, months before the public announcement [derivation, labeled as such].

Phase 4 — 2026: the interviews and the GA

• 2026-01-27: GitHub Blog long-form interview write-up (7 learnings from Anders Hejlsberg, by Aaron Winston; interviewed by GitHub research advisor Eirini Kalliamvakou per DevClass). Its AI section, in the write-up’s editorial voice: “The traditional IDE model assumed a developer writing code and using tools for assistance along the way. Increasingly, that relationship is reversing. AI systems generate code. Developers supervise and correct. Deterministic tools like type checkers and refactoring engines provide guardrails that prevent subtle errors.” The named risk: “plausible, confident code that lacks enough grounding in the realities of a codebase.” He is “skeptical of the idea of AI-first programming languages. Models are best at languages they have already seen extensively, which naturally favors mainstream ecosystems like JavaScript, Python, and TypeScript.”
• 2026-01-28: DevClass’s report of that interview (Tim Anderson, journalist-mediated): AI is “a big regurgitator of stuff someone has done, with some extrapolation on top”; the 10x was “half of it from being native code, and the other half from being able to take advantage of shared memory concurrency”; the IDE era gives way to supervision — “you’re supervising what it’s doing, and it doesn’t necessarily need an IDE in the same way” — and “connecting language services to MCP” so AI can “ask semantic questions or refactoring questions.”
• 2026-03-04: GitHub video “Anders Hejlsberg Discusses the Evolution from AI Assistant to AI Agent,” summarized by tech.hub.ms (secondary summary; the video itself was not transcribed): “The AI is doing the work, and you’re supervising.”
• 2026-07-08: TypeScript 7.0 GA (announcement, by Daniel Rosenwasser): “a 10x faster native port of TypeScript” with “speedups between 8x and 12x on full builds” — vendor claims, labeled.
• 2026-08-17: The Peterman Pod episode, written up by Microsoft’s Command Line (Watch TypeScript creator Anders Hejlsberg on The Peterman Pod). This is where the boundary quotes and the “agentic AI didn’t play much of a role in the port” admission appear (below). The episode video itself was not transcribed in fetched sources; quotes come from the company write-up.

The port as the artifact (template Section 13 leverage)

The measurable artifact of this case is the TypeScript 7 port, and its numbers come in two differently-labeled flavors:

The vendor and VS Code numbers are not directly comparable — different commands, codebases, and TS 6 vs 7 builds — and the VS Code team, while a different org, is still inside Microsoft; both caveats are stated rather than smoothed. What the VS Code post adds that vendor numbers cannot: the speedups benefit “both developers and agents,” and “asking an agent to iterate on a project” is named as a first-class beneficiary.

The decisive structural finding sits in the Command Line write-up: “Interestingly, agentic AI didn’t play much of a role in the port—a fact that Hejlsberg chalks up to timing. ‘We started this project two years ago,’ he said, ‘and LLMs were nowhere near as good as they are now.’” The team “wrote its prototypes, including the scanner and parser, manually,” then wrote “a tool that syntactically translates TypeScript into Go,” refactored the data structures by hand — “We had to redo all the data structures, but we got the same codebase out of it. Then we could sort of bang on that and then, in a more localized fashion, use AI occasionally to help us with the transformation.” The tension is real and kept visible: the port was motivated by AI (2025 announcement) but executed almost without it (2026 interview), with AI adopted afterward at the margins — “We’ve actually been using AI fairly successfully,” he said, to migrate new pull requests from the old codebase into Go (DevClass), and daily use “helping to write tests, move pull requests, and more” (Command Line). The typescript-go repo is closed: “This was the staging repo for the TypeScript 7.0 release during the native port process, which is now completed!” [fact].

The AI boundary — determinism first

Where he stops delegating is stated more precisely than in almost any other case in this cohort, in three moves:

1. The wholesale-port refusal. Command Line, on whether starting today would be done differently: “Possibly, although I will say that if we just let AI loose on the code in the old compiler and asked it to translate it all, I don’t know if that would absolve us from then having to go in and carefully examine every line that came out of it to make sure there were no hallucinations. Unless you have 100% perfect test coverage, you probably still have to go back and check all of that.” DevClass records the earlier attempt and the same reasoning: “That went not so great … we want a very deterministic outcome here. We want to port half a million lines of code and know that they do exactly what the old lines of code did. If you ask AI to translate them, it might hallucinate a little bit here and there, and now you’ve got to go carefully examine every line of code.”
2. The workaround — ask for a program, not an answer. “ask AI to generate a program that helps you do the port, because then when you run that program, you get a deterministic outcome” (DevClass). On the Peterman Pod he gives its general form: “That’s always the thing about AI that people forget: It’s not deterministic, right? So you can’t really trust that it’ll do the same thing twice. But it’s very good at writing programs, so it’s kind of funny. Sometimes you don’t ask AI for the answer. You ask it for a program that computes the answer.” (Command Line)
3. The 2023 root. The boundary predates agents: “It does not absolve you from understanding what the code does” (Aarthi & Sriram, 2023). What changed by 2026 is not the principle but its scope — from advice to architecture.

The AI stack, as evidenced (template Section 6)

The honest structural finding, stated first: every AI-practice claim in the fetched record is team-level self-report. His personal editor, model, and agent setup in 2025–26 is not documented in any fetched source. The table below is therefore split.

Memory, orchestration, parallelism: no public evidence found at either level in fetched sources. GitHub-API evidence on the personal side is negative: his four public repos are all talk-demo repos (2016–2021, TypeScript/JavaScript), with no personal repo pushed since September 2021 (GitHub API) — a data point about what is not visible, not about what he does.

Unit of work (template Section 7)

The template’s cross-case question — what is the largest unit of work the programmer comfortably delegates? — gets a two-level answer:

• Team level, the delegated units: a logged issue (“put Copilot on it”), test-writing, and PR migration between codebases (“fairly successfully”). Each is bounded by a deterministic verifier: the type checker, the test suite, or the requirement that ported PRs preserve old behavior.
• The refused unit: the wholesale translation of the compiler itself — half a million lines whose defining property is that they must “do exactly what the old lines of code did.” That refusal is not fear of AI code quality in general; it is a stated audit-arithmetic argument: delegation only pays when verification is cheaper than generation, and for the semantic core of a compiler it is not.

Interpretation, labeled as such: DHH delegates whole problems; antirez (per his evidence dossier in this repo) delegates implementation but hand-carries context through a web interface; Hejlsberg’s team delegates tasks, but the boundary is drawn where output can no longer be checked mechanically — and he converts refusal into tool-building (MCP-exposed language services) so agents can still operate, correctly, inside the fence.

Bottleneck migration (template Section 8)

• Before AI: the constraint he attacked in 2025 was feedback latency at scale — the port exists because large codebases “can experience long load and check times” (A 10x Faster TypeScript), with AI explicitly named as the new consumer of “large windows of semantic information… with tighter latency constraints.”
• After AI: the constraint his 2026 record names is trustworthy delegation — “plausible, confident code that lacks enough grounding in the realities of a codebase” (GitHub Blog), hallucination audit on generated ports (Command Line), and supervision as the operating mode (“The AI is doing the work, and you’re supervising,” via tech.hub.ms).

Derivation, labeled as such: for a man whose comparative advantage was always feedback-loop speed, the migration is coherent — he did not move from typing to prompting; he moved from making the loop fast for humans to making the loop fast and verifiable for agents, which is the same skill applied one layer out.

What he stopped / started doing (template Sections 9–10)

Stopped: no fetched source documents him personally stopping any concrete practice — the honest answer, per the team-vs-person finding. At team level, the documented stop is the early experiment of letting AI translate the port (“That went not so great”), abandoned in favor of a deterministic translation tool (DevClass).

Started (team level), mapped to the template’s categories:

• C Agent supervision — “you’re supervising what it’s doing” (DevClass); “The AI is doing the work, and you’re supervising” (tech.hub.ms).
• D Harness engineering — language services exposed via MCP so agents can “ask semantic questions or refactoring questions” (DevClass); his own framing is that AI needs “the equivalent of what you would do in an IDE, but do it the LLM (large language model) way or the agent way.”
• F Evaluation — deterministic guardrails positioned as the load-bearing verification layer for AI output (GitHub Blog).

No fetched evidence places him personally in prompting, harness-building, or orchestration roles; the record documents the team’s workflow and his design authority over it.

Identity after AI (template Section 11)

The 2023 self-report anchors the “before”: “My calling is writing code, I’ve doubled down on that” (Aarthi & Sriram). The 2026 record anchors the “after”: chief designer of a shipped 10x compiler, architect of the agent-facing language-service surface, and the person articulating the generate-supervise-guardrail division of labor. Classification, our interpretation: Type B — programmer+architect, drifting toward supervision-and-tool-design at team level — but the record does not document a personal shift to Type C (agent engineer) or Type F (specify/evaluate), because his personal practice is not documented at all. What the record does document is a man four-plus decades in who is still the language designer deep in compiler semantics — the same specialization, with a new class of consumer (agents) for the same product (exact semantics, fast loops).

Spectrum position (template Section 12)

Hejlsberg is the cohort’s clearest team-heavy / personal-bounded case: adoption is high and institutional (daily Copilot on issues, MCP-exposed services, guardrail architecture), while the personal boundary is hard and explicit (no wholesale delegation of semantic-critical translation; “ask it for a program that computes the answer”). Against the siblings: DHH is heavy personal adoption (problem-level delegation, ~100% agent-written shipped code by his own account), Torvalds is moderate adoption with refusal at his gatekeeping layer. The template’s question — did output change despite different adoption? — gets a distinctive answer here: the flagship output (the port) was produced with almost no AI, and AI’s documented contributions sit at the edges (PR migration, tests, issue triage).

Output leverage, with the caveats on every number (template Section 13)

• The port itself: vendor-claimed 8–12x on full builds (11.9x vscode), −18% memory; VS Code team’s independent 7x type check, ~4x watch, ~6x editor load — all labeled as in the table above. AI-attributed share of the speedup: none documented; the 10x is attributed by him to native code plus “shared memory concurrency” (DevClass), i.e., porting craft, not AI.
• Post-port AI leverage: AI “fairly successfully” migrates new PRs between codebases (DevClass); daily use on tests and issue fixes (Command Line).
• Adoption evidence from the consumer side: the VS Code team’s ~six-month incremental migration (summer 2025 → early 2026), with TS 7 already “shockingly far along” when they started (VS Code blog).
• Ecosystem position: TypeScript was “the most used language on GitHub” in 2025 per the 2025 Octoverse report, as cited on the fetched Command Line and GitHub Blog pages (vendor-reported).
• Template Section 5 code-sampling was not performed in this run; no commit-level analysis of his personal commits exists in fetched sources. His public GitHub footprint shows no personal repos pushed since 2021 (GitHub API).

AI leverage × pre-existing strength (2×2, template Section 14)

Strong-programmer row, high-adoption column — at team level: the “AI-amplified master” cell, where AI amplifies exactly his pre-2023 strengths (semantic fidelity → guardrails; fast loops → agent-iteration speed). The personal cell is honestly marked not documented: the record cannot place his individual workflow on the adoption axis. The row’s question — what does AI amplify in a great programmer? — gets a compiler-designer’s answer here: not generation, but grounding — he spends his amplified leverage building the semantic surface that makes AI output checkable.

“Taste-to-code ratio” (template Section 15) — qualitative construct

Not a measured metric. In the sibling cases, AI raises implementation output while judgment stays constant. Hejlsberg’s case inverts the mechanism: the half-million-line implementation was accelerated by a deterministic translation tool the team wrote itself, with AI used “in a more localized fashion… occasionally” — and the LLM’s most valuable documented output was itself a program (“a program that computes the answer”), i.e., taste delegated one meta-level up: use the stochastic machine to build deterministic machines. The judgment unit that did not change is semantic fidelity; the implementation unit that got cheaper was made cheaper by tool craft first and AI second.

The unchanged core (template Section 16)

1. Exact semantic fidelity. “We were going to port because only by porting could we preserve the semantics, algorithms, and exact behavior of our existing compiler, which everyone depends on for backwards compatibility” (Command Line); “This was not a rewrite. The goal was semantic fidelity” (GitHub Blog).
2. Fast feedback loops. From Turbo Pascal’s edit-compile-run to TS7’s agent-assisted iteration — the same 1983 principle, now serving agents.
3. Deterministic tools as guardrails. Type checker and refactoring engine as the trust boundary for stochastic output (GitHub Blog).
4. Understanding what the code does. 2023: “It does not absolve you from understanding what the code does” (Aarthi & Sriram). 2026: the refusal to hand wholesale translation to AI without examining every line (Command Line). The invariant is unchanged across the divide.

Hypotheses H1–H4 against this case (template Section 19)

• H1 (great programmers become super-programmers) — Evidence for: one team shipped an order-of-magnitude compiler artifact, and the VS Code team’s independent measurements confirm the gains. Against: the artifact’s speedup is attributed to porting craft, not AI; AI’s documented role was marginal at execution time. Project-level amplification confirmed; AI-attributed amplification not demonstrated in this case.
• H2 (programming moves upward) — Strong self-report arc, but at team level: generate → supervise → guardrail, supervision moving outside the IDE (DevClass; tech.hub.ms). Against: the personal layer is undocumented, and he personally remains the designer of the guardrails and the port. Supported at team level, with a stated personal-observation gap.
• H3 (more specialized, not less) — He doubles down on compiler and tooling semantics — the port, the type checker, MCP language services — not generic product work. Supported.
• H4 (taste + orchestration is the scarce skill) — Partially, with the cohort’s sharpest refinement: his scarce skill is audit-surface design — deciding what must be deterministic so that delegation becomes checkable — rather than multi-agent orchestration; no parallel-agent evidence exists in fetched sources. “You ask it for a program that computes the answer” is taste expressed as orchestration of determinism, not of agent swarms. Supported with an amendment: orchestration here means engineering the verify step, not running more agents.

Gaps and what would change this picture

• 2023–2024: partially filled this run — the February 2023 Aarthi & Sriram interview (found via the search retry the prior run could not execute) documents his first substantive public AI position. 2024 remains empty in fetched sources; whether that is absence or just an unindexed year cannot be determined from what was fetched.
• Personal vs team: the decisive structural gap. All AI-practice evidence is team-level self-report; no fetched source documents his personal editor/model/agent setup in 2025–26. Any statement about “his” AI workflow beyond the team record would be fabrication.
• Quote provenance: the strongest 2026 quotes come from Microsoft-owned company write-ups (Command Line, GitHub Blog — GitHub is a Microsoft subsidiary) that are not transcripts; DevClass’s quotes are journalist-mediated (Tim Anderson); the Aarthi & Sriram transcript is the show’s own published page, with transcription artifacts (including the odd “their time stupidity” rendering and an apparent “Pad P1” for ThinkPad P1). The Peterman Pod video, the 2026-03-04 GitHub video, and the 2026-04-30 Sajjaad Khader interview (listing with timestamps; video itself unfetched) were not transcribed in fetched sources.
• The 10x numbers are vendor claims checked only against one other Microsoft org’s measurements; an independent non-Microsoft benchmark would strengthen or falsify them.
• No commit-level sampling of his personal TypeScript contributions (template Section 5); the “chief committer on the type checker” claim is 2023 self-report, and its 2026 status is not documented.
• When the team’s daily-Copilot practice started is not documented; the earliest dated evidence is January 2026.

Four cases on one spectrum (contrast coda, interpretation)

Interpretation, labeled as such — drawn from this case and the sibling posts; the antirez characterization comes from its evidence dossier in this repo, whose full case study is a companion piece:

DHH converted personally; Torvalds governs; antirez stays in the loop by refusing agents; Hejlsberg redesigns the tools so that delegation can be trusted — the compiler-builder’s answer, applied to agents.

Interpretation

This case suggests that — and this paragraph is our interpretation, not a sourced fact — a pre-2023 elite programmer whose comparative advantage was exact semantics and fast feedback met the stochastic machine the way a compiler designer would: by fencing it. Hejlsberg’s documented answer to “what may AI touch” is an audit-arithmetic rule, not a vibe: delegate where a deterministic artifact can be run and checked (a generated program, a migrated PR, an issue fix under the type checker), refuse where semantic fidelity is the product itself (the half-million-line port). The port is the proof that the fence works in both directions — it shipped an order-of-magnitude speedup with almost no AI, then adopted AI for the margins where checking is cheap. Where DHH’s arc is conversion, Torvalds’s is governance, and antirez’s is craft-loop refusal, Hejlsberg’s is tool-making: the 2012 insight that types enable tooling becomes the 2026 practice of exposing language services to agents over MCP, so that whatever writes the code next inherits the same guardrails his compilers always enforced. His unchanged core — understanding what the code does — is the same in 2023 and 2026; what changed is who needs the guardrails: first humans, now agents.

Sources

Fetched and verified live during the run on 2026-09-21 (each URL fetched directly this session unless noted):

Direct layer

• A 10x Faster TypeScript (TypeScript devblog, 2025-03-11, by Anders Hejlsberg) — the port announcement; AI-latency motivation quote; “next generation of AI tools”; preview speedup table (10.4x vscode).
• Announcing TypeScript 7.0 (TypeScript devblog, 2026-07-08, by Daniel Rosenwasser) — GA; “8x and 12x” table (vscode 11.9x); memory −18%; the “perhaps an AI agent” editor framing.
• typescript-go README (raw.githubusercontent.com) — staging repo closed; “the native port process… is now completed”; archive planned September 2026.
• GitHub API: users/ahejlsberg and users/ahejlsberg/repos — bio; Technical Fellow title; four talk-demo repos (2016–2021), no personal pushes since September 2021.

Self-report layer (with provenance labels)

• The Aarthi and Sriram Show, EP 34 (2023-02-11) — newly found this run; published transcript with artifacts; 2023 AI/LLM section, 2023 setup, “My calling is writing code,” the “peak truth”/regurgitation passage.
• 7 learnings from Anders Hejlsberg (GitHub Blog, 2026-01-27, by Aaron Winston) — Microsoft-owned company page; interview write-up (not a transcript); full body retrieved via the WordPress API endpoint https://github.blog/wp-json/wp/v2/posts?slug=7-learnings-from-anders-hejlsberg-the-architect-behind-c-and-typescript (fetched this session).
• TypeScript inventor Anders Hejlsberg: AI is ‘a big regurgitator…’ (DevClass, 2026-01-28, by Tim Anderson) — journalist-mediated verbatim quotes from the same GitHub interview.
• Anders Hejlsberg Discusses the Evolution from AI Assistant to AI Agent (tech.hub.ms, 2026-03-04) — secondary summary of a GitHub video; single notable quote; video not transcribed.
• Watch TypeScript creator Anders Hejlsberg on The Peterman Pod (Command Line, 2026-08-17) — Microsoft-owned company write-up of the podcast episode (video not transcribed); port-decision, Rust, no-rewrite, agentic-AI-timing, hallucination-audit, and Copilot-daily quotes.

External observation layer

• Iterating faster with TypeScript 7 (VS Code blog, 2026-06-26) — the VS Code team’s measured 7x / ~4x / ~6x numbers over a ~six-month adoption, “both developers and agents.”

Baseline layer (pre-2023)

• Turbo Pascal (Wikipedia) — 1983-11-20 release; original author; “architect for all versions”; Byte sales figures. Secondary source, labeled as such.
• Anders Hejlsberg: Technical Fellow (archived Microsoft bio, 2007) — joined Microsoft 1996; chief designer of C#; .NET key participant; ECMA/ISO standardization.
• Anders Hejlsberg: Introducing TypeScript (Microsoft Learn archive, 2012-10-03) — “a typed superset of JavaScript.”

Pointer (not transcribed; listing fetched)

• Anders Hejlsberg, Interview (2026-July-Day-1) (Learning in the Open, 2026-07-11) — timestamps-only listing of the 2026-04-30 Sajjaad Khader interview (“AI will NEVER Replace Coders, Here’s Why”); the video itself was not fetched or transcribed this session; no quotes taken from it.

Deliberately excluded from evidence: Hacker News threads and other community aggregations (pointer-only in the prior dossier, not fetched this session), the developing.dev post and LinkedIn posts surfaced by search (not fetched), and anything else not listed above. The prior dossier’s fetched-but-not-reused URLs (YouTube oEmbed checks, the HN comment) are documented in the dossier.

Template: templates/research/pre-llm-elite-programmer-ai-adaptation.md in this repo. Every claim above is either a sourced fact with the link shown, a labeled self-report (with its provenance caveat), a labeled vendor claim, a labeled external measurement, a labeled derivation, or labeled interpretation. Nothing in this note was recalled from model memory without a fetched source.