Salvatore Sanfilippo's AI Arc: 'Still the Coder, But Augmented' — Then the Switch (2009–2026)

Case study run on 2026-09-21 against templates/research/pre-llm-elite-programmer-ai-adaptation.md, in the series that includes the DHH case and the Torvalds case. It rests on a same-day evidence dossier (content/dev-tools/antirez-ai-adaptation-dossier-2026-09-21.md). The evidence layers are unusually clean here: his own blog is a self-report layer with dates, the GitHub API provided the direct layer (repo and PR facts), and the Redis company pages are the vendor/external layer. All URLs below were fetched live during this session’s runs; the two most load-bearing posts (news/154, news/164) were re-fetched and verified verbatim during the writing run. One methodological caveat, kept throughout: antirez.com displays post ages as “N days ago” counters, so post dates below are derivations anchored to the fetch date 2026-09-21 — two of them cross-check exactly against independent search-result dates (news/154 → 2025-07-20; news/151 → 2025-05-01). What could not be verified is labeled as such, not guessed.

Why this case (template Section 2 screen)

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

• Publicly recognized before 2023 for technical work: the redis/redis repository was created 2009-03-21 (GitHub API); the Redis company page states “Salvatore built Redis in 2009, and the project until 2020” (vendor claim, redis.io). Disque, “a distributed message broker”, follows in 2015 (GitHub API).
• Reputation grounded in programming ability, not CEO status: he left Redis in 2020 to write (“The end of the Redis adventure”, his own departure post) and returned as an individual contributor, not an executive. His self-description: “I am an expert in system programming” (antirez.com/news/140).
• Post-2023 public evidence is abundant — and first-person: a dense, dated blog spanning January 2024 → July 2026 (ten posts fetched and verified), plus his GitHub activity.
• He actually encountered AI coding tools: his own retrospective — “Since the advent of ChatGPT, and later by using LLMs that operate locally, I have made extensive use of this new technology” (antirez.com/news/140).
• The template’s required pattern is documented twice over: famous programmer → encounters AI coding → changes his practice — and then changes it again, in the opposite direction, eighteen months later. That second movement is what makes this case more than a biography.

One screen note: he co-founded the Redis company (“I was one of the two founders”, news/144), but his reputation is his code and his writing about code — not CEO status.

Pre-2023 baseline (template Section 3)

3a. What did he build?

3b. What kind of programmer was he?

Primary: systems programmer (C). Secondary: database engineer, developer-tool builder, and a security-researcher credential from Hping (derivation from the facts above; dossier).

3c. What made him unusually good?

His own statements, dated and fetched:

• “I’m an extremist only about software design” and “Redis, for me, is lego for programmers, not a ‘product’” (news/144).
• “I wrote my first NN library in 2003” (news/144) — a machine-learning credential older than most of the field’s current tools.
• The design philosophy the community knows him for: simplicity as a feature, memory efficiency, minimal moving parts (his departure post recalls co-founding two of “the major web 2.0 services of the Italian web” — index, latest/26).

Comparative advantage carried forward (derivation): design taste under constraint — the ability to decide what a data structure should be, exactly, before any code exists. This is the thing his later workflow defends at all costs.

The adoption timeline (the journey itself)

Phase 0 — pre-2023 (no modern LLM coding)

No 2023-dated primary post was found in the fetched blog index slices; his 2023 is documented only retrospectively. First person, from his own January 2024 post: “Since the advent of ChatGPT, and later by using LLMs that operate locally, I have made extensive use of this new technology” (news/140).

Phase 1 — 2023→early 2024 (ChatGPT / GPT-4 era): the language boundary

The January 2024 post sets a boundary that will define his whole arc (news/140):

“I have increasingly used LLMs to write high-level code, especially in Python, and much less so in C… when I write a program in C, I almost always end up using LLMs only as a more convenient form of documentation.”

Local models too: Mixtral and deepseek-coder via llama.cpp on a MacBook M1 Max. And he was already doing LLM research himself — a proposed sampling algorithm (“First Token Cutoff”, news/142) and GPT-4-driven translation experiments (news/141), per the blog index (latest/26).

Phase 2 — December 2024: the return, with Claude as a partner

He rejoined Redis as “evangelist” (vendor claim, company republication by Rowan Trollope, 2024-12-10; role self-reported in news/144). The same post contains the first heavy-use statement:

“Claude AI is my reasoning / editor / coding partner lately. I’m able to accomplish a lot more than I was able to do in the past. I often do more work because of AI, but I do better work.”

