Antirez Voltou ao Redis — e Dessa Vez Trouxe IA

Salvatore Sanfilippo, mais conhecido como antirez, é o tipo de desenvolvedor que criou uma das ferramentas mais usadas do mundo e depois simplesmente… saiu. Em 2020, ele deixou o Redis para se dedicar a projetos pessoais. Seis anos depois, voltou. E o que ele construiu nesses últimos meses mostra que programação de alto nível com assistência de IA não é “vibe coding” — é engenharia de verdade com um copiloto que não reclama de refatorar código às 3 da manhã.

O projeto? Um tipo de dado Array nativo para o Redis. Parece simples, mas se você já trabalhou com Redis sabe que essa lacuna existia desde o primeiro commit do projeto, lá em 2009.

Por Que o Redis Nunca Teve um Array?

Redis sempre teve listas, sets, sorted sets, hashes, streams. Mas um array de verdade — com índice numérico como parte fundamental da semântica — nunca existiu. Listas no Redis são linked lists (ou mais recentemente, listpacks e quicklists). Elas servem bem como filas e pilhas, mas indexação por posição é O(n). Se você quer acessar o elemento 50.000 de uma lista com 100.000 itens, o Redis precisa percorrer metade dela.

Um array nativo resolve isso. Acesso por índice em tempo constante, suporte a arrays esparsos (onde você pode fazer ARSET myarray 293842948324 foo sem alocar bilhões de posições vazias), e operações de scan que rodam em tempo proporcional aos elementos existentes, não ao range total.

A pergunta que fica: se era tão útil, por que ninguém fez antes?

A resposta do próprio antirez é honesta — a complexidade interna necessária para suportar arrays esparsos de forma eficiente é absurda. E é exatamente aí que a IA entrou.

A Arquitetura: Diretórios Fatiados em Três Níveis

A primeira versão do Array usava uma estrutura de dois níveis: diretório + slices, alternando entre representações esparsas e densas dependendo da distribuição dos dados. Parecia funcional nos testes iniciais.

Até alguém tentar fazer ARSET myarray 293842948324 foo.

Com um índice desse tamanho, a estrutura de dois níveis simplesmente não escalava. O consumo de memória explodia e as operações de scan ficavam proporcionais ao range, não aos elementos reais. Antirez teve que repensar tudo.

A solução final é o que ele chama de “super directory of sliced dense directories” — três níveis hierárquicos:

O número mágico é 4.096 elementos por slice — configurável, mas esse valor oferece o melhor equilíbrio entre granularidade e overhead de memória. A estrutura “muda de forma” internamente quando certas condições são atingidas: se um slice esparso atinge uma densidade alta o suficiente, ele se converte automaticamente para denso, e vice-versa.

Isso significa que um ARSCAN ou ARPOP roda em tempo proporcional apenas aos elementos existentes. Mesmo que seu array tenha índices em 0, 1.000.000 e 999.999.999, as operações ignoram os buracos.

# Criar um array esparso com 3 elementos
ARSET meuarray 0 "primeiro"
ARSET meuarray 1000000 "meio"
ARSET meuarray 999999999 "fim"

# Scan percorre apenas 3 elementos, não 1 bilhão
ARSCAN meuarray 0 -1

Os Comandos do Redis Array

O set de comandos é enxuto, mas cobre os casos de uso principais:

# Setar valor em índice específico
ARSET myarray 42 "hello world"

# Inserir (shift dos elementos seguintes)
ARINSERT myarray 10 "novo elemento"

# Scan com range
ARSCAN myarray 0 100

# Pop (remove e retorna)
ARPOP myarray 0    # primeiro elemento
ARPOP myarray -1   # último elemento

# Grep com regex
ARGREP myarray "docker|kubernetes|devops"

Espera. Grep? Em um array Redis?

ARGREP: Quando Um Tipo de Dado Vira Uma Ferramenta de Busca

Essa foi a parte inesperada do projeto. Enquanto antirez modelava casos de uso para o Array — usando arquivos markdown para documentar cenários —, ele percebeu que precisava de funcionalidade de busca textual. Não algo sofisticado como full-text search, mas o bom e velho grep.

Assim nasceu o ARGREP, que implementa busca por expressões regulares diretamente no tipo Array. A engine por trás é a biblioteca TRE, uma implementação de regex otimizada para padrões com alternação (aquele foo|bar|zap que todo mundo usa).

Antirez não apenas integrou o TRE — ele otimizou o handling de padrões de alternação e corrigiu problemas de segurança que encontrou na biblioteca. Quem conhece o estilo do criador do Redis sabe que ele não aceita dependências externas sem reescrever pelo menos metade delas.

O resultado prático:

# Buscar todas as entradas que mencionam Python ou Rust
ARGREP logs "python|rust"

# Encontrar padrões de erro
ARGREP events "error.*timeout"

# Busca case-insensitive (via flags do TRE)
ARGREP messages "(?i)urgente"

Para quem usa Redis como store de logs, eventos ou mensagens, isso elimina a necessidade de puxar tudo para o cliente e filtrar localmente. A busca acontece no servidor, em tempo proporcional aos elementos existentes.

4 Meses com IA: O Que Funcionou e O Que Não Funcionou

Aqui é onde a história fica realmente interessante para qualquer dev que usa (ou quer usar) IA no dia a dia.

Antirez documentou sua experiência de forma brutalmente honesta. Ele começou pareando com o Claude Opus para a fase de especificação — o primeiro mês inteiro foi gasto escrevendo specs, não código. A IA não escreveu a spec sozinha; o processo foi de vai-e-volta constante, com antirez desafiando as sugestões e a IA desafiando as decisões dele.

