Sete Maneiras de Compartilhar o Que Você Constrói: Uma Taxonomia Prática para Equipes na Era da IA

Quando você constrói uma ferramenta que funciona, a próxima pergunta é sempre: como faço para entregá-la a outra pessoa?

Isso parece simples. Não é. A resposta depende de quem é o destinatário (desenvolvedor ou usuário não técnico), onde os dados estão (local ou remoto) e se um humano ou um agente de IA será quem chamará a ferramenta. Ao longo do último ano construindo ferramentas de IA com foco local em SQLite, vLLM e Cloudflare Tunnel, usei sete métodos distintos para compartilhar o que construo — e cada um troca algo diferente.

Este post mapeia esses sete métodos para as ferramentas que realmente uso: GitHub, Claude Code, Google Workspace, Cloudflare, Notion e Tailscale. Nenhuma arquitetura hipotética. Cada linha da tabela abaixo corresponde a algo em produção.

Antes dos sete: o que você está compartilhando?

Os sete métodos são mecanismos de entrega. Antes de escolher um, é útil perguntar o que a coisa sendo entregue realmente é. Na prática, compartilho três tipos de artefatos, e cada um tem um perfil de risco diferente:

Código determinístico — um endpoint FastAPI, uma ferramenta CLI, um script GAS. Mesma entrada, mesma saída. O risco são bugs. Você pode ler o código e verificar o que ele faz antes de executá-lo.

Um agente de IA — uma sessão CLI do Nemotron, uma habilidade do Claude Code, um fluxo de trabalho conectado ao MCP. Mesma entrada, diferente saída a cada vez. O risco é comportamento imprevisível. Você não pode verificar completamente o que o agente fará, apenas restringi-lo. Este é o artefato que o modelo Gatekeeper do Cloudflare OS foi projetado para conter.

Um banco de dados (+ visualizador) — um grande corpus SQLite, uma planilha do Google, um espaço de trabalho do Notion. Não executável, mas com estado e mutável. O risco é vazamento de dados e perda de integridade. O visualizador (interface de busca, painel, página do Notion) e os dados são logicamente separados, mas praticamente inseparáveis — você quase nunca compartilha um sem o outro.

Esses três não têm limites claros. Uma WebUI é código determinístico apoiado por um banco de dados, operado por um humano. Um servidor MCP envolve código determinístico que um agente de IA chama para acessar um banco de dados. Mas ao decidir como compartilhar algo, saber se o artefato central é código, um agente ou dados esclarece qual dos sete métodos se encaixa.

Os sete métodos

Leve ──────────────────────────────────→ Pesado

⑤ CLI/Script  ① Biblioteca  ⑦ Contêiner  ③ WebUI  ② API  ⑥ Servidor MCP
(pip install)  (import)  (docker run)  (navegador) (HTTP)  (IA descobre)

④ Banco de dados compartilhado está por trás de todos os acima

O lado esquerdo é mais leve para configurar, requer menos infraestrutura e assume que o destinatário tem alguma habilidade técnica. O lado direito é mais pesado, mas acessível a usuários não técnicos e — criticamente — a agentes de IA.

Um eixo corta todo o espectro: quem integra? Com tudo à esquerda (①⑤⑦), um humano lê o README, entende a interface e escreve o código de integração. Com ⑥ (MCP), uma IA lê o esquema e integra em tempo real. Com ② (API), pode ir de qualquer maneira — um humano escreve um cliente, ou uma IA chama o endpoint através de uma ferramenta. Essa distinção entre compartilhamento integrado por humanos e integrado por IA é nova. Um ano atrás não existia. Agora é a decisão de design mais consequente na pilha.

① Compartilhamento de biblioteca

O que é: Código empacotado que outra pessoa importa em seu próprio projeto.

Ferramentas envolvidas: GitHub (repositório privado da org) → destinatário clona ou instala.

Como eu realmente faço isso: Quando construo uma utilidade — um wrapper FTS5 do SQLite, um módulo de verificação de saúde do Cloudflare Tunnel, um carregador de configuração TOML — eu o envio para um repositório da org no GitHub. Um colega o clona, lê o README e importa o que precisa.

