Designet er koden

Hvordan cellulære automaters logik vil omforme agentiske designsystemer – og hvorfor fremtidens webudvikling måske allerede er skrevet i enkle regler

Der er en dybtgående forandring i gang i skæringspunktet mellem designsystemer, kunstig intelligens og beregningsteori. Den er så grundlæggende, at den udfordrer vores forståelse af, hvad "design" overhovedet betyder i en tid med autonome agenter.

I årtier har vi behandlet design og kode som adskilte discipliner – design som menneskelig kreativitets og æstetisk dømmekrafts domæne, kode som den mekaniske oversættelse af de idéer til udførbar form. Men i takt med at AI-agenter i stigende grad selv sammensætter brugergrænseflader, bruger designsystemer som maskinlæsbar infrastruktur og genererer kode ud fra semantiske tokens, nærmer vi os et konvergenspunkt, der gentager en meget ældre idé fra beregningsteorien.

Den idé? Designet er koden.

Det er ikke bare en fængende frase. Det er en erkendelse af, at vi måske er på vej mod en verden, hvor designsystemer fungerer som cellulære automater – simple regler, der giver anledning til komplekse, emergente adfærdsmønstre. Hvor skellet mellem at "designe" noget og at "programmere" det helt forsvinder. Hvor autonome agenter ikke bare bruger designsystemer, men er designsystemer i aktion.

Dette blogindlæg udforsker de dybe forbindelser mellem cellulære automater, emergent adfærd og fremtidens agentiske designsystemer. Vi følger de teoretiske rødder fra von Neumanns selvreplikerende maskiner til nutidens svärme af AI-agenter.

Vi ser på, hvordan Drupal og moderne CMS-platforme integrerer AI gennem moduler som Schema.org Blueprints og Drupal AI. Og vi overvejer, hvad det hele betyder for designere, udviklere og fremtidens digitale produktudvikling.

Cellulære automater og emergensens logik

Skønheden i simple regler

I 1970 introducerede matematikeren John Conway Game of Life – et "nul-spiller-spil", der skulle blive et af de mest studerede systemer inden for beregningsteori. Reglerne er forbløffende simple:

1. Enhver levende celle med færre end to levende naboer dør (underbefolkning)
2. Enhver levende celle med to eller tre levende naboer overlever
3. Enhver levende celle med flere end tre levende naboer dør (overbefolkning)
4. Enhver død celle med præcis tre levende naboer bliver levende (reproduktion)

Ud af disse fire regler – udtrykt i en håndfuld binære betingelser – opstår et forbløffende univers af kompleksitet. Gliders bevæger sig henover uendelige gitre. Oscillatorer pulserer i evige rytmer. Guns udsender strømme af mønstre ud i det cellulære rum. Og mest bemærkelsesværdigt er det bevist, at Game of Life er Turing-komplet: alt, hvad der kan beregnes algoritmisk, kan i princippet beregnes i Conways simple gitter.

Figur 1: Gospers svæveflyverkanon i Conways Game of Life. Dette mønster producerer en kontinuerlig strøm af svævere – og viser, hvordan simple regler kan skabe uendelig, selvopretholdende kompleksitet.

Det er den første lektion i cellulære automater: kompleksitet er ikke en forudsætning for kompleks adfærd. Simple regler, der anvendes konsekvent på tværs af et underlag, kan give anledning til mønstre og adfærd, som ingen eksplicit har programmeret.

Langtons Loops og selvreplikation

I 1984 førte Christopher Langton dette princip videre med sine selvreplikerende loops – en cellulær automat, der demonstrerede egentlige principper for kunstigt liv. Hvor Conways Game of Life viser emergent kompleksitet, viser Langtons Loops emergent reproduktion.

Hvert loop består af en cyklisk grænse, der omslutter et "genom" kodet i celletilstande. Dette genom strømmer kontinuerligt rundt i loopet og ud langs en konstruktionsarm, som over 151 tidstrin bygger et datterloop. Når det er færdigt, skilles datteren fra sin forælder, og begge fortsætter med at replikere.