Note what he used it for beyond code: Claude as critic on his fiction — with the boundary stated in one line: “I didn’t let Claude write a single line of the story or the plot: great use of AI is not making machines do what you can do better” (news/144).

Phase 3 — July 2025: the manifesto (“still the coder, but augmented”)

The most-quoted document of his arc, “Coding with LLMs in the summer of 2025 (an update)”, fetched verbatim during this session. Its doctrine, in his own words:

“In this historical moment, LLMs are good amplifiers and bad one-man-band workers… after daily experience writing code with LLMs I strongly believe the maximum quality of work is reached using the human+LLM equation.”

The five uses he documents: pre-release bug elimination (“many were just removed immediately by Gemini / Claude code reviews” — on Vector Sets), throwaway exploration code, “pair-design activities”, partial code under “your clear specifications”, and contiguous domains (“coding in 68000 assembly for an Amiga demo?”). The headline rule:

“Refuse vibe coding most of the times.”

And the interface doctrine — the most specific anti-agent position in the cohort:

“The fundamental requirement for the LLM to be used is: don’t use agents or things like editor with integrated coding agents… Avoid any RAG that will show only part of the code / context to the LLM… Always be part of the loop by moving code by hand from your terminal to the LLM web interface: this guarantees that you follow every process. You are still the coder, but augmented.”

Model picks: “Gemini 2.5 PRO… Claude Opus 4… If you can pick just one, go for Gemini 2.5 PRO.” Language note: “C code tends to be, in my experience, much better” than what LLMs write in Python. Context trick: adding READMEs to the window for types so new that “LLMs don’t yet know about” them — “the LLM can use vector sets at expert level immediately.”

He even pre-committed the condition under which he’d abandon this doctrine: “When this will be true, that agents will perform superb work, I’ll be the first to switch” (news/154). Keep that sentence in mind for Phase 4.

Phase 4 — 2026: the reversal (agents, then his own tooling)

By the end of 2025 the interface had already loosened: “all my interaction is via the web interface of Gemini, Claude, …” (news/157). Then January 2026 produced the cohort’s cleanest documented within-person reversal. On the Redis Array type (news/164, fetched verbatim):

“In the first month I just wrote the specification document… I started writing for days a long specification by hand, then I paired with Opus initially, then GPT 5.3 was released and I switched all the design and development with Codex. Since then I use only GPT 5.x for system programming tasks.”

The same post contains the cohort’s cleanest self-measured leverage line:

“even before LLMs the implementation was likely something I could do in four months. What changed is that in the same time span, I was able to do a lot more.”

Direct evidence of the output: PR #15162, “Implement the new Redis Array type” — created 2026-05-04, merged 2026-05-13, +22,258/−39 lines across 86 files (GitHub API). He notes honestly that acceptance was pending at writing time: “I hope the Array PR will be accepted soon” (news/164).

May 2026 — the extreme datapoint: DS4, “DeepSeek 4 Flash and PRO local inference engine for Metal, CUDA and ROCm” — repository created 2026-05-06, C, MIT, 22,605 stars / 2,163 forks by fetch time (GitHub API): “you can’t build DS4 in one week — and even with all this help you need to know how to gently talk to LLMs”; “I worked 14 hours per day on average. My normal average is 4/6” (news/165).

And then the doctrine completes its arc — he is now building agent tooling himself: an agent for DS4 with a redesigned EDIT tool (news/166, index), and an “agent as QA engineer” markdown harness running distributed-inference checks across two MacBooks over SSH, including day-long simulated multi-user runs of the Array type — “completing projects that may take many months in a few weeks” (news/168). A Z80/ZX Spectrum emulator came “with Claude Code” (post title, index). No MCP usage appears anywhere in the fetched record.

The AI stack, as evidenced (template Section 6)

Unit of work (template Section 7)

The largest unit he comfortably delegates, with dates:

• July 2025: partial code “under your clear specifications” — function-to- module scale, hand-moved, hand-reviewed. Nothing larger; agents rejected outright (news/154).
• 2026: whole data-structure development — spec, design, implementation, testing — delegated to Codex under a hand-written specification, with him reviewing (“constantly reviewing the developed code”, news/164). The largest delegated artifact is a 22,258-line data-structure implementation across 86 files.

The retained boundary is explicit: the specification and the design decisions are hand-written (“In the first month I just wrote the specification document… for days”) and he read the generated core “line by line” before trusting it (news/164).

Bottleneck migration (template Section 8)

