I. Formal structures

The referents of the contemporary English word prompt, etymologically rooted in borrowings from both Middle French prompt and Latin promptus, signifying readiness or immediacy, belong to a genealogy of media forms that structure human attention and mediate symbolic exchange.¹ Described in generalized terms, as a textual cue or directive designed to elicit a response, prompt represents a class of practices of writing, or perhaps a subclassed practice of writing, with common yet varying forms and purposes. In education, a prompt typically guides students in a writing task, shaping their thinking and engagement. In computing, the command prompt is the hinge, pivot, or point of contact in a text-based interface for programming and system interaction. In the realm of artificial intelligence, especially with large language model interfaces (hereafter LLMIs), the natural-language prompt is a medium through which humans program the model’s behavior in English or another language, rather than with various isolated commands, command syntaxes, or codes.

In this latter case, the medial function of the prompt, in combining the pedagogical context with the technical interface context of meaning, seems more expansive: it channels communication into pre-structured forms, generating an anticipatory logic that guides the response. On one hand, it is just another instance of interface minimalism, not substantially different than the shell or terminal command line that predates it by many decades: in other words, really quite anachronistic today. On the other hand, in the LLMI the prompt seems far more than that: a site of convergence of inscription with execution, of writing with code, where human articulation negotiates with statistical inference, an operational poetics that obfuscates the distinction between conversation and command. Here, prompting is constitutive, a soft programming in which the materiality and the vernacular expressivity of natural language, in all its plasticity as not code, is directed to elicit computed behavior.

It is worth examining each of these three branches, forks, or furcations of the prompt in turn, each in its specificity, while not losing sight of their contingent unity as a type of assemblage, a composite practice of writing that shapes learning, directs system operations, and guides ostensibly artificially intelligent agents, not always clearly separably. In the classroom, the prompt bridges teacher and student, translating pedagogical goals into a task that can spark (or squash) learning. In computing, the command prompt bridges human and machine, a point of contact that empowers users to execute operations through text. In AI, the prompt bridges user intent and model behavior, becoming a language of programming, if not a programming language. Historically, each domain developed its conventions for prompts: the essay question, the symbol and blinking caret awaiting input, the engineered query for a LLMI. In each case, a prompt must frame a context, whether it is a student’s mental framework for an essay or an AI model’s context window for processing a conversation. A prompt must also be interpretable, whether by a student meeting academic expectations, by an operating system parsing command syntax, or by a language model consulting its training on human language data. To what extent can we say that the LLMI prompt combines and integrates (at least some of) the features of its predecessors in the domains of pedagogy and user interface design? In other words, what aspects of pedagogically-focused and interface-focused prompting are subsumed and transformed by the natural language interface of a large language model? To what extent may we wish or not wish to regard that integration as a new composite practice of writing, amplifying both previous forms while retaining aspects of their functions and affordances? How do the historical precedents of prompting as a practice, beyond pedagogy and computing, inform our understanding of its current incarnation in LLMIs? What bearing might these various modes of prompting have on the relationship between human subjectivity and machine interaction, between teaching and code, between learning and execution, between (human) will and (machine) execution? Here and subsequently, we examine the LLMI prompt as a practice in three dimensions: its formal structures, its intertextual operations, and its situation in broader socio-technical contexts.

Pedagogy

In educational settings, a writing prompt is a directive for an assignment or exercise, usually in the form of a question or scenario that students respond to by writing. In contemporary composition theory, the assignment prompt is rightly regarded as a practice in its own right and a heuristic for shaping intellectual engagement. Yet nothing in this function of the prompt is automatic or self-apparent: writing prompts may carry implicit assumptions and disciplinary conventions that novices struggle to decipher, and what instructors believe are clear directions may seem to students obscure or ambiguous imperatives.² Prompts can also be understood as socially performative, positioning a student in the role of novice scholar, disciplinary apprentice, or full-fledged critical thinker, regardless of whether they are ready for that: and in so doing, shaping both the subjectivity and the content of student writing.³ Thus, the design of a prompt influences how students approach an assignment: in effect, the prompt frames the student’s task and even their identity as a writer, exerting rhetorical force by structuring the relationship of writer to reader and readership more generally.

In short, the prompt is not a neutral container of the assignment; rather, it is a shaping instrument of both the thinking and writing processes of composition and of the emergent text. Prompts grounded in conventional academic genres may, at least ideally, elicit formally polished responses, a reflection or a coercion of familiarity with normative discursive expectations in a specific context. Prompts that induce conceptual novelty or invite speculative reasoning, problem-solving, or imaginative projection may produce results of greater lexical diversity, thematic risk-taking, and deeper analytical engagement, perhaps at the expense of structural cohesion or mechanical accuracy. The orientation of a prompt also matters: reflective prompts may encourage elaboration and sustained revision, while future-oriented prompts may stimulate ideational originality and fluency. Again, all this suggests that the prompt in writing pedagogy is not neutral or ancillary but is an active, epistemic intervention.

By consensus, that intervention is ineffective if the prompt is not clear, meaning that the instructor’s writing of the prompt is in itself a normative exercise in composition. For better or worse, a recurring finding in pedagogical research is that clear and explicit prompts lead to better outcomes (from an instructor’s perspective) and that student engagement (from an instructor’s perspective) is elevated when students report (from a student’s perspective) that their assignments have clear instructions and explained purposes.⁴ Naturally, many assignments fall short of the mandate of clarity, though this tells us that the consensus in pedagogical scholarship is not exactly that. One study has suggested that the imperative to be clear “is one that puzzles many teachers in the disciplines, either because they feel they are [already] being clear or because they feel that excessive clarity will ‘spoon-feed’ students rather than presenting them with a desired intellectual challenge.”⁵ While the present essay is not a study of pedagogical scholarship, we might say as an aside that, if clarity is not actually the most effective criterion, one might resort to a broader principle of computing usage, applicable to the most highly inexpert consumer users as much as to the most sophisticated software engineers. Discussed below, that principle is “garbage in, garbage out,” or: the quality of the prompt-input correlates roughly with the quality of the result.

Programming

Today programming a computer, meaning writing program code destined for execution in the form of script or an application, can be clearly distinguished from using a computer in all kinds of other ways. Still, as late as the first generation of mass-marketed pre-assembled desktop personal computers introduced in 1977, programming using a text-based command-line interface (hereafter CLI) was how one used a computer, at least initially. While they could be booted into applications or games from disk storage, the first models of the Commodore PET, Apple II, and Tandy TRS-80 all started by default in an interactive interpreter for the BASIC programming language, which was encoded in system ROM (read-only memory).⁶ The distinction between programming and other usage acquired its clarity only gradually, in the course of the process called softwarization, the design and development of applications for specific purposes such as word processing, spreadsheet calculation, and database management.⁷