Figur 2: Langtons Loop i sin startkonfiguration. Den genetiske information cirkulerer gennem loopet og styrer opbygningen af datterloops via den fremskydende arm.

"Hvis en selvreproducerende maskine er mulig inden for en cellulær automat, så kan selve livet måske opnås af maskiner."

- Christopher Langton, "Studying Artificial Life with Cellular Automata" (1986)

Konsekvenserne er dybtgående. Langtons Loops viser, at selvreplikation hverken kræver de biologiske cellers kompleksitet eller den universelle konstruktionsevne i von Neumanns oprindelige design. Det kræver kun:

• Et sæt simple, lokale regler
• En mekanisme til at kode instruktioner
• En proces, hvormed disse instruktioner udføres

Reglerne er organismen. Designet er koden.

I 1999 introducerede Hiroki Sayama evoloops, varianter der inddrager strukturel opløselighed og fænotypiske interaktioner, hvilket muliggør spontane mutationer og evolutionær dynamik. Disse loops udvikler sig gennem direkte fysiske kollisioner under replikationen, hvilket fører til genotypevariationer, øget morfologisk mangfoldighed og voksende kompleksitet på tværs af generationer. I modsætning til Langtons faste replikation viser evoloops nedarvelige mutationer uden ekstern indgriben.

Regel 110 og universel beregning

Stephen Wolframs udforskning af elementære cellulære automater kulminerede i en forbløffende opdagelse: Regel 110, en af blot 256 mulige regler for den simpleste type endimensionel cellulær automat, er i stand til universel beregning.

Regel 110 kan specificeres fuldstændigt ved at angive udfaldet for hver af otte mulige kombinationer af en celle og dens to naboer. Alligevel kan denne trivielt simple regel – otte binære beslutninger – simulere en universel Turing-maskine.

Figur 3: Regel 110-cellulær automat. På trods af sin enkle definition udviser Regel 110 klasse 4-adfærd – komplekse mønstre, der hverken er helt stabile eller helt kaotiske – og er bevist at være Turing-komplet.

"Man behøver ikke noget, der ligner en hel computer-CPU, for at udføre universel beregning. Man behøver bare denne lille regel."

- Stephen Wolfram, "A New Kind of Science"

I 2004 offentliggjorde Matthew Cook et bevis for, at Regel 110 med et bestemt gentaget baggrundsmønster er Turing-komplet. Beviset viser, at Regel 110 kan emulere cykliske tag-systemer, som igen kan emulere enhver Turing-maskine. Blandt de 88 mulige unikke elementære cellulære automater er Regel 110 den eneste, hvor Turing-kompletthed er direkte bevist.

Det princip om beregningsmæssig ækvivalens, som Wolfram har foreslået, peger på noget endnu mere radikalt: Systemer over en minimal tærskel for kompleksitet er i bund og grund ligeværdige i deres beregningsmæssige evner. En menneskehjerne, et vejrsystem og Regel 110 er i en dyb forstand beregningsmæssigt ækvivalente.

0E0P-metacellen: ægte selvreplikation

I oktober 2018 fuldførte Adam P. Goucher konstruktionen af 0E0P-metacellen – et mønster i Conways Game of Life, som er i stand til ægte selvreplikation. I modsætning til tidligere metaceller, der krævede allerede eksisterende kopier i nærheden, kan 0E0P-metacellen bygge kopier af sig selv fra bunden, inklusive sit eget instruktionsbånd.

Dette resultat er en milepæl inden for kunstigt liv: Et system, der kan udbrede sig selv gennem et beregningsmæssigt substrat alene ved hjælp af lokale regler. Den 23. november 2013 byggede Dave Greene den første replikator i Game of Life, der skaber en komplet kopi af sig selv, inklusive instruktionsbåndet – og dermed viste han, at selv Conways simple todelte automat kan understøtte ubegrænset selvreproduktion.

