O design é o código

Como a lógica dos autômatos celulares vai remodelar os sistemas de design agênticos, e por que o futuro do desenvolvimento web talvez já esteja escrito em regras simples

Está em curso uma transformação profunda na interseção entre sistemas de design, inteligência artificial e teoria da computação. É uma mudança tão fundamental que desafia a nossa compreensão do que "design" significa na era dos agentes autônomos.

Durante décadas, tratamos design e código como disciplinas separadas: o design como o território da criatividade humana e do julgamento estético, o código como a tradução mecânica dessas ideias para uma forma executável. Mas, à medida que agentes de IA montam interfaces de usuário de forma autônoma, consomem sistemas de design como infraestrutura legível por máquina e geram código a partir de tokens semânticos, nos aproximamos de um ponto de convergência que ecoa uma ideia bem mais antiga da teoria da computação.

Que ideia? O design é o código.

Isso não é apenas uma frase de efeito. É o reconhecimento de que talvez estejamos caminhando para um mundo em que os sistemas de design funcionam como autômatos celulares: regras simples que dão origem a comportamentos complexos e emergentes. Um mundo em que a distinção entre "projetar" algo e "programá-lo" se dissolve por completo. Em que agentes autônomos não apenas usam sistemas de design, mas são sistemas de design em ação.

Este post explora as conexões profundas entre autômatos celulares, comportamento emergente e o futuro dos sistemas de design agênticos. Vamos traçar as bases teóricas, das máquinas autorreplicantes de von Neumann aos enxames de agentes de IA de hoje.

Vamos examinar como o Drupal e as plataformas de CMS modernas estão integrando a IA por meio de módulos como o Schema.org Blueprints e o Drupal AI. E vamos refletir sobre o que tudo isso significa para designers, desenvolvedores e o futuro da criação de produtos digitais.

Autômatos celulares e a lógica da emergência

A beleza das regras simples

Em 1970, o matemático John Conway apresentou o Jogo da Vida, um "jogo de zero jogadores" que se tornaria um dos sistemas mais estudados da teoria da computação. As regras são de uma simplicidade impressionante:

1. Qualquer célula viva com menos de dois vizinhos vivos morre (subpopulação)
2. Qualquer célula viva com dois ou três vizinhos vivos sobrevive
3. Qualquer célula viva com mais de três vizinhos vivos morre (superpopulação)
4. Qualquer célula morta com exatamente três vizinhos vivos torna-se viva (reprodução)

Dessas quatro regras, expressas em um punhado de condições binárias, surge um universo espantoso de complexidade. Planadores (gliders) atravessam grades infinitas. Osciladores pulsam em ritmos perpétuos. Canhões disparam fluxos de padrões pelo espaço celular. E, o mais notável, já se provou que o Jogo da Vida é Turing-completo: tudo o que pode ser computado de forma algorítmica pode, em princípio, ser computado dentro da grade simples de Conway.

Figura 1: A Glider Gun de Gosper no Jogo da Vida de Conway. Esse padrão produz um fluxo contínuo de gliders, mostrando como regras simples podem gerar uma complexidade infinita e autoperpetuante.

Esta é a primeira lição dos autômatos celulares: a complexidade não é pré-requisito para um comportamento complexo. Regras simples, aplicadas de forma consistente sobre um substrato, podem dar origem a padrões e comportamentos que ninguém programou explicitamente.

Os Loops de Langton e a autorreplicação

Em 1984, Christopher Langton levou esse princípio mais longe com seus loops autorreplicantes, um autômato celular que demonstrou princípios genuínos de vida artificial. Ao contrário do Jogo da Vida de Conway, que mostra complexidade emergente, os Loops de Langton mostram a reprodução.

emergente. Cada loop é formado por uma fronteira cíclica que envolve um "genoma" codificado nos estados das células. Esse genoma circula continuamente pelo loop e sai por um braço de construção, que ao longo de 151 passos de tempo constrói um loop filho. Quando fica pronto, o filho se separa do pai, e ambos continuam se replicando.

Figura 2: O Loop de Langton em sua configuração inicial. A informação genética circula pelo loop e orienta a construção dos loops filhos por meio do braço que se estende.

"Se uma máquina autorreprodutora é possível dentro de um autômato celular, então a própria vida talvez possa ser alcançada por máquinas."

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

As implicações são profundas. Os Loops de Langton demonstram que a autorreplicação não exige a complexidade das células biológicas nem a capacidade de construção universal do projeto original de von Neumann. Ela exige apenas:

• Um conjunto de regras simples e locais
• Um mecanismo para codificar instruções
• Um processo pelo qual essas instruções são executadas

As regras são o organismo. O projeto é o código.

Em 1999, Hiroki Sayama apresentou os evoloops, variantes que incorporam dissolubilidade estrutural e interações fenotípicas, permitindo mutações espontâneas e dinâmicas evolutivas. Esses loops evoluem por meio de colisões físicas diretas durante a replicação, o que leva a variações de genótipo, maior diversidade morfológica e crescimento de complexidade ao longo das gerações. Diferentemente da replicação fixa de Langton, os evoloops demonstram mutações hereditárias sem intervenção externa.

Regra 110 e computação universal

A exploração dos autômatos celulares elementares por Stephen Wolfram culminou em uma descoberta surpreendente: a Regra 110, uma das apenas 256 regras possíveis para o tipo mais simples de autômato celular unidimensional, é capaz de computação universal.

A Regra 110 pode ser especificada por completo informando o resultado de cada uma das oito combinações possíveis de uma célula e seus dois vizinhos. Ainda assim, essa regra trivialmente simples, feita de oito decisões binárias, é capaz de simular uma máquina de Turing universal.

Figura 3: autômato celular da Regra 110. Apesar da definição simples, a Regra 110 exibe comportamento de Classe 4, com padrões complexos que não são nem totalmente estáveis nem totalmente caóticos, e já foi provada Turing completa.

"Não é preciso nada parecido com a CPU de um computador inteiro para fazer computação universal. Basta esta pequena regra."

- Stephen Wolfram, "A New Kind of Science"

Em 2004, Matthew Cook publicou uma prova de que a Regra 110, com um determinado padrão de fundo repetitivo, é Turing completa. A prova demonstra que a Regra 110 consegue emular sistemas de tags cíclicas, que por sua vez conseguem emular qualquer máquina de Turing. Entre os 88 autômatos celulares elementares únicos possíveis, a Regra 110 é a única cuja completude de Turing foi provada diretamente.

O Princípio da Equivalência Computacional proposto por Wolfram sugere algo ainda mais radical: sistemas acima de um limiar mínimo de complexidade são essencialmente equivalentes em suas capacidades computacionais. Um cérebro humano, um sistema meteorológico e a Regra 110 são, em algum sentido profundo, computacionalmente equivalentes.

A Metacélula 0E0P: Autorreplicação de Verdade

Em outubro de 2018, Adam P. Goucher concluiu a construção da metacélula 0E0P, um padrão do Jogo da Vida de Conway capaz de autorreplicação verdadeira. Diferentemente das metacélulas anteriores, que precisavam de cópias preexistentes por perto, a metacélula 0E0P consegue construir cópias de si mesma do zero, incluindo a própria fita de instruções.

Essa conquista é um marco na vida artificial: um sistema capaz de se propagar por um substrato computacional usando apenas regras locais. Em 23 de novembro de 2013, Dave Greene construiu o primeiro replicador do Jogo da Vida que cria uma cópia completa de si mesmo, incluindo a fita de instruções, demonstrando que até o simples autômato de dois estados de Conway pode sustentar uma autorreprodução ilimitada.

Sistemas de Design como Substratos Computacionais

Do Atomic Design ao Design Agêntico

A metodologia Atomic Design de Brad Frost, apresentada em 2013, revolucionou a forma como pensamos os sistemas de design. Ao dividir as interfaces em átomos (elementos básicos, como botões e campos), moléculas (combinações simples), organismos (seções complexas da interface), templates (layouts de página) e páginas (implementações finais), o Atomic Design ofereceu uma estrutura hierárquica para lidar com a complexidade.

Mas o que chama a atenção, olhando em retrospecto, é isto: o Atomic Design já incorporava os princípios dos autômatos celulares sem reconhecê-los explicitamente.

"Quando o design system é entediante, ele libera designers e desenvolvedores para fazer coisas novas, para resolver problemas novos. O design system carrega o fardo do tedioso, para que designers e desenvolvedores não precisem carregá-lo."

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

Em fevereiro de 2023, Brad Frost escreveu sobre "Design Systems in the Time of AI":

"A IA é uma consumidora natural de design systems... O fato é que boa parte do trabalho com componentes de um design system é mesmo mecânica e previsível. Já usamos ferramentas como o PlopJS para gerar o boilerplate de um componente que segue o formato do resto da biblioteca. Eu ficaria feliz com a ajuda da IA para gerar para mim um monte desse boilerplate corriqueiro."

