Immutable Selves: A Functional Approach to Digital Identity through Clojure Principles

SUMMARY

Scarlett Dame, a systems designer and founder of Sic, discusses applying Clojure's immutability principles to digital identity, modeling human and AI selves as append-only logs for secure, verifiable experiences.

STATEMENTS

Identity in digital systems is often treated as mutable state, but it should be viewed as an append-only log of experiences that compiles into a single source of truth over time.
Traditional identification, like IDs or AI models, represents claims by authorities at a specific point, not absolute truth, highlighting the need for explicit state management.
Clojure's functional principles—immutability, explicit state, and pure functions—enable a design pattern called "reified change" for handling identity through deterministic rendering and transactions.
Human identity experiences form an append-only log that renders into identification, allowing deterministic queries for privileges like driving based on past events.
In enterprise recruiting, deepfakes enable impersonation, but immutable logs establish continuity across touchpoints, rendering identification from interaction histories.
Immutability in identity systems provides equality through simple log comparisons, provenance for auditing changes, and versioning like forking data structures.
For AI identity, the source of truth is unclear due to hidden memories, but append-only RDF and Git logs create deterministic, shareable AI individuality.
The talk itself was generated using this pattern: research extracted to RDF, iterated via AI on voice memos, producing versioned slides as compiled snapshots.
Append-only logs in identity avoid mutable pitfalls, enabling generative testing, decentralization, and infinite scale, though they require centralized transactors for consistency.
Identity, whether human or AI, is a state machine best managed immutably, unlocking trust through auditability and referential integrity across domains.

IDEAS

Personal history at Clojure/conj illustrates identity as evolving touchpoints, not erasable mutable state, challenging how we forget or rewrite past selves.
Fake IDs and ChatGPT personas reveal identity as authority claims, not inherent truth, emphasizing snapshots over eternal entities.
Synthetic identities can mimic sameness via credentials or create unique individuality, blurring lines between human and AI personas in functional systems.
Backbone.js's mutate-everything model contrasts with React's single source of truth, inspiring Clojure's tool-based reified change for identity without frameworks.
Experiences compile into identity like code renders UI, turning interactions into transactions that append to logs, looping state explicitly.
Deepfake fraud in job interviews exploits mutable records, but continuity via immutable logs verifies presence across video, docs, and in-person stages.
Clojure's Datomic setup renders interaction logs to device-readable identification, providing equality, provenance, and decentralization for human trust.
AI assistants vary outputs due to hidden memories; explicit RDF/Git logs make memory deterministic, seeding consistent responses from shared snapshots.
Talk preparation via AI-RDF iteration shows documents as versioned assets, evolving from narrative anchors through transactions rather than static edits.
Demo queries trace talk evolution, conviction metrics, and entity relations, treating knowledge graphs as queryable histories for generative storytelling.

INSIGHTS

Modeling identity as immutable append-only logs shifts from fragile mutable objects to auditable state machines, inherently securing provenance and equality.
Functional principles transcend stacks, applying reified change to both Datomic for human ID and RDF/Git for AI memory, unifying trust across domains.
Experiences as transactions reveal identity's narrative core, compiling privileges deterministically while enabling forking for contextual perspectives.
Hidden AI memories fragment individuality; explicit, versioned logs foster shareable, deterministic agents that evolve without losing traceability.
Immutability trades distributed writes for infinite read scale, prioritizing auditability over speed in high-stakes identity systems.
Narrative anchors in ontologies steer idea evolution, turning raw research into refined assets via iterative AI extraction, mirroring identity's growth.

QUOTES

"Identity is not mutable state, right? I'd really like to forget some of the things that happened in the past, but the fact is that there's these touch points and they're individual append only moments in our lives."
"Experience is an appendon log that compiles to identity which is probably the nerdiest thing I've ever said."
"We found that there are bad actors deep faking candidates in enterprise recruiting processes."
"My AI does not do the same thing as your AI... even though we all see the same chat input what's behind it is very very different and that's currently hidden by the interface."
"One thing identity whether human or AI should be modeled as an appendon log that compiles to state not as mutable objects. This single shift unlocks everything else."

HABITS

Compile research into RDF extracts and initial commits before iterating with AI on voice memos for content refinement.
Use narrative anchors as steering functions to thread ideas from strategy through architecture in document hierarchies.
Narrate long voice memos to capture evolving thoughts, then perform transcript extractions for automated slide updates.
Query knowledge graphs iteratively to trace changes, grouping evolutions into phases for better understanding.
Add metrics like conviction levels during ontology passes to quantify idea impact and escalation paths.

