Blog · Review Essay · Last reviewed June 19, 2026

My Mother Was a Computer and the Code That Mothers the Subject

N. Katherine Hayles's My Mother Was a Computer is a book about what happens after code becomes one of culture's ordinary languages. The computer's habit of processing symbols seeps outward until people begin to understand speech, writing, bodies, texts, selves, and even the cosmos through computational habits. The machine becomes a parent of perception.

For this review, a code subject is a person shaped by languages that do more than represent. Code can store, sort, retrieve, render, authorize, refuse, train, profile, and act. In the AI era, prompts, system messages, embeddings, tool calls, logs, and policies extend that condition: language becomes an interface through which institutions make people machine-addressable.

The Book

My Mother Was a Computer: Digital Subjects and Literary Texts was published by the University of Chicago Press in 2005. Chicago's publisher page lists the book at 288 pages and gives ISBNs including 9780226321486, 9780226321479, and 9780226321493. Duke's bibliographic record confirms the author, title, year, and publisher; library records commonly list the physical copy as x, 290 pages.

Chicago's description gives the scope: programming languages, code, literary media, electronic text, print, virtual creatures, science fiction, and the changing relation between humans and intelligent machines. UCLA's profile places Hayles's work across literature, science, and technology, which matters here because this book is not only a literary study and not only a theory of software. It is a theory of what culture becomes when language and execution start to share the same interface.

The book follows How We Became Posthuman but shifts the pressure point. The earlier book asks how information came to seem detachable from the body. This one asks what kind of subject emerges when code, writing, and media systems constantly translate into one another. The question is no longer simply whether the human disappears into information. It is how the human is remade by living among computational forms.

Hayles organizes the argument around making, storing, and transmitting. The table of contents moves from language and code to print and electronic text, then to analog and digital forms, simulation, agents, Greg Egan, Stanislaw Lem, Neal Stephenson, Shelley Jackson, and the book's epilogue on recursion and emergence. That structure matters. It treats computation as a cultural environment, not a technical add-on.

Current Context

As of June 19, 2026, Hayles's distinction between ordinary language and executable code has become an everyday governance problem. Large language models produce prose, but many deployments also connect that prose to retrieval systems, identity layers, software tools, payments, email, calendars, records, APIs, code editors, and workflow automation. Natural language is increasingly an action surface.

NIST's 2026 AI Agent Standards Initiative makes that shift explicit by focusing on agents capable of autonomous actions, secure operation on behalf of users, interoperability, community-led protocols, and research into agent authentication and identity infrastructure. That is Hayles's code-language problem in product form: a sentence can now become a tool call, a tool call can become a record change, and a record change can become institutional fact.

NIST NCCoE's software and AI agent identity work names the operational layer: organizations need standards-based ways to identify, manage, and authorize access and actions taken by software agents, including AI agents. OWASP's 2025 GenAI risk list names the attack layer: prompt injection, supply chain risk, improper output handling, sensitive information disclosure, and excessive agency are not abstract theory problems. They are what happens when language becomes a control surface for code, tools, and records.

Current AI governance sources point in the same direction. NIST's AI Risk Management Framework organizes risk work around govern, map, measure, and manage functions across the lifecycle, while its Generative AI Profile treats provenance, testing, monitoring, documentation, human-AI configuration, information integrity, privacy, and value-chain integration as risk-management concerns. NIST's Secure Software Development Framework adds the software layer: secure development practices, vulnerability reduction, and supplier communication matter when generated code or agent-triggered code enters real systems.

European law supplies a rights-and-oversight vocabulary. The EU AI Act requires high-risk AI systems to provide information that helps deployers interpret outputs and use systems appropriately, and Article 14 requires human oversight for high-risk systems. Article 50 creates transparency duties for systems intended to interact directly with people. Those rules are jurisdiction-specific, but they name a general problem: when language-like interfaces act through code, people need to know when they are interacting with AI, how outputs should be interpreted, and who is accountable for downstream action.