Designsystemer som beregningsmæssige substrater

Fra Atomic Design til agentisk design

Brad Frosts Atomic Design-metode, som blev introduceret i 2013, revolutionerede vores måde at tænke designsystemer på. Ved at opdele grænseflader i atomer (grundlæggende elementer som knapper og inputfelter), molekyler (simple kombinationer), organismer (komplekse UI-sektioner), skabeloner (sidelayouts) og sider (endelige implementeringer) gav Atomic Design en hierarkisk struktur til at håndtere kompleksitet.

Men her er det bemærkelsesværdige, når man ser tilbage: Atomic Design indeholdt allerede principperne fra cellulære automater uden udtrykkeligt at erkende det.

"Når designsystemet er kedeligt, frigør det designere og udviklere til at lave det nye og løse nye problemer. Designsystemet bærer byrden af det kedelige, så designere og udviklere ikke behøver at gøre det."

- Josh Clark, "The Most Exciting Design Systems Are Boring"

I februar 2023 skrev Brad Frost om "Design Systems in the Time of AI":

"AI er en helt naturlig bruger af designsystemer ... Faktum er, at en stor del af arbejdet med komponenter i et designsystem faktisk er mekanisk og forudsigeligt. Vi bruger allerede værktøjer som PlopJS til at spytte en komponent-skabelon ud, der passer til resten af biblioteket. Jeg ville gerne have AI's hjælp til at generere en masse af det gængse standardstof for mig."

- Brad Frost

Designsystemers mekaniske og forudsigelige natur er netop det, der gør dem egnede til drift i stil med cellulære automater. Når reglerne er klare, lokale og anvendt konsekvent, kan agenter arbejde selvstændigt – ligesom cellerne i Conways Game of Life ikke har brug for en central styring for at frembringe glidere og oscillatorer.

Det maskinlæsbare imperativ

Storybook MCP-initiativet (Model Context Protocol) er en afgørende udvikling i denne retning. Storybook MCP blev annonceret i slutningen af 2025 og giver AI-kodningsagenter maskinlæsbare komponentmetadata fra eksisterende Storybook-opsætninger.

Den vigtigste indsigt er, at agenter ikke har brug for rå kode eller visuel dokumentation. De har brug for:

• Komponentmanifester: Strukturerede metadata om hver enkelt komponent – dens props, varianter, bindinger til designtokens og brugseksempler
• Semantisk navngivning: Tokens rige på intention som action.primary.confirm, der formidler mening til agenter og ikke kun værdier
• Valideringsløkker: Evnen til at køre tests, se fejl og rette sig selv

"Storybook MCP hjælper agenter med at følge dine mønstre og bestå dine tests. Det giver dem to ting, de aldrig har haft før: maskinlæsbare komponentmetadata og en iterativ løkke til at hele egne fejl."

- Storybook-teamet

Storybook MCP indeholder en autonom korrektionsløkke. Den lader agenter køre dine komponenttests (interaktion og tilgængelighed), se, hvad der fejler, og rette deres egne fejl. En udvikler behøver først at træde til, når testene er bestået. Slut med at passe på prompts som en barnepige.

Det er netop arkitekturen i en cellulær automat anvendt på design: lokale regler (komponentspecifikationer), interaktion mellem naboer (kompositionsmønstre) og iterative opdateringer (validering og selvkorrektion).

Mit komponentmanifest som genom

Sammenligningen med Langtons løkker bliver endnu mere rammende, når vi ser på, hvordan komponentmanifester fungerer. I Langtons system indeholder det "genom", der er kodet i de cirkulerende celler, instruktionerne til at bygge en ny løkke. I et maskinlæsbart designsystem indeholder komponentmanifestet instruktionerne til at samle grænseflader.

Et komponentmanifest kan angive:

{
  "name": "Button",
  "variants": ["primary", "secondary", "destructive"],
  "sizes": ["sm", "md", "lg"],
  "props": {
    "label": "string",
    "disabled": "boolean",
    "onClick": "function"
  },
  "tokens": {
    "background": "color.action.primary",
    "borderRadius": "radius.md",
    "padding": "space.3"
  },
  "constraints": [
    "Must have accessible contrast ratio",
    "Label required for non-icon buttons",
    "Minimum touch target 44x44px"
  ],
  "examples": [
    { "variant": "primary", "label": "Submit", "size": "md" },
    { "variant": "destructive", "label": "Delete", "size": "sm" }
  ]
}

Dette manifest er på én gang en designspecifikation og eksekverbar kode – eller rettere: de instruktioner, som eksekverbar kode kan genereres ud fra. Agenten, der bruger manifestet, behøver ikke forstå æstetik eller brugeroplevelse i menneskelig forstand. Den skal følge reglerne, kombinere elementerne i overensstemmelse med deres begrænsninger og producere gyldige resultater.

Jeg er enig med Brad Frost i at bruge et yaml-format.

Drupal-komponenter bruger yaml-formatet. Noget i retning af

$schema: https://git.drupalcode.org/project/drupal/-/raw/HEAD/core/assets/schemas/v1/metadata.schema.json
name: Button
status: experimental
description: Use Bootstrap custom button styles for actions in forms, dialogs, and more with support for multiple sizes, states, and more.
props:
  type: object
  properties:
    html_tag:
      type: string
      title: The HTML tag to use for the button (button | a). Defaults to `button`.
      default: button
      enum:
        - button
        - a
    url:
      type: string
      title: URL Link
      description: URL link for the button when the HTML tag is an anchor link.
      $ref: "ui-patterns://url"
    color:
      type: string
      title: Color
      description: Bootstrap includes several predefined button styles, each serving its own semantic purpose, with a few extras thrown in for more control.
      default: ''
      enum:
        - ''
        - primary
        - secondary
        - success
        - danger
        - warning
        - info
        - dark
        - light
        - link
    outline:
      type: boolean
      title: Outline
      description: In need of a button, but not the hefty background colors they bring? Replace the default modifier classes with the .btn-outline-* ones to remove all background images and colors on any button.
      default: false
    size:
      type: string
      title: Size
      description: Bootstrap button size
      default: ''
      enum:
        - ''
        - btn-sm
        - btn-lg
    disabled:
      type: boolean
      title: Disabled
      description: Disabled button
      default: false
    button_utility_classes:
      type: array
      title: Utility Classes
      default: []
      items:
        type: 'string'
      description: An array of utility classes that can be used to add extra Bootstrap utility classes or custom classes to this component.
    attributes:
      type: object
      title: Attributes
      description: HTML attributes for the containing element.
      $ref: 'ui-patterns://attributes'
slots:
  content:
    type: string
    title: Content
    description: The content for the button
    minLength: 1
    examples:
      - Press
      - Submit now
      - Save
      - Login
      - Read more

Designet er koden.

• Varianter
• Tokens
• Props

• Begrænsninger (som vi kunne tilføje til komponenter)

• Regler for slots (hvad der må placeres i andre slots, eller hvad der må placeres i min slot)

• Regler

• Eksempler 

• Animationer  ( Tilladt eller anbefalet at bruge )

Se derefter og eksperimenter med adfærden.

som i https://storybook.demo.varbase.vardot.com/?path=/story/atoms-button--primary 

Design tokens som miljøvariabler

Design tokens er endnu en afgørende brik i puslespillet. I cellulære automater reagerer cellerne på deres nære omgivelser – naboercellernes tilstande. I designsystemer reagerer komponenterne på design tokens – de kontekstuelle værdier, der bestemmer deres udseende og adfærd.

Moderne token-arkitekturer bruger flere lag:

• Kerne-tokens: Rå værdier som color.blue.500: #3B82F6
• Semantiske tokens: Hensigtsdrevne referencer som color.action.primary: color.blue.500
• Komponent-tokens: Afgrænsede anvendelser som button.background.primary: color.action.primary

Når en agent genererer en Button-komponent, behøver den ikke vide, at "primary" betyder blå. Den skal blot henvise til button.background.primary og stole på, at token-systemet finder frem til den rigtige værdi. Miljøet (token-laget) rummer informationen; komponenten (cellen) skal bare reagere på den.

Værktøjer som Tokens Studio har udviklet sig til at behandle design tokens som beregningsgrafer med resolvere – noder, der træffer semantiske beslutninger om, hvilke basis-tokens der skal bruges ud fra konteksten. Det forvandler design tokens fra statiske værdier til dynamiske, regelbaserede systemer.

Drupal-økosystemet og AI-integration

Integrationen af AI i indholdsstyringssystemer er et perfekt laboratorium til at udforske princippet om, at "designet er koden". CMS'er som Drupal rummer allerede kernebegreberne: strukturerede indholdstyper, feltdefinitioner, relationer og regler for sammensætning.

Jeg havde aldrig troet, at vi kunne sige noget i den stil. For mig var det en kunstform i sig selv.

 Det ultimative computersæt, vi kunne have. Nogle udviklere, der lige så godt kunne komme fra fremtidens Star Trek, og som taler til computeren, så den programmerer for dem.

Agent Experience (AX) og den nye bruger

Design til maskiner

I begyndelsen af 2025 introducerede Mathias Biilmann, CEO i Netlify, begrebet "Agent Experience" (AX) – en ny disciplin, der handler om, hvordan AI-agenter interagerer med produkter og platforme.

Skiftet er grundlæggende. I årtier har UX (User Experience) optimeret til menneskelig erkendelse, opfattelse og adfærd. DX (Developer Experience) har optimeret til menneskelige udviklere, der bygger software. AX anerkender, at agenter er ved at blive de primære brugere af digitale systemer – og at de har helt andre behov:

• De går ikke op i visuel æstetik– kun i struktureret, maskinlæsbare data
• De navigerer ikke i grænseflader– de kalder API'er og bruger manifester
• De læser ikke dokumentation som mennesker– de har brug for maskinlæsbar kontekst
• De træffer ikke subjektive vurderinger– de følger regler og begrænsninger

"AI-agenter er ikke mennesker: De er ligeglade med, hvor stor en knap er, hvor læselig typografien er, hvor flot farvepaletten på din hjemmeside er, eller hvor prangende animationerne i din app er. Så hvad 'bekymrer' AI-agenter sig egentlig om? Det spørgsmål har i dag intet entydigt svar, men det bliver stadig vigtigere i de kommende år."

- AX-forskning

Svaret: tydelige regler, forudsigelig adfærd, velstruktureret data og feedbackloops, der gør det muligt for dem at kontrollere og rette deres egne handlinger.

Udfordringen med den dobbelte grænseflade

At designe til AX betyder at bygge to grænseflader på samme tid:

1. Grænseflade mellem menneske og agent: Her overvåger, godkender, redigerer og styrer mennesker agentens adfærd – "missionskontrol"-laget. Tænk dashboards og godkendelseskøer, ikke formularer og knapper.
2. Grænseflade mellem agent og system: Her arbejder agenter med API'er, databaser og værktøjer – det "operationelle" lag. Det skal være robust, veldokumenteret og optimeret til maskinel effektivitet.

Det afspejler arkitekturen i cellulære automater, hvor to forskellige perspektiver eksisterer side om side:

• Det lokale perspektiv: Hver celle (agent) følger enkle regler baseret på sine nærmeste naboer
• Det globale perspektiv: Komplekse mønstre opstår, som kun er synlige i stor skala