• Before AI (his own account): implementation capacity. The Array post is explicit: “even before LLMs the implementation was likely something I could do in four months. What changed is that in the same time span, I was able to do a lot more” (news/164).
• After AI: implementation capacity stops being the constraint; what he names instead is loop control and verification: the manifesto is a manual for staying in the loop (“this guarantees that you follow every process”), and the 2026 posts are dominated by testing — “massive testing”, agent QA, day-long simulated runs, stress testing (news/164, news/168).
• His July 2025 formulation of the risk of the new bottleneck: agents “left alone with nontrivial goals… tend to produce fragile code bases that are larger than needed, complex, full of local minima choices, suboptimal in many ways” (news/154) — the same failure DHH documented at Basecamp 5, named a year earlier by a solo developer.

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

Stopped (documented): hand-writing the implementation of his data structures — the Array code and DS4 engine are AI-written under his spec; he states the four-months-of-his-own-time baseline explicitly (news/164, news/165).

Refusals to delegate: the specification (“I started writing for days a long specification by hand”), the initial algorithm design (he proposed the XOR-accumulator + murmur-128 reciprocity check; Gemini only evaluated it — news/153), and creative work (“I didn’t let Claude write a single line of the story or the plot” — news/144).

Started, mapped to the template’s categories:

• B Specification — the month-long hand-written spec document as the control surface (news/164).
• C Agent supervision / F Evaluation — “agent as QA engineer” harnesses, simulated multi-user runs, distributed checks (news/168).
• D Harness engineering — his own agent for DS4, EDIT-tool redesign, ARGREP as a skills knowledge base (news/166, news/164).
• H Product experimentation — throwaway-code exploration, documented as a formal use case in the manifesto (news/154).
• I Domain expansion — 68000 assembly for an Amiga demo, a Z80 emulator, a quantized local inference engine for Metal/CUDA/ROCm (news/154, index, news/165).
• Local-model infrastructure — he built the inference engine for the models he runs (DS4, DwarfStar) — a category no other cohort member reaches: he agent-built the tooling that serves him the agents’ own models.

Identity after AI (template Section 11)

Working classification (interpretation, labeled as such): Type A — still programmer, with an unusual property: he says so explicitly and repeatedly. “You are still the coder, but augmented” (news/154) is an identity claim, not a workflow note. His January 2026 statement is the cohort’s most direct: “I love writing software, line by line… facts are facts, and AI is going to change programming forever” (news/158, index). The H4-relevant piece of his identity is in his February 2026 post: “automatic programming produces vastly different results… depending on the human… guiding the process with their intuition, design, continuous steering” and — the cohort’s sharpest line — “Programming is now automatic, vision is not (yet)” (news/159).

Spectrum position (template Section 12) — the branch that moved

This case is the cohort’s demonstration that the spectrum is not a personality trait but a position that can move. The same person wrote:

• July 2025: “don’t use agents or things like editor with integrated coding agents… Avoid any RAG… moving code by hand from your terminal to the LLM web interface” (news/154).
• 2026: “I switched all the design and development with Codex. Since then I use only GPT 5.x for system programming tasks” (news/164), plus self-built agent tooling and agent QA harnesses (news/166, news/168).

The manifesto itself predicted the move’s trigger — “From time to time, it is wise to test what agents can do… When this will be true, that agents will perform superb work, I’ll be the first to switch” (news/154) — and the record shows the condition being met on his own terms. The anti-hype guardrail in his own words: “let’s skip the hype, and use AI at its best, that is: retaining control… There is another risk, however: of avoiding LLMs for some ideological or psychological refusal” — “Maybe this is really a case of ‘In medio stat virtus’” (news/154).

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

• Measured (GitHub API, fetched): Array PR #15162 merged 2026-05-13, +22,258/−39 lines, 86 files; DS4 repo created 2026-05-06 with 22,605 stars / 2,163 forks by fetch; redis/redis created 2009-03-21 (api.github.com).
• Self-reported, labeled: “I often do more work because of AI, but I do better work” (news/144); “I ventured to a level of complexity that I would have otherwise skipped” (the super-directory design he says he’d have skipped without the AI safety net — news/164); “completing projects that may take many months in a few weeks” (news/168); DS4 in one week at 14 h/day (news/165).
• Shipped across 2025–2026: Vector Sets (merged ≈2025-04-04 per the index), the Array PR, DS4/DwarfStar, agent-QA methodology, a YouTube “Automatic programming” series (news/159).
• Not measured: pre/post-AI commit-level sampling was not performed in either run — flagged as the case’s main quantitative gap.

The template’s question — did AI increase the output frontier of exceptional programmers? — gets its most literal yes in this cohort here: the same person, the same four-month time span, “a lot more” shipped, with measured artifacts on GitHub to anchor the claim.

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