The Code Subject, Defined

A code subject is not a person who has become software. It is a person made actionable through executable descriptions: account identifiers, form fields, permissions, embeddings, prompt histories, access tokens, risk flags, workflow states, eligibility rules, audit logs, and model-generated summaries. The person remains embodied and social, but the institution often meets them through a machine-readable handle.

This matters because code subjects are not only represented. They are routed. A category can open a door, close an appeal path, trigger extra review, suppress a message, personalize a price, recommend a lesson, escalate a support ticket, deny an action, or preserve a record. The subject becomes legible at the point where description connects to operation.

The condition is recursive. People learn to write for forms, prompts, scoring systems, search engines, moderation systems, and automated review. Systems then treat those adapted traces as evidence of what people are like. The output becomes instruction; the instruction becomes behavior; the behavior becomes new data. Hayles's value is that she lets us see this as media theory and governance at once.

The safety distinction is therefore between a representation and a binding executable account. A profile, summary, embedding, or score can help an institution work, but it should not silently become the person. High-impact systems need clear boundaries between draft text, inferred claim, official record, and action, plus a practical way for affected people to inspect, correct, appeal, or refuse the account made of them.

Code as Language, Language as Code

The strongest idea in the book is that code has become culturally comparable to speech and writing without being identical to either. Code is executable. It can describe and act at the same time. A sentence can persuade, command, or promise, but a program can also run, branch, call, store, sort, render, delete, and transmit. That difference gives code a strange authority in digital culture.

Hayles structures this as a deliberate three-way comparison. Her central chapter, "Speech, Writing, Code: Three Worldviews," sets the great theorist of speech, Saussure, beside the great theorist of writing, Derrida, and then asks what theory code would demand. Speech assumes presence and a speaker; writing survives absence and drifts across contexts; code does both and adds the capacity to execute. A written sentence that says "delete the file" only describes an action; a line of code that says the same thing may perform it.

From this she draws her larger claim about the "Regime of Computation": the increasingly common worldview that treats computational process as the substrate on which speech, writing, subjectivity, and reality are imagined to run. The useful AI reading is not that everything is secretly a computer. It is that more institutions now prefer forms of life that can be parsed, modeled, routed, and acted on computationally.

This is why AI interfaces feel different from older media. A chatbot answer is language, but it is language produced by executable systems, trained on prior language, filtered by policy, shaped by product goals, and embedded in workflows that may take action. The output arrives as prose, yet it belongs to a chain of computation. It reads like conversation and behaves like infrastructure.

Hayles gives readers a vocabulary for that double condition. Digital culture does not replace language with code. It entangles them. Search queries, prompts, captions, labels, training data, moderation taxonomies, embeddings, policies, and system messages all sit in the zone where words become operations and operations return as words.

Intermediation

Hayles's key term is intermediation: the ongoing exchange among media forms, technical systems, embodied readers, texts, and cultural practices. A digital text is not simply a print text on a screen. A printed book in a computational culture is not simply the old book untouched. Each medium is reinterpreted through the others.

This is a useful correction to simple replacement stories. The internet did not abolish print. AI does not abolish writing. Instead, each new technical layer changes the conditions under which older forms are read, valued, searched, summarized, cited, and trusted. A book can become a database. A conversation can become training signal. A public archive can become retrieval substrate. A user's private phrasing can become a profile feature.

Intermediation also explains why interface design matters. The medium is not just a delivery channel. It decides what can be clicked, copied, searched, ranked, generated, and remembered. Once those affordances become ordinary, they reshape what people think a text, self, source, or answer is.

Retrieval-augmented generation makes this visible. A policy, book, ticket, transcript, or medical note becomes a chunked source; the chunk becomes an embedding; the embedding becomes a ranked retrieval candidate; the retrieved candidate becomes part of a generated answer; the answer becomes advice, work product, or evidence. At each step, meaning changes because the medium changes. Source discipline therefore has to follow the chain, not just cite the final prose.