"Agent experience design (AX) bør give stor brugervenlighed for og af agenter. Derfor fører god AX til god brugeroplevelse (UX). Hvis AI-agenten støder på en brudt proces, en brudt protokol eller blot inkonsekvent ordbrug på tværs af systemer, kan den ikke udføre opgaven. Det er en dårlig oplevelse for agenten, som igen fører til en dårlig oplevelse for kunden eller medarbejderen."

- Kat Holmes, Chief Experience Officer, Salesforce

Fra UX til AX: Det digitale designs udvikling

Stigmergi og indirekte kommunikation

Et af de mest kraftfulde begreber fra sværmintelligens er stigmergi – indirekte koordinering gennem spor i omgivelserne. Myrer kommunikerer ikke direkte om, hvor der er mad; de efterlader duftspor, som andre myrer følger. Omgivelserne bliver et kommunikationsmedium.

I agentbaserede designsystemer tager stigmergi form af:

• Delte komponentbiblioteker: Agenter "ser", hvilke komponenter der findes, og hvordan de er blevet brugt
• Design tokens: Semantiske værdier, der gør designbeslutninger til kendsgerninger i omgivelserne
• Mønsterdokumentation: Brugseksempler, der fungerer som duftspor for fremtidige agenter
• Testsuiter: Valideringsregler, der afgrænser rummet af gyldige resultater
• Git-historik: En oversigt over tidligere beslutninger, som agenter kan støtte sig til

Når en agent genererer en brugerflade med en komponent, efterlader den spor – i kodebasen, i dokumentationen, i de mønstre, den etablerer. Fremtidige agenter, der møder lignende opgaver, bliver påvirket af disse spor, og det skaber en form for kollektiv intelligens, som ingen enkelt agent besidder.

Agentbaserede designmønstre

Andrew Ng og andre har identificeret fire centrale mønstre for agentbaserede AI-systemer:

1. Refleksion: AI'en vurderer sit eget output og forbedrer det trin for trin
2. Brug af værktøjer: AI'en arbejder sammen med eksterne værktøjer, API'er og systemer
3. Planlægning: AI en opdeler komplekse opgaver i delopgaver og udfører dem efter hinanden
4. Multi-agent: Flere specialiserede agenter samarbejder om komplekse opgaver

Disse mønstre svarer direkte til begreber fra cellulære automater:

Designet er koden – en dybere læsning

Hvad "Designet er koden" egentlig betyder

Når vi siger "designet er koden", fremsætter vi flere påstande på én gang:

1. Semantisk ækvivalens

Designbeslutninger bliver kørbare, når de er kodet korrekt. Et design token er ikke blot en værdi – det er en instruktion. En komponentspecifikation er ikke blot dokumentation – det er et program. Når agenter forbruger disse artefakter, udfører de designet lige så meget, som de implementerer det.

2. Generativ kapacitet

Ligesom Rule 110 kan beregne alt, hvad der kan beregnes, kan et tilstrækkeligt komplet designsystem generere enhver gyldig brugerflade. Systemet rummer potentialet for alle sine gyldige udtryk. Hvad der opstår, afhænger kun af begyndelsesbetingelserne (kravene) og reglerne (begrænsningerne).

3. Emergent kompleksitet

De mest sofistikerede brugerflader er ikke designet oppefra og ned; de opstår ved konsekvent anvendelse af enkle regler. En veldesignet knap, brugt konsekvent, skaber et sammenhængende visuelt sprog, uden at nogen eksplicit har planlagt den sammenhæng.

4. Beregningsmæssig irreducibilitet

Nogle designresultater kan ikke forudsiges uden faktisk at køre systemet. Du kan ikke vide, hvordan en brugerflade samlet af en agent kommer til at se ud, uden at lade agenten samle den. Det er Wolframs princip om beregningsmæssig irreducibilitet anvendt på design.

5. Selvmodifikation