- Brad Frost

É justamente a natureza mecânica e previsível dos design systems que os torna adequados a uma operação no estilo dos autômatos celulares. Quando as regras são claras, locais e aplicadas de forma consistente, os agentes podem operar de forma autônoma, assim como as células do Jogo da Vida de Conway não precisam de um controlador central para produzir planadores e osciladores.

O imperativo da legibilidade por máquina

A iniciativa Storybook MCP (Model Context Protocol) representa uma evolução crucial nessa direção. Anunciado no fim de 2025, o Storybook MCP fornece a agentes de programação com IA metadados de componentes legíveis por máquina, a partir de configurações existentes do Storybook.

A ideia central é que os agentes não precisam de código bruto nem de documentação visual. Eles precisam de:

• Manifestos de componentes: Metadados estruturados sobre cada componente: props, variantes, vínculos com design tokens e exemplos de uso
• Nomenclatura semântica: Tokens ricos em intenção, como action.primary.confirm, que transmitem significado aos agentes, e não apenas valores
• Ciclos de validação: A capacidade de rodar testes, ver as falhas e se autocorrigir

"O Storybook MCP ajuda os agentes a seguir seus padrões e passar nos seus testes. Ele dá aos agentes duas coisas que eles nunca tiveram: metadados de componentes legíveis por máquina e um ciclo iterativo para autocorrigir os próprios erros."

- Equipe do Storybook

O Storybook MCP inclui um ciclo de correção autônomo. Ele permite que os agentes rodem os testes dos seus componentes (de interação e de acessibilidade), vejam o que falha e corrijam os próprios bugs. O desenvolvedor só precisa entrar em cena depois que os testes passam. Chega de ficar de babá de prompt.

Esta é precisamente a arquitetura de um autômato celular aplicada ao design: regras locais (as especificações dos componentes), interações entre vizinhos (os padrões de composição) e atualizações iterativas (validação e autocorreção).

O manifesto do componente como genoma

A comparação com os Loops de Langton fica ainda mais apropriada quando olhamos como os manifestos de componentes funcionam. No sistema de Langton, o "genoma" codificado nas células que circulam contém as instruções para construir um novo loop. Em um design system legível por máquina, o manifesto do componente contém as instruções para montar interfaces.

Um manifesto de componente pode especificar:

{
  "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" }
  ]
}

Este manifesto é, ao mesmo tempo, uma especificação de design e código executável — ou melhor, as instruções a partir das quais é possível gerar código executável. O agente que consome este manifesto não precisa entender de estética nem de experiência do usuário no sentido humano. Ele precisa seguir as regras, combinar os elementos de acordo com suas restrições e produzir saídas válidas.

Concordo com Brad Frost sobre usar um formato yaml.

Os componentes do Drupal usam o formato yaml. Algo como

$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

O design é o código.

• Variantes
• Tokens
• Props

• Restrições (poderíamos adicionar aos componentes)

• Regras de slots (o que pode ser colocado em outros slots, ou o que pode ser colocado no meu slot)

• Regras

• Exemplos 

• Animações  ( Com uso permitido ou recomendado )

Depois, observe e experimente o comportamento.

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

Design tokens como variáveis de ambiente

Os design tokens são outra peça fundamental do quebra-cabeça. Nos autômatos celulares, as células reagem ao ambiente imediato — os estados das células vizinhas. Nos sistemas de design, os componentes reagem aos design tokens — os valores de contexto que determinam sua aparência e seu comportamento.

As arquiteturas modernas de tokens usam várias camadas:

• Tokens principais (core): Valores brutos como color.blue.500: #3B82F6
• Tokens semânticos: Referências orientadas pela intenção, como color.action.primary: color.blue.500
• Tokens de componente: Aplicações com escopo definido, como button.background.primary: color.action.primary

Quando um agente gera um componente Button, ele não precisa saber que "primary" significa azul. Basta referenciar button.background.primary e confiar que o sistema de tokens vai resolver para o valor correto. O ambiente (a camada de tokens) guarda a informação; o componente (a célula) só precisa responder a ela.

Ferramentas como o Tokens Studio evoluíram para tratar os design tokens como grafos computacionais com resolvedores — nós que tomam decisões semânticas sobre quais tokens base usar de acordo com o contexto. Isso transforma os design tokens de valores estáticos em sistemas dinâmicos baseados em regras.

O ecossistema Drupal e a integração com IA