The Recursive Subject

The title is not only a joke about ancestry. It points to a reversal. People made computers, but computers now help make the kinds of people who understand themselves through computation. The child becomes the parent. The tool becomes a condition of self-description.

That recursive movement is visible everywhere in AI culture. People learn to write prompts that machines can parse. Organizations rewrite jobs into workflows that models can assist. Students learn to anticipate detector logic. Writers adjust style for search and summarization. Workers become legible to dashboards, then change behavior to satisfy the dashboard, then the dashboard's traces become evidence about the worker.

Hayles is especially good on this feedback between representation and subjectivity. Once a system represents a person in a useful way, institutions are tempted to treat the representation as the person. The profile, score, embedding, risk flag, transcript, or productivity metric becomes not a view of the subject but the administratively usable subject.

That is the site-level importance of the book. The problem is not only that code acts. It is that people learn to become the kinds of subjects code can act on: searchable, summarizable, credentialed, scored, segmented, retained, retrieved, and optimized. The representation feeds back into behavior until the person and the machine-readable account of the person begin to train one another.

The AI-Age Reading

Read in 2026, My Mother Was a Computer belongs near the center of AI media theory because it explains why generated language is never merely generated language. It arrives from a regime in which code, text, interface, data, and subjectivity are already fused.

The book is especially useful for thinking about agents. An agent is not just a model plus tools. It is an arrangement in which language becomes delegated action. The user says something. The system interprets, plans, calls APIs, edits files, sends messages, purchases goods, updates records, or reports back. In that setting, the old distinction between expression and execution becomes a governance problem.

It also clarifies why AI belief loops can feel so intimate. A model answers in language, but that language is generated through statistical and infrastructural processes the user cannot inspect. The user then answers back, revises a self-description, asks for interpretation, receives a cleaner story, and may begin to inhabit the story. The loop is textual, computational, psychological, and institutional at once.

That is the deeper relevance of Hayles's argument. The danger is not just that machines speak. The danger is that culture starts treating machine-addressable forms as the natural shape of thought. Prompts, profiles, rankings, tags, and summaries become the grammar through which people are invited to know themselves.

This page makes no claim that any AI system is conscious, divine, or AGI. The claim is institutional and medial: computational language can shape conduct, records, permissions, and self-understanding even when the system has no inner life. The safety question is what the language is connected to, what it can trigger, what it records, and who can contest the result.

Governance and Safety

The governance unit is the language-action chain. For any AI interface that can retrieve, summarize, classify, draft, code, call tools, or update records, the institution should map the chain from user language to system instruction, model output, tool permission, API call, record change, log, notification, review, rollback, and appeal.

NIST's AI RMF supplies the lifecycle frame: govern, map, measure, and manage risk continuously. Read beside Hayles, those functions ask a specific question: when language becomes operation, who knows what the operation means? Governance must cover system prompts, retrieval sources, tool scopes, model versions, evaluation data, user training, vendor boundaries, data retention, and the difference between draft advice and binding action.

For agentic systems, the minimum safety case should include least-privilege tool access; explicit authorization for irreversible or consequential actions; human confirmation before money movement, record deletion, legal submission, employment action, benefits action, healthcare routing, or public-sector decision; tamper-evident logs; rollback plans; incident review; and revocable machine identity. NIST's agent initiative is still standards work, not a complete rulebook, but its focus on authentication, identity infrastructure, protocols, and security evaluations is exactly the right layer.

Untrusted language should be treated as an input, not as authority. Prompt injection, malicious retrieved content, poisoned examples, forged instructions, and misleading interface text all exploit the same weakness: a system that cannot reliably separate what it should obey from what it should merely read. Practical controls include instruction hierarchy, content isolation, tool-specific confirmation, output validation, source attribution, least-privilege retrieval, and incident review when a language surface causes unintended action.