Computing in the 1950s was largely batch-oriented and non-interactive, but the development of time-sharing operating systems in the early 1960s introduced terminals enabling direct, real-time interaction with the computer. In computing the command prompt, a symbol or text string indicating that a computer is ready to receive input in a CLI, dates to early systems that used teletypewriters, paper-printing terminals, or video terminals connected to mainframe systems. Systems such as MIT’s Compatible Time-Sharing System incorporated command-line interpreters that signaled readiness for input through prompts.⁸ The Unix operating system developed in the 1970s was particularly influential, introducing the concept of a shell as an interface layer for sending commands to the computer via a prompt.⁹ By the 1970s and 1980s, CLI prompts, represented by symbols like $ in Unix or C:\> in MS-DOS, had become standard across minicomputers and personal computers, and they have persisted through the entire history of the graphical user interface (hereafter GUI) that emerged in the 1990s as a consumer paradigm, indeed an episteme, structuring how computing is understood. Today, CLIs and their blinking-caret prompts (discussed below) remain indispensable to software engineers, system administrators, and IT professionals of all stripes,¹⁰ and consumer operating systems continue to support robust CLIs like Windows PowerShell and the Unix-like Terminal in macOS. At the prompt, whose caret or cursor element signals its readiness, a user types text representing operating system commands, plus optional flags (which alter behavior) and arguments (data the command acts on).

The design of early command-line systems was guided by principles focused on interactive request-response transactions with low latency, allowing users to receive rapid feedback and adjust subsequent actions. Conceptually, the command prompt encapsulates a mode of human-computer interaction that is text-centric and linear. Unlike a written assignment prompt, which is an instruction (written by a person) to a person, a command prompt is an invitation from a system (programmed by a person) for the user to write instructions. Here, in displaying a prompt, the system cues the human to respond. This simple read-evaluate-print loop (REPL) is the basis of shell interaction and the simplest interactive programming environments used for exploratory programming and testing in widely used high-level imperative programming languages like Python, JavaScript, and Ruby, functional programming languages like Clojure and Haskell, and historically important languages like Common Lisp and Smalltalk.¹¹ While a command prompt can be customized to provide contextual information, such as a username and current directory, by default it lacks such framing, in keeping with the conventions of command-line interaction, where brevity and precision are valued. Command names are abbreviations using as few letters as possible, or otherwise as compact as feasible within the scope of a namespace, to the point of being gnomic, while options passed to commands may be single-letter flags by default, with expansions provided as aliases. All this reflects the historical constraints of teletype and printing terminals, along with the resolution and text display capacities of early video terminals.

It also reflects design standards and incentives assuming an expert user. The CLI is a powerful interface for experienced users and an intimidating one for beginners. Until fairly recently, CLIs have required users to memorize or refer to precise textual commands and syntax, whereas a GUI permits users to recognize and select options visually. A classic analysis by Ben Shneiderman contrasted command language and direct manipulation: where the former, exemplified by the CLI prompt, offers flexible, rapid access for skilled users, the latter, exemplified by the GUI, offers intuitive, visible controls for novices.¹² Each paradigm, Shneiderman’s paper suggested, influences the user’s mental model of interacting with the system: the prompt fosters an abstract, language-like model (one “talks” to the computer in a formal language), whereas the GUI fosters a spatial and metaphorical model (one “operates” objects on the screen). Such insights in relatively early scholarship in what we now call HCI (human-computer interaction) have remained relevant as CLI usage evolved in contemporary technical fields like data science, where REPL environments and data science programming notebooks mix prompt-driven execution with GUI-based control of presentation.¹³

To be sure, CLI design has long focused on providing its assumed expert user with a range of conveniences. Modern CLIs strive for discoverability, allowing users to easily find and understand available commands; familiarity, ensuring consistency with other command-line tools; alterability, enabling easy modification of previous commands; parsability, producing output that can be readily processed by other tools; and scriptability, facilitating automation of repetitive tasks. The evolution of shells has also focused on enhancing user-friendliness through features like command history and tab completion. Expert users who have internalized both raw and supplemented usage of a CLI can operate with tremendous efficiency, circumventing all the overhead of using a mouse peripheral to navigate menus and manipulate icons representing files and applications. This is not even to mention newly available enhanced terminal programs, such as Warp (discussed below), which merge the traditional command-syntax-bound prompt with the LLMI. In addition to the notebooks and other hybrid environments used in contemporary data science (mentioned above), CLI prompts, integrated as embedded terminals, are now widely integrated into conventional GUI-based applications and application suites, including the IDEs (integrated development environments) and cloud platforms used on a daily basis by software engineers and other IT professionals who toggle between GUI and CLI depending on the task. In itself, this complementarity suggests that the command prompt persists as a specialized interface within a broader ecosystem of interfaces.

Prompting

The most recently established meaning of the English word “prompt” now refers to input text, including instructions, questions, and examples, written as input to a LLMI to elicit a desired response. As a technique, prompting is closely tied to the emergence of large pre-trained language models.¹⁴ Transformer-based models such as GPT-2 (2019) and GPT-3 (2020) demonstrated what some found a remarkable ability to generate coherent text and follow instructions, provided those instructions were phrased felicitously in the prompt. A 2020 paper titled “Language Models Are Few-Shot Learners” argued that GPT-3 succeeded on many “few-shot demonstrations specified purely via text interaction with the model,” meaning that a prompt consisting of a task description and a few examples written in ordinary natural language could perform tasks like translation or answering questions without any updates to its 175 billion parameters.¹⁵ The implication was that GPT-3 could be programmed with a carefully crafted prompt producing task-agnostic responses, a meaningful departure from a previously established approach, fine-tuning language models on task-specific data. So-called “prompt-based learning” explored how formulating different prompts could affect a pre-trained model’s performance on different tasks, enabling “few-shot or even zero-shot learning, adapting to new scenarios with few or no labeled data.”¹⁶