FACTS

Deepfakes have been used to impersonate job candidates through multiple interview stages, leading to fraudulent employment.
Clojure/conj attendees in 2013 saw Scarlett Dame pre-transition, evolving to talks in 2019 and 2025, spanning over a decade.
AI outputs vary significantly across users despite identical prompts due to proprietary, hidden memory states.
Traditional IDs require source verification like watermarks, lacking simple hash comparisons possible with immutable logs.
RDF triples in named graphs enable assertions and retractions with provenance, mirroring Datomic's entity-attribute-value transactions.

REFERENCES

Clojure principles: immutability, explicit state, functional composition, data-first design.
Vouch.io (now Be Recognized): immutable identification for human-device recognition in enterprise.
Sic (aswritten.ai): AI memory using narrative-driven knowledge graphs for organizational storytelling.
Datomic: append-only datalog for querying and rendering interaction logs to identification.
RDF and Git: for AI memory logs, with SPARQL queries compiling to deterministic snapshots.
Luke VanderHart's talk: inspiration for append-only transaction history and idea escalation frameworks.

HOW TO APPLY

Establish an append-only log as the single source of truth, capturing experiences or interactions as immutable events with timestamps.
Query the log at a specific point in time to compile a snapshot, rendering it deterministically to a surface like identification or AI response.
Handle user or agent interactions as pure functions that generate transactions, appending new events back to the log without mutating existing state.
Use tools like Datomic for human systems or RDF/Git for AI to ensure provenance, enabling audits of who created changes and versioning via forks.
Implement generative testing by creating varied data structures from the log, verifying rendered outputs for equality and decentralization across clients.

ONE-SENTENCE TAKEAWAY

Embrace immutable append-only logs for identity to unlock verifiable, scalable trust in human and AI systems.

RECOMMENDATIONS

Adopt reified change patterns in identity projects, starting with Clojure tools for explicit state over mutable databases.
Verify continuity in high-stakes processes like recruiting by rendering interaction logs to cross-checkable device identifications.
Build AI memory systems with RDF/Git to make hidden states explicit, ensuring deterministic outputs from shared snapshots.
Iterate content creation via AI-narrated extractions, treating documents as versioned compilations for narrative steering.
Prioritize immutability in designs to gain free benefits like provenance and infinite scaling, despite centralized write bottlenecks.

MEMO

In a world where deepfakes unravel corporate hiring and AI assistants deliver inconsistent advice, Scarlett Dame argues for a radical rethink of digital identity. Drawing from her evolution at Clojure/conj—from a 2013 attendee pre-transition to today's founder of Sic—Dame posits that identity isn't a changeable record but an immutable chronicle of moments. "Experience is an append-only log that compiles to identity," she declares, invoking Clojure's functional ethos to reframe selves as verifiable state machines.

At the heart of her vision is "reified change," a pattern echoing Clojure's tools like Datomic, where interactions become transactions appending to a log. For humans, this counters fraud in enterprise recruiting, where impostors deepfake interviews only to vanish on day one. Dame's former role at Vouch.io (now Be Recognized) built such systems: government IDs, video calls, and job offers feed into logs, rendering a "deterministic UI" of privileges—proving you're the same person across touchpoints via simple hash comparisons.

Extending to AI, Dame tackles the opacity of tools like ChatGPT, where hidden memories yield erratic results. Her startup, Sic, uses RDF triples in Git repositories to craft "narrative-driven knowledge graphs," giving agents persistent individuality. A demo unveils this magic: queries trace her talk's evolution from raw research to polished slides, grouping changes into phases and even gauging "conviction" in ideas. It's proof that AI memory, once ephemeral, can be audited like code commits.

Yet Dame confronts the shadows. What if immutable logs entrench bias from flawed institutions? Her response: technologists must define the "black box" boundary, owning what surfaces from the unalterable truth below. As a trans woman, her lived shifts inform this contextual framing—identity evolves, but its history endures, empowering users with hardware-controlled logs over centralized vulnerabilities.

Ultimately, Dame's blueprint transcends Clojure, applicable via React or SPARQL. By modeling identities as compilable logs, we gain provenance, equality, and boundless scale. In an era of synthetic selves, this functional approach doesn't just secure trust; it humanizes the digital, letting stories unfold without erasure.