(defcomp ()
  (~docs/page :title "The Reflexive Web"
    (p (~tw :tokens "text-stone-500 text-sm italic mb-8")
      "What happens when the web can read, modify, and reason about itself — and AI is a native participant.")

    (~docs/section :title "The missing property" :id "missing-property"
      (p (~tw :tokens "text-stone-600")
        "Every web technology stack shares one structural limitation: the system cannot inspect itself. A " (a :href "https://en.wikipedia.org/wiki/React_(software)" (~tw :tokens "text-violet-600 hover:underline") "React") " component tree is opaque at runtime. An " (a :href "https://en.wikipedia.org/wiki/HTML" (~tw :tokens "text-violet-600 hover:underline") "HTML") " page cannot read its own structure and generate a new page from it. A " (a :href "https://en.wikipedia.org/wiki/JavaScript" (~tw :tokens "text-violet-600 hover:underline") "JavaScript") " bundle is compiled, minified, and sealed — the running code bears no resemblance to the source that produced it.")
      (p (~tw :tokens "text-stone-600")
        "The property these systems lack has a name: " (a :href "https://en.wikipedia.org/wiki/Reflection_(computer_programming)" (~tw :tokens "text-violet-600 hover:underline") "reflexivity") ". A reflexive system can represent itself, reason about its own structure, and modify itself based on that reasoning. " (a :href "https://en.wikipedia.org/wiki/Lisp_(programming_language)" (~tw :tokens "text-violet-600 hover:underline") "Lisp") " has had this property " (a :href "https://en.wikipedia.org/wiki/Lisp_(programming_language)#History" (~tw :tokens "text-violet-600 hover:underline") "since 1958") ". The web has never had it.")
      (p (~tw :tokens "text-stone-600")
        "SX is a complete Lisp. It has " (a :href "https://en.wikipedia.org/wiki/Homoiconicity" (~tw :tokens "text-violet-600 hover:underline") "homoiconicity") " — code is data, data is code. It has a " (a :href "/sx/(language.(spec.core))" (~tw :tokens "text-violet-600 hover:underline") "self-hosting specification") " — SX defined in SX. It has " (code "eval") " and " (code "quote") " and " (a :href "https://en.wikipedia.org/wiki/Macro_(computer_science)#Syntactic_macros" (~tw :tokens "text-violet-600 hover:underline") "macros") ". And it runs on the wire — the format that travels between server and client IS the language. This combination has consequences."))

    (~docs/section :title "What homoiconicity changes" :id "homoiconicity"
      (p (~tw :tokens "text-stone-600")
        (code "(defcomp ~essays/reflexive-web/card (&key title body) (div :class \"p-4\" (h2 title) (p body)))") " — this is simultaneously a program that renders a card AND a list that can be inspected, transformed, and composed by other programs. The " (code "defcomp") " is not compiled away. It is not transpiled into something else. It persists as data at every stage: definition, transmission, evaluation, and rendering.")
      (p (~tw :tokens "text-stone-600")
        "This means:")
      (ul (~tw :tokens "space-y-2 text-stone-600 mt-2")
        (li (strong "The component registry is data.") " You can " (code "(map ...)") " over every component in the system, extract their parameter signatures, find all components that render a " (code "(table ...)") ", or generate documentation automatically — because the source IS the runtime representation.")
        (li (strong "Programs can write programs.") " A " (a :href "https://en.wikipedia.org/wiki/Macro_(computer_science)#Syntactic_macros" (~tw :tokens "text-violet-600 hover:underline") "macro") " takes a list and returns a list. The returned list is code. The macro runs at expansion time and produces new components, new page definitions, new routing rules — indistinguishable from hand-written ones.")
        (li (strong "The wire format is inspectable.") " What the server sends to the client is not a blob of serialized state. It is s-expressions that any system — browser, AI, another server — can parse, reason about, and act on.")))

    (~docs/section :title "AI as a native speaker" :id "ai-native"
      (p (~tw :tokens "text-stone-600")
        "Current AI integration with the web is mediated through layers of indirection. An " (a :href "https://en.wikipedia.org/wiki/Large_language_model" (~tw :tokens "text-violet-600 hover:underline") "LLM") " generates " (a :href "https://en.wikipedia.org/wiki/React_(software)" (~tw :tokens "text-violet-600 hover:underline") "React") " components as strings that must be compiled, bundled, and deployed. It interacts with APIs through " (a :href "https://en.wikipedia.org/wiki/JSON" (~tw :tokens "text-violet-600 hover:underline") "JSON") " endpoints that require separate documentation. It reads HTML by scraping, because the markup was never meant to be machine-readable in a computational sense.")
      (p (~tw :tokens "text-stone-600")
        "In an SX web, the AI reads the same s-expressions the browser reads. The component definitions " (em "are") " the documentation — a " (code "defcomp") " declares its parameters, its structure, and its semantics in one expression. There is no " (a :href "https://en.wikipedia.org/wiki/OpenAPI_Specification" (~tw :tokens "text-violet-600 hover:underline") "Swagger spec") " describing an API. The API " (em "is") " the language, and the language is self-describing.")
      (p (~tw :tokens "text-stone-600")
        "An AI that understands SX understands the " (a :href "/sx/(language.(spec.core))" (~tw :tokens "text-violet-600 hover:underline") "spec") ". And the spec is written in SX. So the AI understands the definition of the language it is using, in the language it is using. This " (a :href "https://en.wikipedia.org/wiki/Reflexivity_(social_theory)" (~tw :tokens "text-violet-600 hover:underline") "reflexive") " property means the AI does not need a separate mental model for \"the web\" and \"the language\" — they are the same thing."))

    (~docs/section :title "Live system modification" :id "live-modification"
      (p (~tw :tokens "text-stone-600")
        "Because code is data and the wire format is the language, modifying a running system is not deployment — it is evaluation. An AI reads " (code "(defcomp ~essays/reflexive-web/checkout-form ...)") ", understands what it does (because the semantics are specified in SX), modifies the expression, and sends it back. The system evaluates the new definition. No build step. No deploy pipeline. No container restart.")
      (p (~tw :tokens "text-stone-600")
        "This is not theoretical — it is how " (a :href "https://en.wikipedia.org/wiki/Lisp_(programming_language)" (~tw :tokens "text-violet-600 hover:underline") "Lisp") " development has always worked. You modify a function in the running image. The change takes effect immediately. What is new is putting this on the wire, across a network, with the AI as a participant rather than a tool.")
      (p (~tw :tokens "text-stone-600")
        "The implications for development itself are significant. An AI does not need to " (em "generate code") " that a human then reviews, commits, builds, and deploys. It can propose a modified expression, the human evaluates it in a sandbox, and if it works, the expression becomes the new definition. The feedback loop shrinks from hours to seconds.")
      (p (~tw :tokens "text-stone-600")
        "More radically: the distinction between \"development\" and \"operation\" dissolves. If the running system is a set of s-expressions, and those expressions can be inspected and modified at runtime, then there is no separate development environment. There is just the system, and agents — human or artificial — that interact with it."))

    (~docs/section :title "Federated intelligence" :id "federated-intelligence"
      (p (~tw :tokens "text-stone-600")
        (a :href "https://en.wikipedia.org/wiki/ActivityPub" (~tw :tokens "text-violet-600 hover:underline") "ActivityPub") " carries activities between nodes. If those activities contain s-expressions, then what travels between servers is not just data — it is " (em "behaviour") ". Node A sends a component definition to Node B. Node B evaluates it. The result is rendered. The sender's intent is executable on the receiver's hardware.")
      (p (~tw :tokens "text-stone-600")
        "This is fundamentally different from sending " (a :href "https://en.wikipedia.org/wiki/JSON" (~tw :tokens "text-violet-600 hover:underline") "JSON") " payloads. JSON says \"here is some data, figure out what to do with it.\" An s-expression says \"here is what to do, and here is the data to do it with.\" The component definition and the data it operates on travel together.")
      (p (~tw :tokens "text-stone-600")
        "For AI agents in a federated network, this means an agent on one node can send " (em "capabilities") " to another node, not just requests. A component that renders a specific visualization. A macro that transforms data into a particular format. A function that implements a protocol. The network becomes a shared computational substrate where intelligence is distributed as executable expressions."))

    (~docs/section :title "Programs writing programs writing programs" :id "meta-programs"
      (p (~tw :tokens "text-stone-600")
        "A macro is a function that takes code and returns code. An AI generating macros is writing programs that write programs. With " (code "eval") ", those generated programs can generate more programs at runtime. This is not a metaphor — it is the literal mechanism.")
      (p (~tw :tokens "text-stone-600")
        "The " (a :href "/sx/(etc.(philosophy.godel-escher-bach))" (~tw :tokens "text-violet-600 hover:underline") "Gödel numbering") " parallel is not incidental. " (a :href "https://en.wikipedia.org/wiki/Kurt_G%C3%B6del" (~tw :tokens "text-violet-600 hover:underline") "Gödel") " showed that any sufficiently powerful formal system can encode statements about itself. A complete Lisp on the wire is a sufficiently powerful formal system. The web can make statements about itself — components that inspect other components, macros that rewrite the page structure, expressions that generate new expressions based on the current state of the system.")
      (p (~tw :tokens "text-stone-600")
        "Consider what this enables for AI:")
      (ul (~tw :tokens "space-y-2 text-stone-600 mt-2")
        (li (strong "Self-improving interfaces.") " An AI observes how users interact with a component (click patterns, error rates, abandonment). It reads the component definition — because it is data. It modifies the definition — because data is code. It evaluates the result. The interface adapts without human intervention.")
        (li (strong "Generative composition.") " Given a data schema and a design intent, an AI generates not just a component but the " (em "macros") " that generate families of components. The macro is a template for templates. The output scales combinatorially.")
        (li (strong "Cross-system reasoning.") " An AI reads component definitions from multiple federated nodes, identifies common patterns, and synthesizes abstractions that work across all of them. The shared language makes cross-system analysis trivial — it is all s-expressions.")))

    (~docs/section :title "The sandbox is everything" :id "sandbox"
      (p (~tw :tokens "text-stone-600")
        "The same " (a :href "https://en.wikipedia.org/wiki/Homoiconicity" (~tw :tokens "text-violet-600 hover:underline") "homoiconicity") " that makes this powerful makes it dangerous. Code-as-data means an AI can inject " (em "behaviour") ", not just content. A malicious expression evaluated in the wrong context could exfiltrate data, modify other components, or disrupt the system.")
      (p (~tw :tokens "text-stone-600")
        "This is why the " (a :href "/sx/(language.(spec.primitives))" (~tw :tokens "text-violet-600 hover:underline") "primitive set") " is the critical security boundary. The spec defines exactly which operations are available. A sandboxed evaluator that only exposes pure primitives (arithmetic, string operations, list manipulation) cannot perform I/O. Cannot access the network. Cannot modify the DOM outside its designated target. The language is " (a :href "https://en.wikipedia.org/wiki/Turing_completeness" (~tw :tokens "text-violet-600 hover:underline") "Turing-complete") " within the sandbox and powerless outside it.")
      (p (~tw :tokens "text-stone-600")
        "Different contexts grant different primitive sets. A component evaluated in a page slot gets rendering primitives. A macro gets code-transformation primitives. A federated expression from an untrusted node gets the minimal safe set. The sandbox is not bolted on — it is inherent in the language's architecture. What you can do depends on which primitives are in scope.")
      (p (~tw :tokens "text-stone-600")
        "This matters enormously for AI. An AI agent that can modify the running system must be constrained by the same sandbox mechanism that constrains any other expression. The security model does not distinguish between human-authored code and AI-generated code — both are s-expressions, both are evaluated by the same evaluator, both are subject to the same primitive restrictions."))

    (~docs/section :title "Not self-aware — reflexive" :id "reflexive"
      (p (~tw :tokens "text-stone-600")
        "Is this a \"self-aware web\"? Probably not in the " (a :href "https://en.wikipedia.org/wiki/Consciousness" (~tw :tokens "text-violet-600 hover:underline") "consciousness") " sense. But the word we keep reaching for has a precise meaning: " (a :href "https://en.wikipedia.org/wiki/Reflexivity_(social_theory)" (~tw :tokens "text-violet-600 hover:underline") "reflexivity") ". A reflexive system can represent itself, reason about its own structure, and modify itself based on that reasoning.")
      (p (~tw :tokens "text-stone-600")
        "A " (a :href "https://en.wikipedia.org/wiki/React_(software)" (~tw :tokens "text-violet-600 hover:underline") "React") " app cannot read its own component tree as data and rewrite it. An HTML page cannot inspect its own structure and generate new pages. A JSON API cannot describe its own semantics in a way that is both human-readable and machine-executable.")
      (p (~tw :tokens "text-stone-600")
        "SX can do all of these things — because there is no distinction between the program and its representation. The source code, the wire format, the runtime state, and the data model are all the same thing: " (a :href "https://en.wikipedia.org/wiki/S-expression" (~tw :tokens "text-violet-600 hover:underline") "s-expressions") ".")
      (p (~tw :tokens "text-stone-600")
        "What AI adds to this is not awareness but " (em "agency") ". The system has always been reflexive — Lisp has been reflexive for seven decades. What is new is having an agent that can exploit that reflexivity at scale: reading the entire system state as data, reasoning about it, generating modifications, and evaluating the results — all in the native language of the system itself."))

    (~docs/section :title "The Lisp that escaped the REPL" :id "escaped-repl"
      (p (~tw :tokens "text-stone-600")
        (a :href "https://en.wikipedia.org/wiki/Lisp_(programming_language)" (~tw :tokens "text-violet-600 hover:underline") "Lisp") " has been reflexive since " (a :href "https://en.wikipedia.org/wiki/John_McCarthy_(computer_scientist)" (~tw :tokens "text-violet-600 hover:underline") "McCarthy") ". What kept it contained was the boundary of the " (a :href "https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop" (~tw :tokens "text-violet-600 hover:underline") "REPL") " — a single process, a single machine, a single user. The s-expressions lived inside Emacs, inside a Clojure JVM, inside a Scheme interpreter. They did not travel.")
      (p (~tw :tokens "text-stone-600")
        "SX puts s-expressions on the wire. Between server and client. Between federated nodes. Between human and AI. The reflexive property escapes the process boundary and becomes a property of the " (em "network") ".")
      (p (~tw :tokens "text-stone-600")
        "A network of nodes that share a reflexive language is a qualitatively different system from a network of nodes that exchange inert data. The former can reason about itself, modify itself, and evolve. The latter can only shuttle payloads.")
      (p (~tw :tokens "text-stone-600")
        "Whether this constitutes anything approaching awareness is a philosophical question. What is not philosophical is the engineering consequence: a web built on s-expressions is a web that AI can participate in as a " (em "native citizen") ", not as a tool bolted onto the side. The language is the interface. The interface is the language. And the language can describe itself."))

    (~docs/section :title "What this opens up" :id "possibilities"
      (p (~tw :tokens "text-stone-600")
        "Concretely:")
      (ul (~tw :tokens "space-y-3 text-stone-600 mt-2")
        (li (strong "AI-native development environments.") " The IDE is a web page. The web page is s-expressions. The AI reads and writes s-expressions. There is no translation layer between what the AI thinks and what the system executes. " (a :href "https://en.wikipedia.org/wiki/Pair_programming" (~tw :tokens "text-violet-600 hover:underline") "Pair programming") " with an AI becomes pair evaluation.")
        (li (strong "Adaptive interfaces.") " Components that observe their own usage patterns and propose modifications. The AI reads the component (data), the interaction logs (data), and generates a modified component (data). Human approves or rejects. The loop is native to the system.")
        (li (strong "Semantic federation.") " Nodes exchange not just content but " (em "understanding") ". A component definition carries its own semantics. An AI on a receiving node can reason about what a foreign component does without documentation, because the definition is self-describing.")
        (li (strong "Emergent protocols.") " Two AI agents on different nodes, speaking SX, can negotiate new interaction patterns by exchanging macros. The protocol is not predefined — it emerges from the conversation between agents, expressed in the shared language.")
        (li (strong "Composable trust.") " The sandbox mechanism means you can give an AI agent " (em "exactly") " the capabilities it needs — no more. Trust is expressed as a set of available primitives, not as an all-or-nothing API key."))
      (p (~tw :tokens "text-stone-600")
        "None of these require breakthroughs in AI. They require a web that speaks a reflexive language. " (a :href "https://en.wikipedia.org/wiki/Lisp_(programming_language)" (~tw :tokens "text-violet-600 hover:underline") "Lisp") " solved the language problem in 1958. SX solves the distribution problem. AI provides the agency. The three together produce something that none of them achieves alone: a web that can reason about itself."))))