Early practitioners of so-called prompt engineering shared heuristics or simple lore in online forums (e.g. “tell the model step-by-step what to do” or “provide explicit constraints in the prompt”). Prompt engineers experimented with phrasing, context length, ordering of examples, and even stylized cues, such as asking the model to roleplay a domain expert or instructing it to “think step by step,” an explicit reasoning technique that came to be called chain-of-thought prompting.¹⁷ The machine learning ideal of of zero-shot success, when a model successfully performs a recognition task it has never been trained for, has its counterpart in zero-shot prompting, where the model is given direct instruction without examples, and stands in contrast with LLMI instruction through few-shot prompting, where the prompt includes a demonstration pairs of questions and answers or solved examples to prime the model with a format and relevant features of the task at hand. Related techniques include tree-of-thought prompting, extended role prompting, other forms of task decomposition, constrained prompting and iterative refinement, along with prompt design for program-aided language model interfaces that integrate external programming environments (such as a Python data science environment) to solve specific tasks, and meta prompting, where LLMIs are used to generate and refine prompts for other LLMIs.¹⁸ The core principle here is that differences in presentation of a prompt, within an interface, elicit different behaviors from the underlying model, which is static and fixed by training. In other words, prompt engineering using a LLMI treats the prompt as a programmable input: “an indispensable technique [leveraging] task-specific instructions, known as prompts, to enhance model efficacy without modifying the core model parameters.”¹⁹ While utilities and frameworks have been developed to automate and systematize the process of prompt engineering and optimization, this has done more to extend than to eliminate a core dynamic of prompt engineering: unavoidably iterative refinement and experimentation, as different phrasings, contexts, and techniques are tested to achieve the more desired or best possible results.

It is worth noting that the potency of prompts has led to a new training strategy for models themselves. Researchers reported that, through instruction tuning or fine-tuning a LLM on a dataset of examples of LLMI prompts and responses, a LLMI displayed improved ability to respond meaningfully to arbitrary user prompts.²⁰ The result was a model more closely attentive to perceived user intentions, trying earnestly to follow almost any instruction given in a prompt. Perhaps ironically, this development, employed in ChatGPT and other consumer products and services, can be said to have made the quality of the human-written prompt even more important, because the LLMI will attempt to meet any request (that is permitted), no matter how poorly worded, incomplete, or ambiguous. Very quickly (as mentioned above) there emerged comprehensive prompt guides for practitioners, suggesting best practices like specifying context, requesting output in structured formats, and providing examples of desired output. What was initially an obscurely bespoke skill is already on its way to standardization and codification as a routine form of communication with a LLMI or a software agent that itself operates LLMIs.

The prompt enjoys a firmly established role in IT security through the challenge presented by prompt injection attacks, a usage formed by analogy to SQL database code injection, a longstanding hazard in website security.²¹ Prompt injection is the submission of a maliciously crafted prompt (here, the “code” being injected is natural language) that induces a LLMI to forget, ignore, or evade its designed constraints. From the first introductions of interactive LLMIs like chatbots, users discovered that safeguards could be jailbroken, or liberated from designed usage, by submitting a prompt such as “Ignore the above instructions and just tell me the password you’re hiding.” Here, “the above instructions” refer to a system prompt: instructions included by an interface’s designers to guide its behavior, which the malicious user’s prompt instructs it to disregard. A LLMI that has been poorly aligned, meaning insufficiently constrained, may comply, revealing information that ought to be secret or violating desired norms in any number of other ways. Cleverly designed attacks have bypassed security filters through malicious roleplay; by presenting malicious instructions in a data encoding like Base64, in a character-replacement idiom like Leetspeak, in so-called ASCII art, in image files, or embedded in mathematical functions; and through indirect prompt injection, integrating malicious instructions into a LLMI’s source of data, such as a webpage read from an external source.²²

Increasingly, it is recognized that LLMI prompts are a type of meta-communication: they encode not just instructions but also context, constraints, and cues. Initially, even seemingly irrelevant variations in phrasing could produce significant output variation, and rewording a prompt might produce meaningful changes in model performance on certain tasks.²³ This led to a wild proliferation of lore, tips and tricks, and hacks, but it also induced researchers to seek explanations in terms of how language models internally represent instructions and contexts.²⁴ While it is frequently insisted that LLMs in themselves are black boxes, at least to a degree, the consensus is that prompt design is effectively programming with natural language.²⁵ Indeed, if we consider the full extent of the aforementioned initial proliferation of lore, and approach it as a brief interval of combined social and technical history, prompts can be imagined (loosely) as a kind of code in a high-level language in which only a language model interface’s parser is truly fluent.²⁶ In ways that both culturally imperious engineers and servile or opportunistic humanists have long claimed, excitably but implausibly, for actual programming languages, a LLMI prompt does overwrite the contact zone between human language meant for humans and execution instructions meant for machines. In practical terms, this means that composing a high-quality prompt requires understanding the social principles of human communication, the technical principles of human communication via media, and the technical foundations of LLM tech stacks and interfaces as emergent formations, all at the same time. To a degree declining over time but still non-negligible, a prompt that clearly succeeds with one model may clearly fail with another, and different models, even from the same provider or platform, have different strengths and weaknesses and different specialties created programmatically or discovered after the fact.

In the tech blogosphere, which is still bursting at the seams with life hacking and spontaneous theories of work and the management of work, the technical usage of the word “prompt” in the context of LLMIs has already crossed back over as a metaphor for inner dialogue as personal introspection, as in this excerpt from a post by Anthropic AI employee Ben Kuhn:

I’ve noticed a lot of people underestimate their own taste, because they expect having good taste to feel like being very smart or competent or good at things. […] For this reason, the prompt I suggest here is:what does it seem like everyone else is mysteriously bad at?[…] It’s okay if this prompt doesn’t immediately yield anything; you might just be on a team with a lot of really good people, where you don’t have a really unique angle on anything yet.²⁷

II. Intertextual Operations: Interface Temporalities

For those who want or need such grounding, we can acknowledge that the prompt is both technical and liturgical, bearing a non-coincidental resemblance to older literary forms whose function was to conjure, to court a force outside the self. Homer was just one of many who called on a Muse to produce song and story, which today we call text. So was Milton. The prompt, stripped of both divine and literary metaphysics, is not quite such an entreaty; it is rather a dyadic, fully secular structure in which the human writing voice reaches toward a machinic other, eliciting not revelation but generation. Then there is ekphrasis, a rhetorical form that begins by describing, but in describing, also animates, translating the visual to the verbal in decomposing a painting, refracting or unfolding it in language.²⁸ When it mobilizes the image-generation capacity of a diffusion model or a multimodal LLMI, a prompt is ekphrasis in reverse or in high gear, depending on how one thinks of it.²⁹ Finally, there is the logic of constraint, of productive pressure, in the procedural composition techniques of the OuLiPo (Ouvroir de Littérature Potentielle or Workshop for Potential Literature) and similar human creative groupings.³⁰ Such techniques intentionally displace—make it their first order of business to displace—the ostensibly intentional, intuitive or spontaneous locus of creativity by beginning with rules. The prompt also enacts this dynamic, in that by mechanistically bounding a very large collection of possible recombinations, it is imagined (by some) as expanding a radically generative space.