Na implementação, ele migrou para GPT para “tarefas de programação de sistema” — provavelmente porque na época o GPT tinha vantagem em geração de código C, que é a linguagem do Redis.

Mas o ponto mais revelador é a analogia que ele usa: a IA como rede de segurança.

Sabe quando você está escalando e tem uma rede embaixo? Você não pula com mais força por causa da rede — ela está lá para quando você escorregar. Antirez usou a IA da mesma forma: ela permitiu que ele explorasse complexidades que ele teria evitado se estivesse sozinho. Não porque a IA escreveu o código difícil, mas porque ela absorveu o trabalho tedioso (como portar tudo para suporte 32-bit) e liberou o tempo dele para as decisões de design que realmente importam.

O que a IA fez bem

• Fase de especificação: ida e volta de feedback, desafios intelectuais sobre design
• Código repetitivo: suporte 32-bit, boilerplate, testes de stress
• Code review: uma segunda opinião instantânea sobre decisões de implementação
• Reescrita de módulos: quando antirez decidia refatorar, a IA regenerava o código mais rápido

O que a IA NÃO substituiu

• Decisões arquiteturais: a mudança de 2 para 3 níveis de diretório foi 100% humana
• Otimização de performance: entender por que uma estrutura não escalava exigiu intuição
• Segurança: os bugs no TRE foram encontrados por revisão manual
• Sabor do design: o que incluir vs. o que deixar de fora — o minimalismo que define o Redis

A frase que resume tudo: “For high quality system programming tasks you have to still be fully involved.”

O Cronograma Real (Spoiler: Não Foi Rápido)

Quatro meses para um tipo de dado. Parece muito? Considere que o último tipo adicionado ao Redis (Streams, em 2018) levou mais de um ano de desenvolvimento. O Array é significativamente mais complexo internamente, e foi feito em menos da metade do tempo.

A IA não fez o projeto em uma tarde. Mas comprimiu um trabalho de 12+ meses para 4. Essa é a realidade da programação assistida por IA em 2026: não é magia, é alavancagem.

Como Isso Muda o Redis na Prática

Se você usa Redis hoje, o Array abre cenários que antes exigiam gambiarras:

Time-series simplificado: Em vez de usar Sorted Sets com scores como timestamps, um Array esparso com índices baseados em timestamp UNIX funciona nativamente. O ARSCAN com range faz a consulta temporal.

Logs estruturados: Arrays como buffers de log com ARGREP embutido eliminam o padrão “puxa tudo pro cliente e filtra”. Para aplicações que processam milhões de eventos, isso é a diferença entre latência de microsegundos e millisegundos.

Filas com prioridade: ARINSERT permite inserção em posição arbitrária, algo impossível com listas Redis sem recriar a estrutura inteira.

Sparse data: Dados de sensores IoT, métricas com gaps, matrizes esparsas — qualquer coisa onde os índices não são contíguos. Antes, a solução era usar Hashes com chaves numéricas como strings, perdendo toda a semântica de ordenação.

import redis

r = redis.Redis()

# Time-series com Array esparso
import time
ts = int(time.time())
r.execute_command('ARSET', 'sensor:temp', ts, '23.5')
r.execute_command('ARSET', 'sensor:temp', ts + 60, '23.8')
r.execute_command('ARSET', 'sensor:temp', ts + 120, '24.1')

# Consulta dos últimos 5 minutos
start = ts
end = ts + 300
results = r.execute_command('ARSCAN', 'sensor:temp', start, end)

O Elefante na Sala: Redis É Open Source de Novo?

Quem acompanha a saga do Redis sabe que em 2024 a empresa mudou a licença de BSD para uma dual-license restritiva (RSALv2/SSPL), causando forks como o Valkey. Antirez criticou publicamente a mudança na época.

O fato dele ter voltado — e estar contribuindo ativamente — levanta perguntas. O Array vai estar disponível no Valkey? Vai ser apenas para o Redis comercial? No blog post, antirez não toca nesse assunto. Mas o PR está no repositório principal do Redis, o que sugere que estará disponível para todos os usuários do Redis (mas não necessariamente nos forks, que precisarão portar manualmente).

Para quem migrou para o Valkey, vale ficar de olho. Features desse calibre são difíceis de ignorar.

Lições para Quem Quer Usar IA em Projetos Complexos

O relato do antirez é provavelmente o melhor estudo de caso público sobre IA em programação de sistemas que temos em 2026. Não é um tutorial de “como fazer um CRUD com ChatGPT” — é o criador de uma das bases de dados mais usadas do mundo explicando como integrou IA em um projeto de 4 meses de engenharia pesada.

Os takeaways que eu destaco:

1. Spec primeiro, código depois. Antirez gastou 25% do tempo total apenas na especificação. A IA foi mais útil nessa fase do que na implementação. A maioria dos devs que reclamam que “a IA gera código ruim” nunca gastaram uma hora escrevendo uma spec decente.

2. Troque de modelo sem cerimônia. Ele usou Claude para spec e GPT para código C. Não existe lealdade a modelo — existe a ferramenta certa para o momento.

3. A IA amplia, não substitui. Quatro meses em vez de doze não é porque a IA escreveu o código. É porque ela absorveu o trabalho braçal e liberou o humano para pensar nas partes difíceis.

4. Revise tudo. As otimizações de segurança no TRE vieram de revisão humana. Se antirez tivesse confiado cegamente na integração da IA, o Redis teria uma vulnerabilidade nova.

O Array deve chegar em uma release estável do Redis nos próximos meses. Quando chegar, lembre que por trás dele tem um italiano teimoso que se recusa a aceitar código que não entende — mesmo quando foi uma IA que escreveu.

Fonte de inspiração: Redis array: short story of a long development process — antirez