Strong-programmer row, high-adoption column: the “AI-amplified master” cell — but with the cohort’s most explicit statement of why the amplification works: “the maximum quality of work is reached using the human+LLM equation… if such humans have extensive communication capabilities and LLM experiences: the ability to communicate efficiently is a key factor” (news/154). Amplification, in his account, is gated by a skill the template’s H4 calls taste-plus-communication, not by delegation capacity.

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

Labeled as a construct, not a metric. His case gives it a concrete form: the spec was written “for days” by hand before any AI touched the design, and his 2026 review doctrine is that when you own the ideas, code review becomes “suboptimal and often pointless” — what matters is an LLM-written DESIGN.md per data structure (news/169). The ratio shifted for him not by writing less judgment, but by spending the same judgment further upstream — at the specification, where the 22,258-line implementation is then “automatic programming” (news/159).

The unchanged core (template Section 16)

1. The spec is the product. “To write the initial huge specification was the key to the successive work” (news/164) — the discipline that made Basecamp-on-10-hours-per-week work in the DHH case appears here as a month of hand-written design documents.
2. Taste owns the ideas. “Great use of AI is not making machines do what you can do better” (news/144); “the creativity of humans still have an edge” (news/153); “Programming is now automatic, vision is not (yet)” (news/159).
3. C over Python, unchanged: “C code tends to be, in my experience, much better” (news/154) — the systems-programmer identity survived the tooling change; what changed is that he now ships C at a scale he otherwise wouldn’t attempt solo.
4. Simplicity as the quality bar — his review standard for agent output is minimalism: “the sharpest code possible: minimal when needed, using complex ideas when required” (news/154).

The template’s warning holds here with a twist: the hype risk in this case is not over-adoption but the speed of the reversal — the same person who formulated the strictest anti-agent doctrine in July 2025 was running his own agents by mid-2026. His own writing anticipated the objection (“In medio stat virtus”) and answered it: refusing tools ideologically is also a failure mode.

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

• H1 (great programmers become super-programmers) — Supported, with measured artifacts. Evidence for: “I often do more work because of AI, but I do better work” (news/144); “I ventured to a level of complexity that I would have otherwise skipped” (news/164); DS4 built in one week (news/165). Against: the amplification is attributed by him to the human+LLM equation, not to personal skill — and no against-evidence was found in fetched sources. Supported in this case.
• H2 (programming moves upward) — Supported with a documented exception. Spec-first, “Control the ideas, not the code”, QA emphasis, DESIGN.md over review — all upward movement (news/164, news/169). Against: he still line-reads core files and still calls himself “still the coder, but augmented” (news/154) — he did not vacate the code layer, he re-weighted it. Supported, boundary intact.
• H3 (more specialized, not less) — Strongly supported. HNSW reimplementation, an LLM sampling algorithm, a quantized local inference engine, a Z80 emulator — harder systems problems, not PM work (dossier). Against: none found in fetched sources.
• H4 (taste + orchestration is the scarce skill) — Supported, with the sharpest formulation in the cohort. His own version: “Programming is now automatic, vision is not (yet)” (news/159). He builds orchestration tooling (agent QA, EDIT-tool agent) — but as a tool he picks up and puts down: “each time you feel they can’t do as well as you can, return to your terminal” (news/154). Taste is the identity; orchestration is an instrument.

Gaps and what would change this picture

• 2023 is documented only retrospectively (“Since the advent of ChatGPT…”); no 2023-dated primary post was found in the fetched index slices.
• No commit-level pre/post-AI code sampling (template Section 5) was performed in either run; the numbers used are repo/PR-level facts.
• The Array PR’s real-world acceptance was pending at the time of his post (“I hope the Array PR will be accepted soon” — news/164); the merge itself is verified, downstream adoption is not measured.
• The Changelog Interviews #631 episode (2025-03-07, listed topics include “AI and vector embeddings in Redis, and… LLM inference” — listing) was not transcribed in either run.
• “Formal methods and the future of programming” and any attribution of “The Little Redis Book” to him: not found in fetched sources — stated as non-findings.
• This is one case; the cross-case matrix needs the full cohort.

Five cases, one spectrum (contrast coda, interpretation)

(Hejlsberg and Carmack columns reflect their published cases in this series.)

The antirez cell is the one the template predicted least: a solo systems craftsman who wrote the strictest anti-agent doctrine in the cohort — and then upgraded it within months, on his own stated condition, while keeping every control point that doctrine was protecting. Where DHH delegated problems and Torvalds delegated nothing, Sanfilippo delegated implementation under a hand-written specification — and measured the result in merged lines and star counts.

Interpretation