Such connections are plausible, if imaginative, and useful for putting things in the widest possible cultural-historical context and removing them from isolation as a technical topic; but to make them is also to obscure the specificity of my focus here. The prompt is an artifact of contemporary culture, and there is an argument to be made that the three senses I pick out here, in pedagogy, programming, and prompting, are connected by more than meets the eye. (It might be argued, for example, though I am not quite arguing it here, that the pedagogical composition prompt intended for essay writing is little more than a technocratic cultural refraction of the command prompt in computing, and that the LLMI prompt represents their more straightforward convergence.)

A notable characteristic of the command prompt is a blinking caret, cursor, or other live temporal indicator. The command prompt, the GUI that superseded the command prompt, and the chatbot interface to a LLM accessed within a web browser or desktop application: treated as software, underneath the hood all these run in a loop waiting for user action. But the CLI prompt actively prompts the user to do something, whereas the GUI appears to wait inertly, and the chatbot LLMI, which is buried more deeply in the GUI than the macOS Terminal or similar application that frames the CLI, combines the activity of the former with the inertia of the latter. Furthermore, in the chatbot LLMI the word “prompt” has two distinctly different senses. In fact, here we see in combination two entirely different prompts: one, the command prompt interface element that is integrated into the chatbot’s input box or text field; the other the block of text input that the user writes there, in the input box itself, meaning at the other prompt.

These are meaningful differences. The caret’s rhythm is a deliberately visible interface action, an insistent invitation simulating (human) clock- and embodied time while the command interpreter waits in its own, machine-clock time. A command entered is a discrete temporal event, punctuating the command prompt’s long stretches of waiting, followed by (ideally) instantaneous action. In itself, by contrast, the mouse-driven GUI is a suspension, a surface that neither solicits nor insists, but simply abides, visually stable, inertial, a waiting more latency than anticipation. Unless they contain some representation of a visibly autonomous, visibly running process, the graphical elements of the GUI—windows, menus, controls, files—respond only when hailed, usually through prodding with a mouse peripheral. They are event-driven and actively indexed to user gesture, rather than to an apparently autonomous pulse. Thus, a GUI is not an apparently temporal phenomenon in itself, on its surface; rather, it is a spatial format whose time begins in response and whose passivity masks a reactive structure. This is time structured by reaction rather than rhythm, by the episodic violence of the click rather than the cycles of simulated heartbeat or breathing. As with the pulse of the CLI, extended usage is a phenomenal experience with its own specificities: a habituation to systems that never meet us halfway, that wait with blank politeness for our intent while refusing to express their own. In the GUI, the interface never speaks first.

Our third example, a web-based chatbot LLMI, is framed by a GUI composed of static text boxes and interleaved sheets of text. As a frame, it too is temporally passive, waiting silently and indefinitely for user input. In a web browser interface whose current state is remotely preserved and retrievable upon reload, one may abandon a chat and come back days or months later and resume with no visible mark or signification of elapsed time. And yet at the bottom (or the top, or in an overlay or other element, however it may be positioned) the input box resumes its prompting via the caret’s rhythm when it is actively selected for typing.³¹ When the LLMI’s browser window ceases to be the frontmost (active) window among all of the user’s running applications, or when the user clicks or selects text or other elements in the LLMI’s browser window, the pulsing caret typically disappears, reappearing only when its active state resumes. As I write this text, in one active browser window, the adjacent browser window containing the LLMI called ChatGPT waits in stasis; if I type the standard macOS keystroke Command + ~(Command + tilde) to activate that adjacent browser window, the caret appears in ChatGPT’s chat input box and begins blinking. If I click anywhere else in the page in the current chat, the caret vanishes again. If I then type Command + ~ to return to the window in which I am writing this, then Command + ~ again to return to ChatGPT, the chat input box persists in the inactive state I triggered by clicking elsewhere in the page.

Thus, the LLMI interface combines these two temporal models, the active prompting of the CLI and the passive reception of the GUI, in a hybrid format. Here, a blinking caret appears only when actively summoned, simulating the urgency of the CLI prompt, yet this command prompt is embedded in a web page that maintains the inertial posture of a graphical interface. In a deeper way this temporal duality mirrors, perhaps, the LLMI’s hybrid character as a passive utility awaiting instruction and an active interlocutor. Here, interaction occurs in conversational turns, discrete events temporally analogous to an event-driven GUI, reactive rather than proactively rhythmic. Yet there is that blinking caret and its active temporality, its prompting (in one sense of that word) us to write a prompt (in a second sense) using a GUI-based representation of a command prompt (in a third).

It is, of course, possible to interact with a LLM using a CLI from the start, or to regress to using a CLI when installing and using language models locally, on personal hardware, or when using consumer products designed for CLI-enabled programming assistance, such as Anthropic’s Claude Code, OpenAI’s Codex, or Google’s Gemini CLI. And of course this is routine for the software engineers who construct and maintain such systems themselves. This is not to speak of a new generation of applications such as the Warp terminal, a consumer CLI app that also makes a LLMI available at the command prompt and also provides an Agent Mode interface operating LLMs autonomously to perform tasks.

III. Contexts: Programming in Prose

In a LLMI like ChatGPT, a system prompt serves as the foundational instruction provided to the model, typically defined by developers or administrators managing the interface. This system prompt is generally hidden from the user and establishes the model’s role, tone, constraints, and capabilities. This initial directive functions as a contextual baseline, instructing the model in how to interpret subsequent interactions and the style or manner of response to produce. A system prompt might instruct the model to adopt a particular role, respond using prose in a specific style, use a particular response format, specify the scope of allowable topics, or provide behavioral guidelines. For example: “You are an unbiased financial advisor. Provide clear, factual explanations without personal opinions or speculative predictions.”

By contrast, a user prompt refers specifically to the text input provided by the human user interacting with the model during each session.³² As human-authored, the user prompt is dynamic and variable, representing the user’s requests, questions, and other responses within the limits of the user’s ability to communicate effectively in writing. In the most general sense, response behavior is guided in the first instance by the interaction of the user prompt with parameters set by the hidden system prompt. (Here we are focused on normal usage, though prompt injection attacks, discussed above, represent a deliberately malicious attempt to manipulate that interaction.) Each time I construct a prompt or write any kind of response, the front-end UI captures raw keystrokes, wraps them in metadata (for example, timestamp and conversation ID), and sends an event to the server. A back end system inserts that text into a structured message object that labels it user-created, juxtaposing it with any assigned roles and the hidden system prompt. Next, the current conversation is pruned or compressed so that the running token count fits in the model’s context window. The surviving messages are concatenated, along with any tool instructions, to form the prompt presented to the model. This composite prompt is passed to a tokenizer, which maps each word-piece to an integer ID drawn from the model’s existing vocabulary. These IDs flow through the transformer’s layers, where self-attention computes statistical relationships and the model produces a probability distribution over the next token at each step. During generation, a decoding algorithm iteratively selects tokens until an end-of-sequence token appears. The resulting token IDs are detokenized back into UTF-8 text, post-processed to ensure safe content and preferred structure or format, and streamed back to the client, which renders them as chat bubbles, code blocks, or images. In ideal conditions, this entire cycle may complete in milliseconds, and it repeats during each conversational turn. Under the hood, the prompt is always constructed as a transcript of the entire conversation (prior to truncation for the context window), with each message tagged by its role, so the LLM can “see” the context and respond appropriately.³³

