Shooting a Still Bird
A Tracery-based generative text project producing pages of a somewhat infinite book from a personal lexical corpus. Each page is unique: two to fifteen lines drawn from thirteen syntactic templates and twenty-odd lexical pools, displayed on a cream background in monospace type and navigated by a “Next Page” button. The reader’s navigation constitutes the text rather than merely receiving it.
Open the Project · View Tracery Grammar
Reflection: Yet Another Iteration
I want to be upfront that this project went through three distinct phases before what I am sharing here, and the frustrations have been as instructive as the outcome.
I have some initial experience with Tracery (see the auto-Glenn project), so I felt comfortable with an initial concept that was ambitious in a way that quickly proved to outpace my ability. I wanted the grammar to function cinematically — each generated page prefaced by an aspect ratio label, a frame condition drawn from cinema history: 1.33:1, 1.66:1, 2.35:1, 2.76:1. The ratio would function the way a lens functions: not determining what you see, but determining how much of it, and from what distance. I built a setLens mechanism following Compton’s setPronouns pattern, where a push action would assign both the ratio and the syntactic template to variables that a line symbol would then format with HTML. It looked right. It failed completely. The output was ((lens)) and ((page)) — unresolved variables, red in the editor, the grammar refusing to evaluate. What I eventually diagnosed, after several iterations, was that nested # characters inside inline push actions were confusing the parser when loaded in the browser. The variables were being assigned but not resolved in the context where line was called. The Tracery editor showed the structure correctly — origin flowing to line, lens and page as distinct nodes — but the output was empty in the preview panel.
Rather than keep debugging that architecture, I made a pivot I hadn’t anticipated: I built a Combatwoundedveteran song title generator as a stepping stone. The reasoning was practical — a single-line output with no variable dependencies would let me confirm that my JSON was syntactically sound and that I understood the template mechanism before returning to the more complex project. CWV’s discography turned out to be a rich corpus for this: imperative constructions, colon-definition titles, body-part inventories, commodity logic, absurdist proper noun combinations — “Eat More Blood Money,” “My Spine! My Spine! My Spine!,” “Operation: Head Superimposed.” These titles already operate as procedural templates. Running the generator at scale confirmed that the JSON structure was sound and that the combinatorial variety I wanted was achievable.
That confirmation let me return to Shooting a Still Bird with the simpler architecture the project actually needed. The grammar functioning in the editor produced results like: “iron: the facade seeps to the foundation of the study,” “the weight of the fabric is responsible,” “fix your left finger — a relic — into the dirt,” “opulence is but a lingering fixture.” The templates are doing what I wanted them to do. The corpus is recognizably itself.
The final page — cream background, monospace font, two to fifteen lines per load, a “Next Page” button — produces a somewhat infinite book. Each click generates a configuration that has never existed before and will never exist again. This is akin to the form Queneau’s Cent Mille Milliards de Poèmes discovered in 1961: the combinatorial book engineered so that the reader’s navigation is constitutive of the text rather than merely receptive to it. Queneau cut the pages of his sonnets into fourteen strips so that the reader’s combination produced the poem. The “Next Page” button does the same work at a different scale. The reader doesn’t choose what appears; they only enact something to appear.
This is where Abbate’s argument becomes directly relevant. The claim in “Coding is Not Empowerment” that I keep returning to is that the coding movement’s focus on skill acquisition “avoids culturally loaded questions about the purpose of software and the social goals it might serve” (312). The question Shooting a Still Bird is asking is not whether Tracery teaches coding — it does, minimally — but whether the mechanism is legible enough that a new user can understand not just the output but the procedure that produced it. The grammar is its own documentation. Someone reading the JSON can trace exactly how “sepia air occupies scabbed fabric” was produced: adjective_sensory drew “sepia,” noun_substance drew “air,” verb_contact drew “occupies,” adjective_surface drew “scabbed,” noun_covering drew “fabric.” The mechanism is inspectable, modifiable, transferable. I connect this to what Johnson and Salter mean by procedural literacy as critical practice — not the ability to code, but the ability to read a procedure and understand what assumptions are baked into it.
Corporate generative AI inverts this. It lowers the barrier to output while raising the barrier to understanding. Anyone can prompt a language model but almost no one can inspect what it does. Tracery lowers the barrier to understanding at the cost of a slightly higher barrier to output, and Compton’s scaffolded documentation makes that tradeoff explicit and navigable. The grammar I built here, with its thirteen syntactic templates and twenty-odd lexical pools drawn entirely from my own corpus, could be handed to someone else. The reader who clicks “Next Page” is appropriating a text produced by a procedure they could, with sufficient documentation, reproduce. The reader of a ChatGPT output has no such access.
This project is also preparation for something larger. NaNoGenMo — the generative variant of National Novel Writing Month — requires participants to share not just a novel of 50,000 words but the source code that produced it. The open-source requirement is constitutive, not incidental. The tradition already understands that sharing the grammar is the scholarly act. Shooting a Still Bird as it currently exists is a proof of concept for a NaNoGenMo contribution that would expand this grammar to novel scale, drawing on the full corpus, with the source code shared as the primary theoretical object. This exercise has been the conceptual preparation for that work — learning what the templates can do, where the pools need expansion, how the reader’s navigation produces the text.
Abbate’s conclusion is blunt: “coding by itself is not empowerment” (328). The response this project makes is not to disagree but to insist on a distinction. Transparent tools with legible documentation create conditions for appropriation that opaque corporate infrastructure forecloses. The grammar is a small, legible, transferable counter-example.