Ligesom evoloops, der muterer under replikation, kan agent-klare designsystemer udvikle sig gennem brug. Komponenter genereret af agenter bliver en del af det bibliotek, som fremtidige agenter forbruger. Systemet lærer, tilpasser sig og vokser.

Metaforen om cellulære automater udvidet

Ud over metaforen: en reel konvergens

Men det er ikke blot en metafor. Konvergensen er reel og sker lige nu:

• Storybook MCP gør komponentbiblioteker til maskinlæsbare instruktioner, som agenter udfører
• Model Context Protocol standardiserer, hvordan agenter får adgang til værktøjer og kontekst – og skaber dermed et universelt substrat for agentiske operationer
• Multi-agent-arkitekturer fordeler arbejdet mellem specialiserede agenter (arkitekt, programmør, reviewer), der interagerer efter protokoller – som celler med differentierede funktioner
• Selvhelbredende loops lader agenter køre tests, opdage fejl og iterere – de samme feedbackmekanismer, som cellulære automater bruger til at udvikle stabile konfigurationer
• Schema.org Blueprints gør indholdsstrukturer maskinlæsbare og semantisk meningsfulde
• Drupal AI leverer infrastrukturen, så AI-agenter selvstændigt kan oprette, ændre og administrere indhold

Vi griber ikke "designet er koden" an som et filosofisk standpunkt. Vi bygger det som teknisk infrastruktur.

Konsekvenser og vejen frem

For designere

Designerens rolle forvandles fra "rektangelskaber" til "regeldefinerer". Som Brad Frost bemærkede:

"Designere og udviklere, der ser deres job som at skabe rektangler, har god grund til at være bekymrede. Men designere og udviklere, der ser deres job som at løse problemer – og som tilfældigvis må skabe eller håndtere nogle rektangler for at løse dem – har mindre at frygte."

- Brad Frost

I den agentbaserede fremtid vil designere:

• Definere semantiske tokens og deres indbyrdes relationer
• Fastlægge kompositionsbegrænsninger og mønstre
• Skabe valideringsregler, som agenter skal opfylde
• Kuratere og udvikle de regler, der styrer emergens
• Designe de feedbackmekanismer, der muliggør selvkorrektion
• Udforme de "fitnessfunktioner", der afgør, hvilke resultater der er acceptable

Det er design på et højere abstraktionsniveau – man designer de regler, der frembringer designs, frem for selve designene. Ligesom man definerer reglerne for en cellulær automat i stedet for at tegne hver enkelt celle for sig.

For udviklere

Udviklere bliver arkitekter af agentsystemer. Som Anthropic beskriver det:

"Softwareudvikling har vist bemærkelsesværdigt potentiale for LLM-funktioner, hvor mulighederne har udviklet sig fra kodefuldførelse til autonom problemløsning."

Udviklere får brug for at:

• Skabe maskinlæsbare grænseflader mellem agenter og systemer
• Designe feedbackloops og valideringsmekanismer
• Bygge den stillads, inden for hvilken emergent adfærd opstår
• Bevare menneskeligt tilsyn som den endelige dommer
• Definere de protokoller, agenter kommunikerer efter
• Implementere den "limkode", der forbinder forskellige agentsystemer

For webudvikling og CMS-platforme

Integrationen af AI i platforme som Drupal peger mod en fremtid, hvor:

• Indholdsmodeller bliver agentlæsbare gennem standarder som Schema.org
• Redaktionelle arbejdsgange bliver agentassisterede med AI-drevet udkast, moderering og optimering
• Søgning udvikler sig fra nøgleordsmatch til semantisk forståelse via embeddings og vektordatabaser
• Personalisering bliver autonom ved at agenter lærer brugernes præferencer og tilpasser indholdet i realtid
• Udviklingen accelererer i takt med at agenter genererer komponenter, tests og dokumentation

Drupal-økosystemets omfavnelse af AI – gennem moduler som Drupal AI, Drupal Canvas, Schema.org Blueprints og integrationen af AI-udbydere – viser, at denne fremtid allerede er ved at blive bygget.