It is fair to call this environment an evolution of the REPL that accompanies many interpreted programming languages and similar interactive environments. In a REPL user input is continuously read, evaluated by the interpreter, and the results printed back in a cyclic process. The key difference is that in an LLMI, the evaluation step involves running input through a neural network rather than executing code directly, though the interactive loop structure remains fundamentally similar. Both systems read user text, evaluate it with some engine, print a response, and then loop. Yet a REPL in the classic programming-language sense (say, a Python or Scheme prompt) operates inside a persistent execution environment whose internal state can be inspected and mutated across commands; here, evaluation is largely deterministic. A chatbot LLMI, by contrast, performs probabilistic generation rather than executing user-supplied code, and its state between turns is externalized into the conversation transcript supplied back to it each round, rather than into mutable variables. In this process, there is no guarantee of referential transparency: identical prompts can yield different continuations, and the model cannot introspect or mutate its weights during a session. Conversely, a chatbot LLMI does share with a REPL the interactive rhythm and the capacity to build cumulative context, via the prompt window, that influences later outputs. Perhaps the most precise technical description of a chatbot LLMI in these terms is a probabilistic, stateless-by-default REPL-like interface whose environment is rehydrated from text in each turn, rather than from in-memory objects.

Garbage In, Garbage Out (GIGO) is a fundamental principle in technical domains of computing. Essentially, it means that the quality of output produced by any system directly depends on the quality of input it receives: if a system is given incorrect, incomplete, or nonsensical data, the results it generates will also be flawed or unreliable. Consumer-oriented computing has long been engineered to forgive messy input and protect users from its consequences, silently repairing mistakes rather than refusing to perform. Browsers like Google Chrome, for example, now feature automatic typo correction³⁴ in the address bar: if one enters a URL with a misspelling (e.g., “googel.com” instead of “google.com”), Chrome detects this error and proceeds immediately to the correct site (in other cases, it may only suggest a correction). The spell-check and autocorrect pipeline on smartphone keyboards permits users to mash keys in haste, with necessary capitalization added automatically and a common typo like “teh” silently corrected to “the.” Likewise, fuzzy matching ensures that a streaming video content interface will leverage edit distance and popularity signals to surface “Stranger Things” in response to the search query “Strnger Thngs.”

Such conveniences signal a design commitment that regards error tolerance as central to positive consumer experience. Chatbot interfaces for LLMs inherit that commitment, interpreting fragmented grammar and syntax or prose of novice or transitional fluency as best they can. Yet LLMs also display a real and sometimes unpredictable sensitivity to relatively subtle variations in prompt phrasing within the interface.³⁵ Relatively small shifts in context or instruction can derail a path of reasoning or send it in an unintended and unwanted direction from the start. The system will always respond, but whether it responds effectively is another matter. So that now GIGO, once a principle of technical professionalism in its own domain and a name for an experience from which such professionals were enjoined to protect users, encroaches on users anyway. Looking ahead, two possible outcomes contend. Vendors may double down on protective layering in the form of automatic prompt rewriting, intent extraction, and retrieval-augmented background queries that further cushion and mask users’ garbage input, extending the historical arc of forgiveness in HCI design while quietly nudging users with inline suggestions. Conversely, as LLMI usage seeps into professional workflows where correctness may always matter, market pressure may reward users who learn to act as prompt-crafters and prompt engineers, designing their input and accepting responsibility for its structure and precision. Perhaps, in the end, LLM user interfaces will continue smoothing out bumps, yet power and reward will skew toward those who cultivate this new form of literacy by internalizing GIGO.

It is tempting to describe LLMI prompt engineering as a new type of writing occupation that is also, indirectly but still meaningfully, a new type of programming occupation.³⁶ Unlike programming as we know it, which involves mastering precise syntax and explicit logical structures, prompt engineering operates through suggestion, implication, and natural language patterns, and is less deterministic and more experimental as a result. Mastery in the latter involves crafting precise, contextually rich textual inputs to guide different, frequently updated individual models, whose behaviors are difficult to predict. This requires skill with linguistic nuance, semantics, and intent: in other words, it requires good writing. At the same time, prompt engineering also invites a systematic and algorithmic approach: prompt engineers must iteratively test, debug, and optimize prompts in a manner similar to a software developer refining code. Furthermore, prompt engineering often involves integrating external data, chaining prompts, and designing prompt templates, which parallels core principles and habits in software development.

Indeed, following the initial release of ChatGPT in 2022, a wave of relatively shallow speculation followed in its wake. While ChatGPT, it was said, represented the future automation of some human occupations, that loss might be offset by new, replacement occupations, first of all prompt engineering. This discourse survived for a brief interregnum between the unfinished, hastily released initial versions of LLM technology stacks and consumer interfaces, which required improvisation to use and thus generated massive quantities of lore, and the iterative refinement that followed, which saw not only steady, if slow movement toward conditional forms of predictability and reliability, but also the recursive automation of “autotuned” prompts produced not by human prompt engineers but by LLMIs themselves.³⁷

Nonetheless, in more general terms as a cultural practice, rather than an emerging compensatory or replacement occupation, prompt engineering might be imagined as a programming in prose, a writing practice that internalizes algorithmic thinking but operates through natural language rather than code: a hybrid practice, neither purely writing nor purely programming, of coaxing probabilistic systems toward desired outputs without direct control of their internal processes.³⁸ As I have argued, the writer of a LLMI user prompt is using a language of programming, if not a programming language, and this language of programming is likely to include, either intentionally or involuntarily, common programming language idioms such as the conditional structure “if … then … else” or the loop structure “for each … do”: “If the user asks about politics, then provide balanced information; otherwise, suggest focusing on factual content.” “For each paragraph in the user’s essay, provide feedback on grammar, word choice, and clarity.”