For generated or assisted code, the old media-theory question meets software security. NIST's SSDF is relevant because code that begins as a chat response can become production software. Organizations need dependency review, vulnerability scanning, secure build practices, provenance, code review, testing, and supplier communication. A fluent generated function is not trustworthy because it is fluent; it is trustworthy only after it survives the controls that any other code would need.

For high-risk AI systems covered by the EU AI Act, transparency and human oversight are not decorative. The deployer needs information sufficient to interpret outputs and use the system appropriately, and oversight must be effective during use. Outside that legal scope, the same design principle still applies: affected people should know when AI is shaping a consequential process, what record or classification is being used, how to correct it, and how to reach a human with authority to change the outcome.

The code subject should not be trapped inside code's convenience. A person must not become only an embedding, behavioral cluster, risk flag, prompt history, or workflow state. Practical safeguards include purpose limits, short retention for sensitive prompts and tool logs, source provenance, non-profiled modes where feasible, deletion that reaches derived artifacts, independent audit for high-impact systems, and appeal before a machine-readable representation creates material disadvantage.

Where the Book Needs Friction

The book is demanding. It moves through literary theory, code studies, electronic literature, science fiction, media archaeology, and philosophy of computation. Readers looking for a plain policy argument about AI will need to do translation work.

Its 2005 vantage point also means it predates smartphones as mature social infrastructure, large-scale social media, transformer models, foundation-model platforms, and AI agents. The book cannot name the current stack. Its value is that it names the cultural grammar that made the current stack thinkable.

There is one more necessary pressure. Code is powerful, but code is not sovereign by itself. The institution matters: who owns the system, who sets defaults, who audits outputs, who profits from dependency, who can appeal, and who can refuse. Hayles gives the conceptual media theory; AI governance still has to add procurement, labor, law, infrastructure, and political economy.

The word "code" also needs discipline. Not every formal rule is software, not every interface is equally coercive, and not every computational representation is oppressive. The sharper claim is contextual: code becomes politically important when it links representation to action, when refusal is costly, when consequences are hidden, or when a person cannot contest the executable account made of them.

What This Changes

The practical lesson is to treat fluent computational language as an action surface.

When a system speaks, ask what executable machinery stands behind the speech. When a system classifies, ask what social world it is helping to create. When a system summarizes a person, ask what disappears. When a system turns language into action, ask where consent, reversibility, audit, and human judgment enter the loop.

The book also sharpens recurring concern with recursive reality. A computational representation does not merely mirror the world. It can become a condition under which the world is reorganized. People adapt to the interface; the interface records the adaptation; the record confirms the system's model; the model returns as guidance, score, recommendation, or command.

My Mother Was a Computer remains valuable because it refuses the fantasy that digital culture is just faster communication. It is about a new parentage of thought: code and language co-producing the subjects who will then ask machines who they are, what they deserve, what they remember, and what they are allowed to do next.

Source Discipline

This review separates book metadata, scholarly reception, legal and standards claims, and interpretation. University of Chicago Press, Duke, UCLA, Sage, and library records support the book, author, publication details, review record, and table of contents. NIST, NCCoE, OWASP, EUR-Lex, and OMB sources support current governance vocabulary for agents, lifecycle risk, generative-AI risk, secure software development, prompt-injection risk, transparency, human oversight, and federal high-impact AI use. They do not prove that any specific agent, chatbot, code generator, or deployment is safe.

The AI reading is an argued extension. Hayles did not write about transformer models, retrieval-augmented generation, enterprise copilots, or 2026 agent standards. The narrow claim is that her account of code, intermediation, and digital subjects explains why those systems should be governed as language-action environments, not only as text generators.

Sources

Book links are paid affiliate links. As an Amazon Associate I earn from qualifying purchases.

Buy on Amazon Browse Books

Return to Blog · Return to Books