A etapa chave é destilação. Antes de compartilhar, uso o Claude para comprimir a base de código: remover fixtures de teste, colapsar módulos verbosos, remover credenciais, adicionar um README mínimo. O destinatário recebe um pacote limpo, não um despejo do meu diretório de trabalho.

O que isso troca: O destinatário precisa entender o código bem o suficiente para integrá-lo. Não há UI, nenhum serviço em execução, nenhum "basta clicar aqui".

Modelo de atualização: O destinatário executa git pull quando deseja atualizar. A propriedade permanece com o autor original. Esta é uma atualização explícita, iniciada pelo usuário — o oposto de over-the-air.

② Integração baseada em API

O que é: Um serviço em execução que expõe endpoints HTTP. Outros o chamam sem ver os internos.

Ferramentas envolvidas: FastAPI em VPS (Ubuntu) → Cloudflare Tunnel → URL pública.

Como eu realmente faço isso: HoureiLLM (busca semântica sobre 241.879 artigos de 8.928 leis japonesas) e PatentLLM (FTS5 sobre um corpus de patentes dos EUA) ambos funcionam como serviços FastAPI atrás do Cloudflare Tunnel. Qualquer um com a URL pode pesquisar. O chamador não precisa de Python, SQLite ou qualquer uma das minhas dependências. Eles enviam uma consulta, recebem JSON de volta.

O servidor de inferência Nemotron-9B funciona da mesma maneira: vLLM expõe uma API compatível com OpenAI na porta 8000, e a ferramenta CLI que construí se conecta a ela via HTTP. A fronteira da API significa que posso trocar o modelo, mudar o hardware ou reescrever o servidor — e a CLI não se importa.

O que isso troca: O serviço deve estar em execução. Se meu VPS cair, a API cai.

Modelo de atualização: O provedor atualiza silenciosamente. O consumidor não sabe e não precisa saber. Isso é over-the-air por padrão — e essa é tanto a força (zero atrito) quanto o risco (mudanças quebradas chegam sem aviso).

vs. MCP (⑥): Uma API requer que um humano leia a documentação, entenda o esquema, escreva um cliente e lide com erros. O MCP envolve o mesmo transporte HTTP em um protocolo que agentes de IA podem descobrir e chamar sem trabalho de integração humana. Os mecanismos subjacentes são semelhantes; o sujeito da integração é diferente. Eu os separo porque essa diferença — compartilhamento integrado por humanos vs. compartilhamento integrado por IA — muda fundamentalmente o modelo de compartilhamento.

③ Aplicação WebUI

O que é: Uma aplicação baseada em navegador que usuários não técnicos podem operar.

Ferramentas envolvidas: FastAPI + Jinja2 + JS puro → Cloudflare Tunnel → navegador.

Como eu realmente faço isso: Recycle Paperless, a PWA de otimização de rotas para logística de reciclagem, é uma WebUI. Os motoristas a abrem em seus telefones, inserem dados de coleta e o painel do administrador mostra o progresso em tempo real. Os motoristas não sabem (ou precisam saber) que o backend é FastAPI + SQLite WAL em um Chromebook.

É aqui que o compartilhamento deixa de ser sobre código e começa a ser sobre experiência. Uma WebUI precisa lidar com casos extremos, mostrar estados de carregamento, funcionar em dispositivos móveis, recuperar-se de quedas de rede. Na minha experiência, o esforço de engenharia é várias vezes maior do que expor a mesma funcionalidade como uma API.

O que isso troca: Custo de desenvolvimento e carga de manutenção. Cada peculiaridade do navegador, cada viewport móvel, cada cenário offline é seu problema.

Uma nota sobre hospedagem: O Chromebook executando Recycle Paperless é, arquitetonicamente, um servidor. Minha máquina RTX 5090 executando vLLM é um servidor. Em um mundo onde hardware de consumo pode executar inferência e servir aplicações, qualquer PC se torna um potencial host. Isso muda a economia: em vez de pagar um provedor de nuvem, você está pagando sua conta de eletricidade. O Cloudflare Tunnel torna esses servidores de hardware pessoal...