Do Laravel ao Go: refazendo o Rush CMS do zero

O Rush CMS nasceu em 2025, usando Laravel 12 e Filament 4, e fiquei testando e ajustando ele com treze empresas diferentes, em treze sites feitos em Astro. Ele atendia, inclusive, este blog (que agora é atendido pela nova versão). Ele funciona, e muito bem, mas mesmo assim decidi reescrevê-lo do zero, usando Go e um painel em React.
Loucura? Talvez (e muito provavelmente sim), mas explicarei minhas motivações.
O que é Rush CMS? É de comer?
Primeiramente, não é de comer!
Rush é um CMS headless feito para agências: uma instalação só, vários clientes, cada um com seu site isolado, seus usuários e suas permissões. O conteúdo é editado num painel e entregue por uma API pública pensada para sites SSG e SSR, com cache e deploy automático quando algo é publicado.
Já existem soluções enormes e com (muito, mas muito, mas muito) mais dinheiro no mercado. Eu tinha minhas próprias dores que na época não consegui resolver com nenhum:
- Multilíngue de primeira classe
- Multi-tenant por padrão
- Fluxo de publicação com rascunho, revisões, agendamento e preview
- Self hosted e Open source
Tudo isso junto, sem necessidade nenhuma de plugin.
Laravel + Filament é excelente
Antes de qualquer coisa quero deixar isso bem claro, para não ofender os colegas do PHP, eu ainda uso em diversos projetos Laravel e em alguns Filament. Dá pra lançar e validar produtos na velocidade da luz. É bão mesmo, e em pouco tempo estava trabalhando com clientes reais em um sistema real que tinha coleções, formulários, menu, categorias, mídia, blocos customizados, databases... E muitas outras "coisinhas".
Mas o problema era o encaixe e o caminho que eu estava fazendo o Rush virar.
Ele foi deixando de ser um painel headless onde eu edito o conteúdo de todos os sites, e com o tempo, foi se transformando em um verdadeiro sistema headless para agências. A primeira versão já oferecia multi-tenant isolado na mesma instalação com permissões por site; multilíngue de primeira classe; API pública pensada em sites estáticos.
Cada um destes pontos, no v1, significava brigar com as convenções, e ir cada vez mais mudando e adaptando para se adequar no que eu queria. Enquanto eu tinha a velocidade, perdia na flexibilidade.
Na versão atual, feita em Go, eu apliquei um modelo de publicação com rascunho separado, histórico de revisões, agendamento, preview de rascunhos, quase da mesma forma que o Sanity, Contentful, Strapi e Payload fazem. E tudo funcionando junto com o multilíngue de primeira classe.
Por que Go?
Depois de me desculpar com o Laravel, tenho que ser honesto. Eu já estava estudando Go, e me preparando para expandir esse conhecimento em novas oportunidades de mercado, e não tem nenhum lugar melhor para fazer isso do que com projetos próprios. Assumindo os riscos de minhas próprias decisões.
Esse era o desafio ideal: um CMS headless multi-tenant com fila, processamento de imagem e regras de concorrência é um bom lugar pra começar. Eu separei alguns "thoughts" enquanto fritava meu cérebro fazendo o Rush tudo de novo:
- Explícito até demais: Erros são valores, dependências são passadas na mão, e não tem mágica. Eu já estava preparado, e querendo, trabalhar sem mágica, então esse paradigma já estava quebrado na minha cabeça.
- Verboso: Isso não é um elogio, que código feio!
- Um binário só: Com servidor, filas e processamento de imagem no mesmo processo. Isso aqui me pegou desde o começo, era isso o que eu queria: um binário compilado e leve. Fora dele só Postgres e Redis.
Na versão nova: O i18n saiu de campos JSON traduzíveis para tabelas separadas. Não estou usando ORM, tem mais de 300 queries SQL tipadas com sqlc. O que está publicado vive em tabelas próprias, derivadas de revisões imutáveis, e webhooks, cache e deploy saem de um outbox com retentativas.
E o que eu perdi? Bom... Tudo que o Laravel me proporcionava, eu tive que escrever. O Laravel é imbatível nisso.
Quanto de código eu escrevi
Na guerra dicotômica atual da IA, Sunitas irão me chamar de Xiita, ou vice-versa. Uma boa parte do código não foi escrita por mim.
Mas, se você está aprendendo a linguagem, tem a obrigação de escrever.
Sim, e não. Entendo a necessidade da prática, mas muita coisa acontece mais na nossa cabeça do que no papel. Hoje, estamos no meio de uma transição completa de fluxo de trabalho, em que o mercado muitas vezes quer a entrega mais rápida. Eu ainda acho necessário saber o que está sendo escrito e feito, e mais do que nunca, entender os conceitos de System Design, regras de negócio e etc. Se eu tivesse escolhido fazer tudo na mão, só terminaria em dois anos, sendo positivo.
Esse foi um outro motivo, e talvez o mais curioso, de fazer do zero em uma nova linguagem. O jeito que deu certo aqui:
- Todas as decisões são minhas: cada pacote de trabalho deve ter todas as pontas fechadas, todas as principais decisões devem ser registradas e com fácil acesso, um plano só é executado depois de ser validado por um humano.
- Regras Explícitas: sem código duplicado, sem comentários, tipagem estrita, testes determinísticos... As guidelines de código precisam ser seguidas religiosamente.
- Revisão Independente: Antes de chegar em mim, um agente fresco faz uma revisão, sem ter contato com o agente que escreveu o código. Isso funciona bem: esse X9 quase sempre encontra algum problema ou uma guideline não seguida antes de chegar em mim. Economizo tempo e a entrega melhora.
- Mutation Tests: Se tem uma coisa que os agentes gostam, é fazer testes que sempre vão dar certo. Ter o projeto todo testado é bom, e é possível ser o maluco dos testes hoje sem necessariamente ser um maluco. Além dos diversos tipos de testes que já são padrão, os testes de mutação são importantíssimos para pegar um teste preguiçoso de calças curtas.
- Pare e Pergunte quando necessário: Quando uma especificação não cobre um caso, o agente decide sozinho. Aqui algo pode sair caro. Quando eu percebo algo que eu não gosto, paro na hora o que ele está fazendo e busco entendimento. Às vezes é uma boa decisão, melhor que a minha, outras vezes não!
As coisas evoluíram muito, antes eu tinha meu falecido AIPIM, que gerenciava contextos e tasks com agentes sozinho. Até que vieram os subagents do Claude Code, que melhoraram tanto que aposentaram meu finado pacote. Hoje eu rodo um agente principal, que despacha subagentes (que podem, dependendo do tamanho ou complexidade da spec, despachar outros subagentes, fazendo um inception de agentes), executando a spec com grafos, que antes já foi revisada e aprovada.
Hoje a nova versão tem cerca de 35 mil linhas de Go, 49 mil linhas de testes e mais de 800 commits desde março de 2026.
O que esse textão todo quer dizer?
Que às vezes tomar a decisão maluca de refazer do zero pode ser uma boa decisão. Pelo menos aqui foi! Eu poderia ter continuado com PHP puro, Symfony, ou até Laravel com Inertia, mas o que eu aprenderia?
Symfony daria conta com os pés nas costas, mas eu estaria resolvendo só o encaixe do Filament, ainda na mesma linguagem dos últimos 15 anos. E o Inertia não fazia sentido: o Rush é headless, a API é o produto, então o painel virou só mais um cliente dela.
Sair da zona de conforto foi a minha escolha final.
O que vem depois?
Ser self-hosted e open source eram dois dos requisitos que, juntos, me fizeram construir o Rush CMS. Por enquanto, ele ainda não é open source.
O Rush CMS (a nova versão, em Go) vai virar um repo open source depois que eu validar e resolver as minhas principais dores atuais. Com um beta aberto no repositório oficial do Github. Quando liberado, o link será esse.