Howdy, Stranger!
It looks like you're new here. If you want to get involved, click one of these buttons!
Categories
In this Discussion
Week 2: AI Sprint: Vibe Coding Strachey's Love Letter Generator (1952)
The Exercise
This week we're running a collaborative exercise to try vibe coding for yourself and reflect on the experience. Rather than an abstract prompt, we're working with a specific historical object which is Christopher Strachey's Love Letter Generator from 1952.
Christopher Strachey (1916-1975) stands as one of the key figures whose work we now recognise as a foundational transitions in computational culture. The Stracheys belonged to the Bloomsbury Group, the group of intellectuals including Virginia Woolf, John Maynard Keynes and Strachey's uncle Lytton Strachey, which makes his later computational work all the more interesting for crossing of cultural and technical domains.
He was a pioneer in programming language design and denotational semantics, Strachey programmed the first computer music in England in 1951, rendering the National Anthem on Manchester's Ferranti Mark 1, followed by recordings of "Baa, Baa, Black Sheep" and "In the Mood" captured by the BBC. More significant still, in 1952 he created a love letter generator for the same machine that represents the first known instance of computer-generated literature, a development that prefigures contemporary anxieties about LLMs whilst also gesturing towards the literary experimentalism of his milieu.
His later development of time-sharing concepts in 1959 points to the infrastructural transformations that enable the distributed computational environments we now inhabit. What makes Strachey's life so fascinating is how it demonstrates the convergence of cultural, technical and literary spheres, collapsing distinctions that are difficult to cross over, even today.
The (literary) significance of the Love Letter Generator extends beyond its curiosity as an early version of computational culture. It seems to be a parody of one of literature's most codified genres, the love letter. It contains conventional declarations, expected rhythms of longing and affirmation, etc.. Strachey's algorithm (which sadly we seem to have lost) might be what the Russian Formalists would call a device of amatory writing, revealing the "templates" that structure even our most intimate texts. The generator's outputs read either as both sincere and satirical, occupy the same uncomfortable space as Oulipian constraint-based writing or Burroughs's cut-ups, which would emerge a decade later. The fact that Strachey drew his vocabulary from Roget's Thesaurus, shows fascinating connections to the idea of a systematisation of language. Perhaps this deepens the irony as the love letter, supposedly a singularity of expression, is revealed as a combinatorial operation on an inherited lexical dictionary. This might make us think of the generator not just as an engineering experiment but as a work of literary theory made executable, a machine for demonstrating that romantic discourse, like all discourse, is structured by rules that precede and exceed the speaking subject.
Your task: use an LLM to create your own version of the Love Letter Generator, then document what happens.
You can use our new CCS workbench or any other LLM to help co-create it
Why Strachey?
The Love Letter Generator is arguably the perfect historical antecedent for vibe coding. Written for the Manchester Mark 1, Strachey's algorithm generates "love letters" by filling sentence templates with words randomly selected from lists compiled from Roget's Thesaurus. The original code is lost, but the algorithm has been reimplemented many times.
A sample output:
DARLING SWEETHEART
YOU ARE MY AVID FELLOW FEELING. MY AFFECTION CURIOUSLY CLINGS TO YOUR PASSIONATE WISH. MY LIKING YEARNS FOR YOUR HEART. YOU ARE MY WISTFUL SYMPATHY: MY TENDER LIKING.
YOURS BEAUTIFULLY
M. U. C.
This raises the follwing questions:
The letters are grammatically correct, emotionally legible, yet produced without actual understanding. Strachey noted his interest in how "a rather simple trick" could produce "an illusion that the computer is thinking", anticipating both the ELIZA effect and what I'm calling elsewhere the "competence effect," but for text generation rather than dialogue.
Who wrote these letters? Strachey? The machine? Roget (whose Thesaurus supplied the vocabulary)? This question of distributed authorship maps directly onto vibe coding's triadic hermeneutic structure.
Both Strachey and Turing were gay men working during the 1952 prosecutions. Jacob Gaboury reads the generator as "pure camp", as an exultant love of the artificial. The gender-neutral, anonymous letters can be read as a quiet act of resistance.
There was a Code Critique thread on the Strachey Love Letter Algorithm at the 2024 CCSWG, proposed by Titaÿna Kauffmann. Key questions included: How is reimplementation a reinterpretation? What does it tell us about the legacy and "reborn-digital" heritage of Strachey? How can we "queer" this narrative through CCS? This questions remain (even more) relevant to vibe coding.
The Sprint Structure
Days 1-2: Vibe code your generator
Choose an LLM (Claude, ChatGPT, Gemini, Copilot, the CCS workbench or whatever you have access to) and prompt it to create a Love Letter Generator. You might, for example,
- Ask it to recreate Strachey's original algorithm
- Ask for a "love letter generator" without mentioning Strachey
- Share Montfort's reimplementation and ask for modifications
- Try different approaches and see what emerges
- Remember to keep your prompt history. This becomes a primary text for critical reading.
Days 2-4: Document the cognitive modes
As you work, you might want to pay attention to, for example,
- Cognitive delegation: Where did you offload judgment to the LLM? Did it lead you down unproductive paths?
- Productive augmentation: Where did human architectural control combine effectively with machine implementation?
- Cognitive overhead: Did managing the LLM's context or correcting its assumptions take you significant effort?
Note any moments where the "competence effect" appeared, which is where the LLM's output looked ok but was subtly wrong, or where its apparent understanding masked a deeper misunderstanding.
Days 2-7: Share and compare
Post your reflections to this thread (and the code if it is short enough - consider using the "Spoilers" tag to make the post manageable by others.
- Does your LLM's version resemble Strachey's structure, or does it "improve" it?
- What did the LLM add or subtract?
- Is the output a reimplementation of Strachey, of Montfort's reimplementation, or of the concept of a love letter generator?
- How do we read the differences critically?
- What does your prompt history reveal about the distribution of agency?
Resources
Strachey's Algorithm
- Nick Montfort's Python reimplementation: https://nickm.com/memslam/love_letters.py
- Interactive version: https://www.gingerbeardman.com/loveletter/
- Wikipedia: https://en.wikipedia.org/wiki/Strachey_love_letter_algorithm
- David Link's Manchester Mark 1 emulator reconstruction: https://alpha60.de/art/love_letters/
- Previous CCSWG thread: https://wg.criticalcodestudies.com/index.php?p=/discussion/152/code-critique-strachey-love-letter-algorithm-thread
- The Critical Code Studies workbench, which allows you to create code within the tool, https://wg.criticalcodestudies.com/index.php?p=/discussion/205/critical-code-studies-workbench
The Core Love Letter Logic
The algorithm is remarkably simple. From Montfort's reimplementation:
def longer():
return (
' My'
+ maybe(adjectives)
+ ' '
+ choice(nouns)
+ maybe(adverbs)
+ ' '
+ choice(verbs)
+ ' your'
+ maybe(adjectives)
+ ' '
+ choice(nouns)
+ '.'
)
def shorter():
return ' ' + choice(adjectives) + ' ' + choice(nouns) + '.'
It contains a template plus word lists. It can be understood quickly and reimplemented in any language, and which makes it ideal for observing what LLMs do when asked to recreate it.
Critical Reading
- JSTOR Daily: "The Love Letter Generator That Foretold ChatGPT": https://daily.jstor.org/the-love-letter-generator-that-foretold-chatgpt/
- Paul Curzon's description from the Wayback Machine.
- Gaboury, J. (2013) ‘On Uncomputable Numbers: The Origins of a Queer Computing’, Media-N: Journal of the New Media Caucus [Preprint]. Available at: https://median.newmediacaucus.org/caa-conference-edition-2013/on-uncomputable-numbers-the-origins-of-a-queer-computing/
Vibe Coding Discussion
This exercise lets us examine several questions
- When an LLM "reimplements" Strachey's code, what is it actually doing? Is it reading Montfort's version? Training data that includes discussions of the algorithm? The concept filtered through countless blog posts?
- Does your LLM produce something that looks like Strachey's generator but operates differently? How would you know?
- From Strachey (1952) to ELIZA (1966) to vibe coding (2025) can we trace how the "competence effect" intensifies as systems become more capable while remaining equally lacking in understanding. Does your experience of vibe coding confirm or question this genealogy?
- What would it mean to do critical code studies on the vibe coding session itself, including the prompts, the iterations, the failures, rather than on the resulting code?
- If Strachey's generator produces grammatically correct, emotionally legible love letters through pure combinatorics, what does this suggest about the relationship between literary form and authentic expression? Does the generator parody the love letter, or does it reveal something already present in the genre?
- Given the Bloomsbury Group's preoccupation with sincerity, intimacy, and the limits of language, particularly in figures like Virginia Woolf and Lytton Strachey, how might we read Christopher Strachey's generator as continuous with rather than discontinuous from that literary project?
I'll post my own attempt and reflections partway through the week. Looking forward to seeing what emerges and post your experiences below.
Comments
Here is my version, the Visible Love Generator (after Strachey, 1952) which reimplements the idea in a version that foregrounds the generator's status as literary theory made executable. The program displays the template structure with numbered blank slots, then populates each slot as you press Enter, allowing you to experience the combinatorial process as it unfolds.
Full code version here
Post yours below, with screenshots if possible (note if the code is long then it makes sense to post only code fragments or a link to a Gist or similar place.
Who needs code?
https://claude.ai/share/68cd09c8-9576-4188-9fc4-b3438594eda3
I decided to implement it in Inform7 as I felt I'd be best equipped to understand any errors it was throwing up. (Tracery would have allowed for a much more elegant way of implementing this, but I only thought of that after I had started on the process.) I sent the following prompt to ChatGPT:
And this was the output:
When I saw this first implementation it suggested, I knew right away that it wouldn't work. I tried it, and it gave an initial error about the table having an invalid name. Once that was fixed, it gave a load more errors because neither way it was trying to look up random entries in tables was how it works. If I didn't know anything about Inform, at this point I could see how it could be quite frustrating to get this to work through this method. And so, thinking about how I would implement this from scratch, I prompted it to try the sort of approach I would try:
The method with "to say" was the most simple approach and was similar to how I would have written it from scratch. The code compiled with only some minor blank space issues that were easy to fix. The output was as expected.
Finally, to make it more interesting, and to see if it could handle the request, I prompted:
It managed a serviceable job. I fixed some issues: "pea-green boat" was a noun and "pea-green" an adjective, so "pea-green pea-green boat" as a possible output, as was "bong-tree bong-tree". I also changed the generation to happen on the room description rather than the game start, so it could be refreshed indefinitely without restarting. Here is the final code:
This is what it outputs:
Overall, this implementation is worse than Strachey's original, with less variation. With about three times as many items for grammar lists we could start to avoid the more obvious repetitions. If I'd been making this from scratch, I would have varied the sentence structures somewhat to disguise the template, as I do with my generative text bots. To answer the question @jshrager posed, "who needs code", the value in hand coding a generative text bot is that you can have control over the possibility space, allowing for greater artistry.
@JoeyJones I agree that there settings where code is needed, but I don't think that this is one of them -- or, well, it depends on how you interpret the assignment. One of my students is working on how bad LLMs are at math. We have a catch phrase that we think would make a great paper title: "Don't let the parrot land the plane." -- less eloquently, when you need correct, use correct code; when you need creative, let the llm do it's thing. The assignment here was pretty vague: "Use an LLM to create your own version of the Love Letter Generator, then document what happens." @davidmberry gave me the out with the phase "your own version", writing love letters is pretty much one of the core fortes of LLMs*, so it's a bit of a shame to not let me "land the date", so to speak.
(* In talks, I often claim [mostly to be controversial] that LLMs are good at the five "P"s that are the standard fare of the web: Politics (people yelling at one another), Products (advertising, etc), Pubmed (which is a stand-in for factoids, as from Pubmed or Wikipedia, etc), Programming (because it's essentially a linguistic skill), and the fifth "P" you can, I'm sure, fill in for yourself, and is the one most relevant to the task at hand! .... since this is an international forum, and this might not be obvious unless you're a native English speaker, I'll give away my punchline: The fifth P that LLMs are good at is "Porn" :-)
All my academic complaining aside, I did actually do the project as intended, sort of:
I think you're right, it does depend on how you interpret the assignment. I can use an LLM to generate something interesting and amusing, but I can't get it to generate anything I would be artistically proud of because it isn't my own creation. Spending a short time with Tracery, I was able to make my own variation of Nick Montfort's implementation with considerably more cross-fertilisation of the word lists:
So with no additionally vocabulary, with a more creative hand-crafted approach I was able to improve the variability and ardour of the love letters:
It can be pasted into a browser-based tracery editor to render such output as:
To me, as a longtime creator of these kinds of "art bots" or creative text generators, this was a more satisfying kind of generation than anything that could be accomplished through either vibecoding or LLM generation.
I worked with the web interface to ChatGPT to vibe-code a p5.js animated and interactive web-based Love Letter Generator. Here was the result:
Note that you can edit it / fork it live in the p5js.org web editor: https://editor.p5js.org/jeremydouglass/full/2hWivqunL
When I originally looked at this challenge, I first tried a twist on my normal path -- I consulted with a web-based LLM on how to plan a spec-driven exploration of writing a Strachey Love Letter Generator in p5.js, then had it write files (e.g. an AGENTS file and a set of development tasks) with the plan of provisioning a local environment and letting the agent get to work).
This looked interesting (having one LLM plan without being able to execute, and another execute with a fixed plan), but it was not very "vibe-y."
For my second attempt, I tried to have the AI code "blind." Rather than using e.g. Claude.ai web based projects / artifacts or a local setup with testing and feedback (e.g. node/vite/etc.) I fired up a ChatGPT web session (not a project!) and had it just chat code back and forth -- first in entire programs, then entire functions, then patches, until the code because a distant memory or rumor, and it started patching speculatively.
One interesting component of the initial prompt was that I pointed my web-based agent directly at this discussion thread as the context, and, rather than engaging in a lengthy planning conversation, instructed it to plan and produce something immediately.
This had two immediate impacts. First, the vibe entire coding session involved constant callbacks to the goals and methodology of CCS. Second, the initial sketch was almost entirely an animated p5.js Javascript clone of David Berry's Visible Love Generator example, including bracket-numbered placeholders [1] [2] [3] ... that are stepped through interactively.
Some early features (such as a swappable "camp" lexicon) were interesting but underdeveloped. In an interactive session I iterated with the agent -- on text and image export, randomization, controls and credits, reproducibility from RNG seeds, text layout, et cetera. Some of the transcript was interestingly reflexive onto the subject of CCS approaches to Strachey's work. Most represented a slow descent away from "vibes" as the session got further into the weeds implementing e.g. the specifics of printing credits in three different layout engines (html DOM, p5.js, and TXT). At the same time, the performance of the online chat degraded substantially as its program swelled towards 1000 lines, its descriptions of a multitude of patches to be applied caused the idea of a single source file to become less and less reconstructable from the transcript, and as the length of the transcript degraded the context window. Increasingly the LLM and the human are cutting and pasting at each other, like two blind people touching different parts of the same elephant (or like two people who are each in a different Searle's room, with one slot connecting them).
Notable features include mouse and keyboard interaction, plain text and screenshot output, hovering tooltips with the word set candidates for each slot, and reproducible seeds that are recorded in the outputs and may be set by the user.
At mid-cycle I asked the LLM to reflect on the process and outcome, and it wrote a very triumphalist evaluation of all the innovations in the still-nascent animated template sketch. I replied:
...to which the agent enthused that I was, once again, correct:
At the end I asked the LLM to reflect on the process in the context of this discussion.
It pushed back fairly strongly:
This is interesting. On the one hand, throughout the transcript the LLM proposes new features (often in the final 1-2 lines of a previous response as a follow-up suggestion), was told essentially "go ahead," and then later in summary attributed "my" features to my brilliance. On the other hand, it is correct that it was heavily steered.
After some negotiation it composed a fairly lengthy report, which I then asked it to summarize for us in a fairly prompt-engineer-y way:
It replied:
The final output gestures at some interesting ideas, and it gets the genre of writing roughly correct, including self-reflexivity, but it does so with little regard for the difference between mountains or molehills, and it approves, admires, and celebrates every outcome of the process. This may be something slightly distinct from the sycophancy problem: it produces the shape of critical language without being, in the most common use of the word, critical of anything.
@jeremydouglass this is super interesting and reminds me of the Bliss Attractor problem that Anthropic identified in relation to the systemic bias towards affirmative conversation.
I rather like your p5.js and makes me think that we should explore outside of the textual elements of the love letter generator and consider more visual and dynamic ways of rethinking it as an interesting experiment in poetry generation.