For organisationer

Konkurrencefordelen tilfalder de organisationer, hvis designsystemer er mest "agentklare". Agentklare systemer kendetegnes ved:

• Fuld dækning af komponenters tilstande og varianter
• Semantisk navngivning, der formidler hensigt
• Maskinlæsbar dokumentation og kontekst
• Infrastruktur til validering og test
• Klare begrænsninger, der afgrænser rummet af gyldige output
• API'er designet til agentforbrug (AX-first)
• Schema.org-first-indholdsarkitekturer

Til fremtidens digitale produkter

Slutresultatet minder om en slags digital økologi: utallige agenter, der arbejder efter lokale regler og frembringer emergente grænseflader, som ingen enkelt designer eller udvikler har planlagt, men som alligevel hænger sammen, fordi de underliggende regler er solide.

Det er ikke så søgt, som det lyder. Det er præcis sådan, biologiske systemer fungerer, sådan byer vokser, og sådan markeder virker. Spørgsmålet er ikke, om vi når dertil, men hvordan vi navigerer gennem overgangen.

Konklusion: Koden er levende

John von Neumann, polyhistoren der opfandt de cellulære automater, blev drevet af et grundlæggende spørgsmål: Hvad er den mindste kompleksitet, der kræves for selvreproduktion? Hans svar, von Neumanns universelle konstruktør, viste, at selvreplikering ikke kræver biologisk maskineri. Den kræver blot regler, der koder for deres egen anvendelse.

Halvfjerds år senere opdager vi, at det samme princip gælder for designsystemer. Minimumskravet til autonom UI-generering er ikke kunstig generel intelligens eller kreativitet på menneskeligt niveau. Det er et komplet, konsistent og maskinlæsbart regelsæt, som agenter kan udføre.

Når Langtons løkker replikerer sig henover et cellegitter, siger vi ikke, at løkkerne "designer" nye løkker. Replikeringen er simpelthen det, reglerne frembringer. Alligevel er resultatet, nemlig stadig større kolonier af selvlignende mønstre, ubestrideligt generativt og i en funktionel forstand kreativt.

Når AI-agenter samler grænseflader af designsystemets komponenter og følger semantiske tokens og kompositionsbegrænsninger, gør de noget lignende. "Kreativiteten" ligger ikke i agenterne, men i de regler, de udfører: regler, som mennesker har designet, men som nu virker på egen hånd.

Vi står på tærsklen til en ny æra inden for digital skabelse. Agenterne er her. Protokollerne tager form. Designsystemerne er ved at blive grobund for kunstigt liv.

Designet er koden.
Og koden er ved at komme til live.

Centrale artikler og projekter

• Design Systems in the Time of AI - Brad Frost
• Storybook MCP Sneak Peek - Storybook
• Introducing AX: Why Agent Experience Matters - Mathias Biilmann
• Building Effective Agents - Anthropic

Drupal AI-ressourcer

• Drupal AI

• Schema.org Blueprints Module

   

Ressourcer om cellulære automater

• Conway's Game of Life Lexicon - Omkring 1500 figurer
• A Working Turing Machine in Game of Life
• Langton's Loops - Wikipedia
• Rule Sets for Cellular Automata
• A New Kind of Science Online - Stephen Wolfram
• Cellular Automata - Nature of Code

Jeg har udforsket idéer i skæringspunktet mellem beregningsteori, designsystemer, kunstig intelligens og webudvikling.

 De udtrykte synspunkter er spekulative udforskninger af nye tendenser, ikke forudsigelser om bestemte fremtider.

Jeg ser, at vi skaber AI-agenter, der arbejder i en løkke og interagerer med andre AI-agenter i yderligere løkker.

Designet er koden, når systemet kører i en løkke som en livscyklus inden for et valgt lærred og et sæt regler.