This case suggests that — and this paragraph is our interpretation, not a sourced fact — the real unit of adoption for a taste-first programmer is not the tool but the contract: what the human agrees to produce by hand versus what the machine may produce under that contract. Sanfilippo’s July 2025 doctrine and his 2026 practice are the same contract at two different prices. The contract’s clauses never changed — he writes the specification, he owns the ideas, he verifies — what changed was the market rate for the implementation layer, and he repriced it the moment the agents cleared his bar, exactly as he had pre-committed (“I’ll be the first to switch”). His pre-2023 comparative advantage — design taste under constraint — did not move upward or sideways; it moved upstream, into the artifact that now does the governing: the specification. The cohort pattern so far is consistent: the people who made their reputation by deciding what good software is (Rails, kernel merges, Redis data structures) are the ones who convert AI throughput into scope without losing the taste layer — and the specification, not the prompt, is where they keep it.

Sources

Fetched during the run on 2026-09-21 (dossier run and writing run; the two most load-bearing posts were re-fetched and verified verbatim during writing):

Primary — his own blog (self-report layer; post dates are derivations from “N days ago” counters anchored to 2026-09-21, two cross-checked exactly):

• antirez.com/news/154 — “Coding with LLMs in the summer of 2025 (an update)” — the manifesto: amplifiers-not-one-man-bands, the five uses, “Refuse vibe coding most of the times”, Gemini 2.5 PRO pick, no-agents/no-RAG/hand-move doctrine, “You are still the coder, but augmented”, “return to your terminal”, “In medio stat virtus”. Re-fetched verbatim this session.
• antirez.com/news/164 — “Redis array type: short story of a long development” — January 2026 start, spec-by-hand, Opus→Codex switch, “I use only GPT 5.x for system programming tasks”, line-by-line review, super-directory design, ARGREP/TRE, “massive testing, thanks, again to AI”. Re-fetched verbatim this session.
• antirez.com/news/140 — “LLMs and Programming in the first days of 2024” — C-vs-Python boundary, local models, “expert in system programming”.
• antirez.com/news/144 — “From where I left” — Redis return, Claude as partner, “more work… better work”, fiction boundary.
• antirez.com/news/153 — “Human coders are still better than LLMs” — human-creativity edge, Gemini as “smart duck” verifier, XOR-accumulator design ownership, fuzzers.
• antirez.com/news/157 — end-2025 web-interface interaction.
• antirez.com/news/159 — “Automatic programming” — “Programming is now automatic, vision is not (yet)”; steering intuition.
• antirez.com/news/165 — DS4: one week, 14 hours/day, “gently talk to LLMs”.
• antirez.com/news/168 — “A new era for software testing” — agent QA harness, two-MacBook distributed checks, months→weeks.
• antirez.com/news/169 — “Control the ideas, not the code” — review doctrine, DESIGN.md, DwarfStar, “Fable and GPT 5.6 Sol”.
• antirez.com/latest/0, latest/1, latest/26 — blog index slices covering 2015→2026 titles/excerpts (Vector Sets ≈2025-04-04, news/158–172, 2024 posts, Disque RC1, departure post, Wohpe).

Direct layer (GitHub API, fetched):

• api.github.com/users/antirez — identity, born 1977, 109 public repos, account created 2009-03-21.
• api.github.com/repos/redis/redis/pulls/15162 — Array PR: created 2026-05-04, merged 2026-05-13, +22,258/−39, 86 files; redis/redis repo creation date.
• api.github.com/repos/antirez/ds4 — DS4: created 2026-05-06, C, MIT, 22,605 stars / 2,163 forks, pushed 2026-09-20.
• api.github.com/repos/antirez/disque — Disque: created 2015-04-27, 8,073 stars.

External / vendor layer:

• redis.io/blog/welcome-back-to-redis-antirez.md — company republication of his return post (published 2024-12-10, by Rowan Trollope); “evangelist” role; “built Redis in 2009… until 2020” [vendor claim].
• changelog.com/news/antirez-returns-to-redis-DVO6 — Changelog Interviews #631 (2025-03-07) listing AI/vector/LLM-inference topics; episode not transcribed this session.

Not found in fetched sources (stated as non-findings, never filled with plausible content): any 2023-dated primary post; the “Formal methods and the future of programming” post; any attribution of “The Little Redis Book” to Sanfilippo.

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, a labeled vendor claim, a labeled derivation, or labeled interpretation. Quotes for news/154 and news/164 were re-verified verbatim during the writing pass; all other quotes were verified on fetched pages in the same-day dossier run. Nothing in this note was recalled from model memory without a fetched source.