A integração da IA aos sistemas de gerenciamento de conteúdo é um laboratório perfeito para explorar os princípios de "o design é o código". CMSs como o Drupal já incorporam os conceitos centrais: tipos de conteúdo estruturados, definições de campos, relacionamentos e regras de composição.

Nunca imaginei que pudéssemos dizer algo assim. Para mim, isso era o estado da arte.

 O computador definitivo que poderíamos ter. Desenvolvedores que parecem ter vindo do futuro de Star Trek, falando com o computador para ele programar por eles.

Experiência do agente (AX) e o novo usuário

Projetando para máquinas

No início de 2025, Mathias Biilmann, CEO da Netlify, apresentou o conceito de "Agent Experience" (AX), uma nova disciplina voltada para a forma como os agentes de IA interagem com produtos e plataformas.

A mudança é fundamental. Por décadas, a UX (experiência do usuário) foi otimizada para a cognição, a percepção e o comportamento humanos. A DX (experiência do desenvolvedor) foi otimizada para desenvolvedores humanos que constroem software. A AX reconhece que os agentes estão se tornando os principais usuários dos sistemas digitais — e eles têm necessidades completamente diferentes:

• Eles não se importam com a estética visual — apenas com dados estruturados e interpretáveis
• Eles não navegam por interfaces — chamam APIs e consomem manifestos
• Eles não leem a documentação como os humanos — precisam de contexto legível por máquina
• Eles não fazem julgamentos subjetivos — seguem regras e restrições

"Agentes de IA não são pessoas: eles não ligam para o tamanho de um botão, a legibilidade da tipografia, a bela paleta de cores do seu site ou as animações chamativas do seu aplicativo. Então, com o que os agentes de IA 'se importam'? Essa é uma pergunta que hoje não tem resposta concreta, mas que será cada vez mais importante nos próximos anos."

- Pesquisa sobre AX

A resposta: regras claras, comportamentos previsíveis, dados bem estruturados e ciclos de feedback que permitam a eles verificar e corrigir suas próprias ações.

O desafio da interface dupla

Projetar para a AX significa construir duas interfaces ao mesmo tempo:

1. Interface humano-agente: Onde as pessoas supervisionam, aprovam, editam e orientam o comportamento do agente: a camada de "centro de controle". Pense em painéis e filas de aprovação, não em formulários e botões.
2. Interface agente-sistema: Onde os agentes interagem com APIs, bancos de dados e ferramentas: a camada "operacional". Precisa ser robusta, bem documentada e otimizada para a eficiência das máquinas.

Isso espelha a arquitetura dos autômatos celulares, em que duas perspectivas distintas coexistem:

• A perspectiva local: cada célula (agente) segue regras simples baseadas nos vizinhos imediatos
• A perspectiva global: surgem padrões complexos que só são visíveis em larga escala

"O design da experiência do agente (AX) deve resultar em ótima usabilidade para os agentes e dos agentes. Assim, uma ótima AX leva a uma ótima experiência do usuário (UX). Se o agente de IA encontra um processo ou protocolo quebrado, ou até uma redação inconsistente entre sistemas, ele não consegue executar a tarefa. Isso é uma experiência ruim para o agente, que, por sua vez, leva a uma experiência ruim para o cliente ou o funcionário."

- Kat Holmes, Chief Experience Officer, Salesforce

De UX para AX: a evolução do design digital

Estigmergia e comunicação indireta

Um dos conceitos mais poderosos da inteligência de enxame é a estigmergia: a coordenação indireta por meio de rastros no ambiente. As formigas não se comunicam diretamente sobre onde está a comida; elas deixam trilhas de feromônio que as outras seguem. O ambiente se torna um meio de comunicação.

Em sistemas de design agênticos, a estigmergia assume a forma de:

• Bibliotecas de componentes compartilhadas: os agentes "enxergam" quais componentes existem e como foram usados
• Design tokens: valores semânticos que codificam decisões de design como fatos do ambiente
• Documentação de padrões: exemplos de uso que funcionam como trilhas de feromônio para os próximos agentes
• Suítes de testes: regras de validação que delimitam o espaço de saídas válidas
• Histórico do Git: um registro das decisões passadas que os agentes podem consultar

Quando um agente gera uma interface usando um componente, ele deixa rastros: no código, na documentação, nos padrões que estabelece. Os agentes futuros que encontrarem tarefas semelhantes serão influenciados por esses rastros, criando uma forma de inteligência coletiva que nenhum agente isolado possui.

Padrões de design agênticos

Andrew Ng e outros identificaram quatro padrões principais para sistemas de IA agênticos:

1. Reflexão: a IA avalia a própria saída e a melhora de forma iterativa
2. Uso de ferramentas: a IA interage com ferramentas, APIs e sistemas externos
3. Planejamento:O assistente de IA divide tarefas complexas em subtarefas e as executa em sequência
4. Multiagente: Vários agentes especializados colaboram em tarefas complexas

Esses padrões se relacionam diretamente com os conceitos de autômatos celulares:

O design é o código: uma leitura mais profunda

O que "o design é o código" realmente significa

Quando dizemos que "o design é o código", estamos afirmando várias coisas ao mesmo tempo:

1. Equivalência semântica

As decisões de design, quando codificadas do jeito certo, tornam-se executáveis. Um design token não é só um valor: é uma instrução. A especificação de um componente não é só documentação: é um programa. Quando os agentes consomem esses artefatos, eles estão executando o design tanto quanto o implementando.

2. Capacidade generativa

Assim como a Regra 110 consegue computar tudo o que é computável, um sistema de design suficientemente completo consegue gerar qualquer interface válida. O sistema contém o potencial de todas as suas expressões válidas. O que emerge depende apenas das condições iniciais (os requisitos) e das regras (as restrições).

3. Complexidade emergente

As interfaces mais sofisticadas não são projetadas de cima para baixo: elas emergem da aplicação consistente de regras simples. Um botão bem projetado, usado de forma consistente, produz uma linguagem visual coerente sem que ninguém precise planejar essa coerência explicitamente.

4. Irredutibilidade computacional

Alguns resultados de design não podem ser previstos sem de fato rodar o sistema. Não dá para saber como será uma interface montada por um agente sem deixar o agente montá-la. É o princípio da irredutibilidade computacional de Wolfram aplicado ao design.

5. Automodificação

Como os evoloops, que sofrem mutação durante a replicação, os sistemas de design prontos para agentes podem evoluir com o uso. Os componentes gerados pelos agentes passam a fazer parte da biblioteca que os agentes futuros vão consumir. O sistema aprende, se adapta e cresce.

A metáfora dos autômatos celulares, ampliada

Além da metáfora: uma convergência real

Mas isso não é apenas metáfora. A convergência é real e está acontecendo agora:

• Storybook MCP transforma bibliotecas de componentes em instruções legíveis por máquina que os agentes executam
• Model Context Protocol padroniza como os agentes acessam ferramentas e contexto, criando um substrato universal para operações agênticas
• Arquiteturas multiagente dividem o trabalho entre agentes especializados (arquiteto, programador, revisor) que interagem segundo protocolos, como células com funções diferenciadas
• Ciclos de autocorreçãoPermitem que os agentes executem testes, detectem erros e iterem, os mesmos mecanismos de feedback que os autômatos celulares usam para evoluir configurações estáveis
• Schema.org Blueprints tornam as estruturas de conteúdo legíveis por máquina e semanticamente significativas
• Drupal AI fornecem a infraestrutura para que agentes de IA criem, modifiquem e gerenciem conteúdo de forma autônoma

Não encaramos "o design é o código" como uma posição filosófica. Estamos construindo isso como infraestrutura técnica.

Implicações e o caminho à frente

Para designers

O papel do designer está se transformando de "criador de retângulos" em "definidor de regras". Como observou Brad Frost:

"Designers e desenvolvedores que veem seu trabalho como criar retângulos têm muito com que se preocupar. Já os que veem seu trabalho como resolver problemas, e só incidentalmente precisam criar ou manejar alguns retângulos para resolvê-los, têm menos a temer."

- Brad Frost

No futuro agêntico, os designers vão:

• Definir tokens semânticos e as relações entre eles
• Estabelecer restrições e padrões de composição
• Criar regras de validação que os agentes precisam satisfazer
• Curar e evoluir as regras que governam a emergência
• Projetar os mecanismos de feedback que permitem a autocorreção
• Moldar as "funções de aptidão" que determinam quais resultados são aceitáveis

Isso é design em um nível mais alto de abstração: projetar as regras que produzem os designs, e não os designs em si. Como definir as regras de um autômato celular em vez de desenhar cada célula individualmente.

Para desenvolvedores

Os desenvolvedores se tornam arquitetos de sistemas de agentes. Como a Anthropic descreve:

"O campo do desenvolvimento de software demonstrou um potencial notável para recursos de LLM, com capacidades que evoluíram do autocompletar de código à resolução autônoma de problemas."

Os desenvolvedores precisarão:

• Criar interfaces legíveis por máquina entre agentes e sistemas
• Projetar ciclos de feedback e mecanismos de validação
• Construir o andaime dentro do qual o comportamento emergente acontece
• Manter a supervisão humana como árbitro final
• Definir os protocolos pelos quais os agentes se comunicam
• Implementar o "código de ligação" que conecta diferentes sistemas de agentes

Para o desenvolvimento web e as plataformas de CMS

A integração da IA em plataformas como o Drupal aponta para um futuro em que:

• Os modelos de conteúdo se tornam consumíveis por agentes por meio de padrões como o Schema.org
• Os fluxos editoriais passam a contar com a assistência de agentes com redação, moderação e otimização movidas por IA
• A busca evolui da correspondência de palavras-chave para a compreensão semântica, por meio de embeddings e bancos de dados vetoriais
• A personalização se torna autônoma com agentes que aprendem as preferências dos usuários e adaptam o conteúdo em tempo real
• O desenvolvimento se acelera à medida que os agentes geram componentes, testes e documentação

A adoção da IA pelo ecossistema Drupal, por meio de módulos como Drupal AI, Drupal Canvas, Schema.org Blueprints e a integração com provedores de IA, demonstra que esse futuro já está sendo construído.

Para as organizações

A vantagem competitiva será das organizações cujos sistemas de design forem mais "prontos para agentes". Sistemas prontos para agentes têm:

• Cobertura completa dos estados e variantes dos componentes
• Nomenclatura semântica que transmite a intenção
• Documentação e contexto legíveis por máquina
• Infraestrutura de validação e testes
• Restrições claras que delimitam o espaço de resultados válidos
• APIs projetadas para o consumo por agentes (AX-first)
• Arquiteturas de conteúdo baseadas primeiro no Schema.org

Para o futuro dos produtos digitais

O estado final lembra uma ecologia digital: incontáveis agentes operando segundo regras locais e produzindo interfaces emergentes que nenhum designer ou desenvolvedor planejou sozinho, mas que, de algum modo, fazem sentido em conjunto porque as regras de base são sólidas.

Isso não é tão absurdo quanto parece. É exatamente assim que funcionam os sistemas biológicos, que as cidades crescem, que os mercados operam. A questão não é se chegaremos a esse estado, mas como vamos atravessar a transição.

Conclusão: o código está vivo

John von Neumann, o polímata que inventou os autômatos celulares, foi movido por uma pergunta fundamental: qual é a complexidade mínima necessária para a autorreprodução? A resposta dele, o construtor universal de von Neumann, mostrou que a autorreplicação não exige maquinaria biológica. Exige apenas regras que codifiquem a própria aplicação.

Setenta anos depois, estamos descobrindo que o mesmo princípio vale para os sistemas de design. O requisito mínimo para a geração autônoma de interfaces não é inteligência artificial geral nem criatividade de nível humano. É um conjunto de regras completo, consistente e legível por máquina, que os agentes possam executar.

Quando os Loops de Langton se replicam por uma grade celular, não dizemos que os loops estão "projetando" novos loops. A replicação é simplesmente o que as regras produzem. Ainda assim, o resultado, colônias em expansão constante de padrões autossemelhantes, é inegavelmente generativo, criativo em algum sentido funcional.

Quando agentes de IA montam interfaces a partir de componentes de um sistema de design, seguindo tokens semânticos e restrições de composição, fazem algo parecido. A "criatividade" não está nos agentes, e sim nas regras que eles executam: regras que humanos desenharam, mas que agora operam de forma autônoma.

Estamos no limiar de uma nova era da criação digital. Os agentes já estão aqui. Os protocolos estão tomando forma. Os sistemas de design estão se tornando substratos para a vida artificial.

O design é o código.
E o código está ganhando vida.

Principais artigos e projetos

• 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

Recursos de IA do Drupal

• Drupal AI

• Módulo Schema.org Blueprints

   

Recursos sobre autômatos celulares

• Conway's Game of Life Lexicon - Cerca de 1.500 figuras
• 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

Explorei ideias na interseção entre teoria da computação, sistemas de design, inteligência artificial e desenvolvimento web.

 As opiniões expressas são explorações especulativas de tendências emergentes, não previsões de futuros certos.

Vejo que estamos criando agentes de IA que trabalham em um loop e interagem com outros agentes de IA em loops adicionais.

O design é o código quando o sistema opera em um loop, como um ciclo de vida, dentro de um canvas e de um conjunto de regras escolhidos.