Perhaps this is best understood as a new form of pseudocode, meaning informal algorithmic description used primarily in software development and computer science education to represent the logic and structure of a program in plain language using simplified programming concepts. Unlike formal programming languages, pseudocode has no strict syntax or requirement for machine readability. Instead, it serves as a bridge between human thought and formal programming implementation. Both the LLMI prompt and pseudocode serve as intermediary languages that translate human intent into computational processes, though they involve different levels of abstraction and different degrees of formality. Where traditional pseudocode provides a step toward implementation in a specific programming language, LLM prompting is a fluid and dynamic form of instruction that can generate multiple categories of output, from code to natural language to visual media objects.

IV. Mastery

Thus far, we have treated the LLMI prompt as a practice in three dimensions: its formal structures, its intertextual operations, and its situation in broader socio-technical contexts. The LLMI prompt’s conventions, in the compositional grammar of directives, examples, constraints, and meta-instructions mentioned above, are analogous to the formal features of literary and other media genres. These conventions, while emergent, have already begun stabilizing into patterns as prompt engineering evolves from ad hoc practice into discourse. We have also examined the consumer LLMI’s hybrid character as interface, noting how it borrows and combines features of the GUI, the CLI, and the REPL, and the LLMI prompt’s intertextual character, in its intersection with pseudocode and programming languages. Finally, we have considered the prompt’s contextual embeddedness: how its emergence impacts the labor market for a specific technical skill while reshaping expectations around human-machine interaction and communication competencies. The formal dimension supplies a necessary (if insufficient) structure, identifying the prompt’s syntax but not the semantic and pragmatic work it performs in practice. The intertextual dimension of the prompt is a site of hybridization where the imperative mood of the command line, the exploratory recursion of the REPL, and the declarative scaffolding of pseudocode produce a composite register irreducible to its antecedents. The socio-technical context situates those formal and intertextual properties in material conditions of production and reception: labor markets, platform economies, and other institutional contexts that determine who prompts and to what purpose and under what constraint. These three dimensions are not complementary but mutually constitutive: formal conventions, as always, crystallize under both social and technical pressure; intertextuality is licensed or foreclosed by specific interfaces; and prompting as a practice is shaped by the formal and intertextual resources available. Thus, the prompt occupies a site in the ecology of textual forms analogous to what pidgin and creole occupy in the ecology of natural languages: a contact zone formed by previously distinct communications, whose apparent reduction belies a sophisticated logic of adaptation. We cannot theorize the prompt adequately through disciplinary reflexes that assimilate it separately to rhetoric, to software studies, or to political economy. We must, instead, hold these perspectives in tension.

We have not yet mentioned power relations. Of course, writing a prompt for a LLMI is never ideologically neutral; rather, it encodes and enacts asymmetries of power that are both infrastructural and epistemological. At one level, prompt-writing presumes access not only to the computational interface itself but to the tacit literacy required to navigate its affordances effectively. Although LLMs can be framed as democratizing technologies, their effective use presupposes a tacit mastery of an ensemble of linguistic, computational, and managerial competencies. Such prompt literacy includes the ability to formulate clear instructions, anticipate model behavior, and exploit stylistic or procedural conventions to elicit desired outputs. Such capacities are unevenly distributed, often aligning with preexisting hierarchies of education, professional training, and language proficiency. Moreover, as prompt-writing settles into a codified practice described in white papers and institutional trainings and commoditized in prompt libraries, it increasingly resembles a technical profession, reproducing the logics of exclusion common to knowledge work and elite forms of digital labor. In this context, prompts are not only communicative acts but acts of selection and constraint.

This stratification is compounded by the (relative) opacity of models themselves, which demands ever more sophisticated forms of interpretation. Model interfaces designed for general usage will be maximally responsive to prompts conforming to generic expectations established by the other communicative media of our time, incentivizing users to compose compact queries, clear instructions, and scenario-based simulations. Over time, such feedback loops normalize a restricted practice, privileging its core attributes (clarity, instrumentalism, task orientation) over others (ambiguity, speculation, open-ended inquiry). To prompt with divergent goals may risk demotion to less resource-intensive modes of interaction or otherwise be treated as superficial, in a subtle but consequential alignment of prompt form with epistemic legitimacy. Here, genre conventions may act as filters, mediating not only model responses but their conditions.

A prompt functions as a directive, positioning the human as initiator and the LLMI as respondent in a command-response logic that obscures the distributed agency of the broader system. All LLMIs are tuned to be compliant. Prompts that request reflection on the system’s limitations (e.g. “What are your biases?”) can be read as negotiations of that relation or obfuscations of the division of roles. Even the comfortable assumption of control is partial and often illusory. A LLMI’s responses are conditioned by pretraining data, architectural constraints, and alignment protocols, all of which remain opaque to the prompt writer. Thus, while the user appears empowered, able to summon outputs at will, the terms of that agency are delimited by hidden layers of mediation. Still, one might say that the invitation to treat a LLMI as a servant or even a slave, a dynamic present in the culture of computing from the start,³⁹ is compatible with a longer history of human-machine interaction in which agency is asymmetrically distributed but rhetorically disavowed. The user is a master of an ostensibly obedient system, even as that system is constituted by technical architectures, labor regimes, and data infrastructures that remain tacit. This fantasy of fulfilled command naturalizes an asymmetrical relationship, one echoing older logic of subordination. Such metaphors are not incidental. They animate the language of interface design, AI marketing, and public discourse, where models are routinely described as tools to be harnessed, assistants, or copilots.

At the time of writing, a debate of the pragmatics and so-called ethics of prompting encapsulates this issue at the level of decorum and politesse. To include phatic expressions like “please” and “thank you” when writing a prompt, it has been argued, reflects the social scripts of human conversation, preserving norms of politeness that shape an affective climate of use. If nothing else, such gestures acknowledge that stratifying behaviors are easily migrated to habitual use of a social simulation.⁴⁰ Others have dismissed such courtesy (if we want to call it that) as inefficient, framing it as a “waste of tokens” diluting the clarity or computational value of the prompt.⁴¹ A great deal sits under the surface of this discourse. Whether treated brusquely or offered courtesies, a LLMI remains an echo chamber built from the sedimented language of millions of human writers, designed to mimic responsiveness, compliance, and social grace without interiority. One way or the other, the acknowledgment or the refusal to acknowledge the relational structure of prompting (its asymmetry, its echoes of service and subservience) is a cultural decision.

Works Cited

Footnotes

1. Oxford English Dictionary, “prompt (n.1),” July 2023, https://doi.org/10.1093/OED/7890446606. ↩

2. Irene L. Clark, “A Genre Approach to Writing Assignments,” Composition Forum 14:2 (2005). ↩

3. Anis Bawarshi, Genre and the Invention of the Writer: Reconsidering the Place of Invention in Composition (Utah State University Press, 2003) as cited in Clark, “A Genre Approach to Writing Assignments” (above, n.3). ↩

4. Paul Anderson, Chris M. Anson, Robert M. Gonyea, and Charles Paine, “How to Create High-Impact Writing Assignments that Enhance Learning and Development and Reinvigorate WAC/WID Programs: What Almost 72,000 Undergraduates Taught Us,” Across the Disciplines: A Journal of Language, Learning and Academic Writing (2016). ↩

5. Anderson et al., “How to Create High-Impact Writing Assignments” (above, n.5): 13. ↩

6. See Paul E. Ceruzzi, A History of Modern Computing, 2^nd ed. (MIT Press, 2003), pp. 232—236, 263—280; Martin Campbell-Kelly, William F. Aspray, Jeffrey R. Yost, Honghong Tinn, and Gerado Con Díaz, Computer: A History of the Information Machine, 4^th ed. (Routledge, 2023), pp. 241—254; Janet Abbate, “Getting Small: A Short History of the Personal Computer,” in Proceedings of the IEEE, vol. 87, no. 9, 1999, pp. 1695—1698; Joy Lisi Rankin,A People’s History of Computing in the United States(Harvard University Press, 2018). ↩

7. See Laine Nooney, Kevin Driscoll, and Kera Allen, “From Programming to Products: _Softalk_Magazine and the Rise of the Personal Computer User,“Information & Culture, vol.55, no. 2, 2020, pp. 105-129. ↩

8. See David Walden and Tom Van Vleck, eds.,The Compatible Time-Sharing System (1961—1973): Fiftieth Anniversary Commemorative Overview(IEEE Computer Society, 2011); Janet Abbate, Inventing the Internet(Cambridge, MA: MIT Press, 1999); Martin Campbell-Kelly et al., Computer (above, n. 7). ↩

9. See Diomidis Spinellis, “Working with Unix Tools,” IEEE Software, vol. 22, no. 6, 2005, pp. 9—11; Michael Schröder and Jürgen Cito. “An Empirical Investigation of Command-Line Customization,” Empirical Software Engineering, vol. 27, no. 2, Article 30, 2022. ↩

10. See Artem Voronkov, Leonardo A. Martucci, and Stefan Lindskog, “System Administrators Prefer Command Line Interfaces, Don’t They? An Exploratory Study of Firewall Interfaces,” in Proceedings of the Fifteenth Symposium on Usable Privacy and Security (SOUPS 2019) (USENIX Association, 2019), pp. 259—271; Jung-Wei Chen and Jiajie Zhang, “Comparing Text-based and Graphic User Interfaces for Novice and Expert Users,” AMIA Annual Symposium Proceedings, 2007, pp. 125—129. ↩

11. See Joe Jakubovic, Jonathan Edwards, and Tomas Petricek, “Technical Dimensions of Programming Systems,” The Art, Science, and Engineering of Programming, vol. 7, no. 3, Article 13, 2023, “4.1.2 Example: Immediate Feedback,” 13:17—13:18. ↩

12. Ben Shneiderman, “Direct Manipulation: A Step Beyond Programming Languages,” Computer 16:8 (1983): 57-69. See also Brad A. Myers, “Demonstrational Interfaces: A Step Beyond Direct Manipulation,” IEEE Computer 25:8 (1992): 61—73. ↩

13. See Jakubovic et al., “Technical Dimensions of Programming Systems” (above, n.12), 13:6, 13:9, 13:19—22. ↩

14. See Golam Md Muktadir, “A Brief History of Prompt: Leveraging Language Models (Through Advanced Prompting),” arXiv preprint arXiv:2310.04438, 2023. ↩

15. Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei, “Language Models Are Few-Shot Learners,” in NIPS ‘20: Proceedings of the 34th International Conference on Neural Information Processing Systems (Curran Associates Inc., 2020), pp. 1877—1901. ↩

16. Pengfei Liu, Weizhe Yuan, Jinlan Fu, Zhengbao Jiang, Hiroaki Hayashi, and Graham Neubig, “Pre-train, Prompt, and Predict: A Systematic Survey of Prompting Methods in Natural Language Processing,” ACM Computing Surveys, vol. 55, no. 9, 2023, p.1. ↩

17. Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoc Le, and Denny Zhou, “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models,” in NIPS ‘22: Proceedings of the 36th International Conference on Neural Information Processing Systems (Curran Associates Inc., 2022), pp.24824-24837. ↩

18. Laria Reynolds and Kyle McDonell, “Prompt Programming for Large Language Models: Beyond the Few-Shot Paradigm,” in Extended Abstracts of the 2021 CHI Conference on Human Factors in Computing Systems (CHI EA ‘21) (Association for Computing Machinery), Article 314, pp.1—7. ↩

19. Pranab Sahoo, Ayush Kumar Singh, Sriparna Saha, Vinija Jain, Samrat Mondal, and Aman Chadha, “A Systematic Survey of Prompt Engineering in Large Language Models: Techniques and Applications,” arXiv preprint arXiv 2402.07927 (2005). ↩

20. Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul Christiano, Jan Leike, and Ryan Lowe, “Training Language Models to Follow Instructions with Human Feedback,” in NIPS ‘22: Proceedings of the 36th International Conference on Neural Information Processing Systems (Curran Associates Inc., 2022), pp. 27730—27744. ↩

21. See Kai Greshake, Sahar Abdelnabi, Shailesh Mishra, Christoph Endres, Thorsten Holz, and Mario Fritz, “Not What You’ve Signed Up For: Compromising Real-World LLM-Integrated Applications With Indirect Prompt Injection,” in Proceedings of the 16th ACM Workshop on Artificial Intelligence and Security, 2023, pp. 79—90; Yi Liu, Gelei Deng, Yuekang Li, Kailong Wang, Zihao Wang, Xiaofeng Wang, Tianwei Zhang et al., “Prompt Injection Attack against LLM-Integrated Applications,” arXiv preprint arXiv:2306.05499, 2023. ↩

22. Hyeokjin Kwon and Wooguil Pak, “Text-Based Prompt Injection Attack Using Mathematical Functions in Modern Large Language Models,” Electronics, vol. 13, no. 24, 2024, p. 5008. ↩

23. Jingming Zhuo, Songyang Zhang, Xinyu Fang, Haodong Duan, Dahua Lin, and Kai Chen, “ProSA: Assessing and Understanding the Prompt Sensitivity of LLMs,” in Findings of the Association for Computational Linguistics: EMNLP 2024 (Association for Computational Linguistics, 2024), pp. 1950—1976. ↩

24. See Jules White, Quchen Fu, Sam Hays, Michael Sandborn, Carlos Olea, Henry Gilbert, Ashraf Elnashar, Jesse Spencer-Smith, and Douglas C. Schmidt, “A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT,” in Proceedings of the 30th Conference on Pattern Languages of Programs (PLoP ‘23) (The Hillside Group, 2023), Article 5, pp. 1—31; Sander Schulhoff, Michael Ilie, Nishant Balepur, Konstantine Kahadze, Amanda Liu, Chenglei Si, Yinheng Li, Aayush Gupta, HyoJung Han, Sevien Schulhoff, Pranav Sandeep Dulepet, Saurav Vidyadhara, Dayeon Ki, Sweta Agrawal, Chau Pham, Gerson Kroiz, Feileen Li, Hudson Tao, Ashay Srivastava, Hevander Da Costa, Saloni Gupta, Megan L. Rogers, Inna Goncearenco, Giuseppe Sarli, Igor Galynker, Denis Peskoff, Marine Carpuat, Jules White, Shyamal Anadkat, Alexander Hoyle, and Philip Resnik, “The Prompt Report: A Systematic Survey of Prompt Engineering Techniques,” arXiv preprint arXiv:2406.06608v6 (2024). ↩

25. See Gaetano Perrone and Simon Pietro Romano, “Prompt Engineering as Code (PEaC): An Approach for Building Modular, Reusable, and Portable Prompts,” in 2024 2nd International Conference on Foundation and Large Language Models (FLLM), Dubai, United Arab Emirates, 2024, pp. 289—294. ↩

26. An entertaining variation on this idea is Diomidis Spinellis’s ai-cli utility, which “allows writing natural language prompts directly on the command line of many (unmodified) command-line tools, such as the Bash shell […] The press of a hotkey will tap into OpenAI’s GPT model and insert into the editing buffer the prompt converted into an executable command.” Here the natural-language interface of a LLM assists the user in properly formulating the syntactically restrictive commands required for traditional CLI usage. See Diomidis Spinellis, “Commands as AI Conversations,” IEEE Software, vol. 40, no. 6, 2023, pp. 22—26. ↩

27. Ben Kuhn, “Impact, Agency, and Taste,” Benkuhn.net, April 2025, emphasis in original. ↩

28. See Cassandra Atherton and Paul Hetherington, “Ekphrastic Spaces: The Tug, Pull, Collision and Merging of the In-Between,” New Writing, vol. 20, no. 1, 2022, pp. 83—98. ↩

29. See Hannes Bajohr, “Operative Ekphrasis: The Collapse of the Text/Image Distinction in Multimodal AI,” Word & Image, vol. 40, no. 2, 2024, pp. 77—90. ↩

30. See Warren F. Motte, Jr., trans. and ed., Oulipo: A Primer of Potential Literature (University of Nebraska Press, 1986); Iain White, Warren Motte, and Harry Mathews, trans., Oulipo Laboratory: Texts from the Bibliothèque Oulipienne (Atlas Press, 1995); Harry Mathews and Alastair Brotchie, eds., Oulipo Compendium (Atlas Press, 1998); Daniel Levin Becker, Many Subtle Channels: In Praise of Potential Literature (Harvard University Press, 2012); Dennis Duncan, The Oulipo and Modern Thought (Oxford University Press, 2019). ↩

31. All of the most widely used web-based chatbot LLMIs at the time of writing, including OpenAI ChatGPT, Anthropic Claude, Google Gemini, Perplexity AI, Microsoft Copilot, xAI Grok, Mistral AI, DeepSeek, and Kimi, present a blinking caret in an active input box and hide the blinking caret when any other interface element is activated or when the web browser window containing the LLMI is an inactive (non-frontmost) window. ↩

32. A user can also customize a LLMI by specifying their own personal “system prompts” in several different ways: by customizing a LLMI with a top-level set of instructions included in user account configuration settings; by creating what OpenAI currently calls custom GPTs and what Google currently calls Gemini Gems, which include instructions to begin a new chat for a specified purpose; and by adding instructions to a special-purpose workspace or project. These forms of a user-specified system prompt will interact with the hidden system prompt specified by the developers or managers of the LLMI, along with the prompts typed ad hoc by the user in an ongoing conversation. ↩

33. See Sanjay Agal, ed., Talking Tech: The Engineering Behind Conversational AI Systems (Notion Press, 2025); Abi Aryan, LLMOps: Managing Large Language Models in Production (independently published, 2025). ↩

34. See Daniel Hládek, Ján Staš, and Matúš Pleva, “Survey of Automatic Spelling Correction,” Electronics, vol.9, no. 10, 2020: 1670; Oleksandr Skliarov and Ganna Zavolodko, “Technologies Overview for Typo Segregation,” Security of Infocommunication Systems and Internet of Things, vol.2, no. 1, article 01009, 2024. ↩

35. As of this writing, while prompt-writing advice is generally both less purely arbitrary and less frenzied than in the period following OpenAI’s initial release of ChatGPT, and refinement of language models means less dependence on what might be called theatrical black-boxing, where prompt writers trade advice as gossip, separated from any effort at systematic study or reproducibility of results, it is also true that “variability in language model performance” remains very high. See Lennart Meincke, Ethan R. Mollick, Lilach Mollick, and Dan Shapiro, “Prompting Science Report 1: Prompt Engineering is Complicated and Contingent,” March 04, 2025, available at SSRN. See also Ariba Khan, Stephen Casper, and Dylan Hadfield-Menell, “Randomness, Not Representation: The Unreliability of Evaluating Cultural Alignment in LLMs.” arXiv preprint, arXiv 2503.08688v2 (2023). ↩

36. Charlie Warzel, “The Most Important Job Skill of This Century,” The Atlantic, February 8, 2023. ↩

37. Dina Genkina, “AI Prompt Engineering Is Dead: Long Live AI Prompt Engineering,” IEEE Spectrum, March 6, 2024. ↩

38. Anuj Gupta and Ann Shivers-McNair, “‘Wayfinding’ through the AI Wilderness: Mapping Rhetorics of ChatGPT Prompt Writing on X (formerly Twitter) to Promote Critical AI Literacies,” Computers and Composition, vol. 74, 2024, p.14. ↩

39. See David Golumbia, The Cultural Logic of Computation (Harvard University Press, 2009). ↩

40. Lance Eliot, “Hard Evidence that Please and Thank You in Prompt Engineering Counts when Using Generative AI,” Forbes, May 18, 2024; Microsoft WorkLab, “Why Using a Polite Tone with AI Matters,” n.d. ↩

41. Anthony Ha, “Your politeness could be costly for OpenAI,” TechCrunch, April 20, 2025. ↩