Bootstrap Pro 2.0 Ultron Mode — Arquitetura profissional + economia de tokens para Claude Code

Name: Bootstrap Pro 2.0 Ultron Mode
Author: B2Tech

Assista primeiro

O que é o Bootstrap, em um vídeo

Antes de comprar, veja o que o baseline .claude/ resolve na prática — o vídeo explica o que é o Bootstrap e por que ele existe.

O pacote

Duas camadas, uma licença

O Bootstrap Pro estrutura o projeto antes da primeira linha de código; o Ultron Mode corta o custo de cada request depois dela. Você pula os dois primeiros dias de setup — e paga menos por todos os dias seguintes.

Camada 1 · arquitetura

Claude Code Bootstrap Pro

O baseline .claude/ de projetos sérios: Spec-Driven Development, Vertical Slice + DDD, API-First, ADRs, docs Diátaxis, DevSecOps, subagents, skills e hooks prontos — com NOTES.md de memória viva e continuidade entre sessões. Entregue como zip com watermark + repositório GitHub template.

Camada 2 · economia

Ultron Mode (ultronpx)

Proxy local que converte blocos densos de contexto em PNG — vision tokens custam por pixel, não por texto: até ~3× mais barato por bloco, ~45% de economia medida por bloco imageado em tráfego real. Verbatim Guard, gate adaptativo, fail-open e economia auditável em BRL. Rewrite do conceito do pxpipe, de teamchong, com atribuição.

Por que juntos

Economia composta

O Bootstrap disciplina o contexto — specs, NOTES.md, waves e hooks de compact mantêm as sessões enxutas e retomáveis. O ultronpx comprime o que sobra de denso: tool results, logs, histórico. Estrutura reduz o desperdício; compressão reduz o preço do que é inevitável.

Bootstrap Pro por dentro

O que o template resolve antes de você começar

É o mesmo baseline .claude/ usado pra iniciar todo projeto sério da B2Tech — cada capacidade abaixo vem pronta, com os assets nomeados.

Workflow Spec-Driven

destaque

/specEntrevista você e escreve a spec da feature — objetivo, contratos, edge cases, critérios de aceite.
/wavesDeriva o plano de implementação em ondas: dependências, paralelismo e critérios de aceite por onda, com comando /goal pronto.
/vertical-sliceScaffolding de uma slice VSA + DDD completa, da apresentação à infraestrutura.

Verificação & loops

autonomia

/verifyO Claude verifica a própria mudança de ponta a ponta — evidência, não opinião — antes de reportar como pronta.
/babysit-prSob /loop, monitora um PR: responde review comments e conserta CI vermelho sozinho.
how-to/loopsOs quatro tipos de loop (turn, goal, time, proactive) mapeados, com regras de custo.

Continuidade de sessão

memória

NOTES.mdMemória viva do projeto: o que foi decidido, o que está em curso, o que falta — sobrevive ao fim da sessão.
pre-compactHook tira snapshot do git e orienta o resumo antes do /compact; outro hook restaura o contexto depois.
stop-notesChecagem de continuidade no fim de cada turno — onda concluída força atualização das notas.

Guardrails de segurança

DevSecOps

block-secretsHook PreToolUse bloqueia acesso a .env e paths sensíveis no nível da tool.
/security-scanPipeline de auditoria DevSecOps sob demanda, com template de threat model STRIDE em docs/security/.
settings.jsonAllow/deny lists curadas + blocker opcional de comandos destrutivos.

Qualidade automática

hooks + agents

format-on-saveAuto-format em cada arquivo editado; docs-reminder avisa quando as docs ficam pra trás do código.
subagentscode-reviewer, test-runner, threat-modeler e web-researcher com contexto fresco.
/review · /commitReview de PR e Conventional Commits guiados, mais /fix-issue pra triagem de issues.

Arquitetura & docs

templates

docs/adr/ADRs formato Nygard com meta-ADR inicial; decisões arquiteturais versionadas desde o dia 1.
openapi · asyncapiContratos API-First esqueletados em docs/api/ — o código respeita o contrato, não o contrário.
Diátaxis + CIÁrvore tutorials/how-to/reference/explanation + workflow de CI e Dependabot multi-ecossistema.

Ultron Mode por dentro

Engenharia para comprimir sem quebrar nada

Comprimir contexto é fácil; comprimir sem corromper um SHA, vazar um secret ou travar seu fluxo é o problema real. Cada peça abaixo existe para isso — e todas estão no ultronpx 2.x que acompanha o pacote.

Verbatim Guard

destaque

SHAs · UUIDs · IPsIdentificadores exatos são extraídos para um sidecar textual antes do render — byte a byte, nunca viram pixel.
stack tracesCaminhos de arquivo e traces ficam legíveis por texto: o Claude cita a linha exata, não uma leitura aproximada.
secretsSecret detectado pina o bloco inteiro como texto — credencial nunca é renderizada em imagem.

Adaptive Gate

rentabilidade

threshold vivoO ponto em que compressão compensa se recalibra com telemetria real (EWMA com bounds duros) — não é um chute fixo.
model profilesPerfis por modelo + fidelity probe calibram o render para o modelo que você está usando.
render cacheBlocos repetidos entre requests não são re-renderizados — o custo do render é pago uma vez.

Economia auditável

em BRL

count_tokensCada request modificado registra o custo real e o contrafactual — medidos pelo endpoint gratuito da Anthropic, não estimados.
events.jsonlTrilha completa em ~/.ultronpx/events.jsonl: o que foi convertido, quanto custou, quanto teria custado.
dashboardDashboard local mostra o acumulado em BRL; ultronpx stats resume no terminal.

CLI

6 comandos

ultronpx setupInício guiado: config, licença, serviço em background e wrapper com fallback — num comando. Reversível com --undo.
ultronpx initCria ~/.ultronpx/config.toml e mostra os passos de ativação.
ultronpx activateAtiva a licença com um código de 6 dígitos enviado ao e-mail da compra.
ultronpx doctorValida porta, env, chave, conectividade, fontes de render e licença.
ultronpx startSobe o proxy em 127.0.0.1:47821.
ultronpx statsEconomia acumulada, direto no terminal.

Request entra → Verbatim Guard separa o intocável → gate decide se compensa → render (ou passthrough) → economia registrada. Tudo em 127.0.0.1.

A matemática dos pixels

Por que uma imagem custa menos que o texto

No texto, você paga por palavra — como num telegrama. Na imagem, você paga pelo tamanho da folha: a API cobra ⌈largura × altura ÷ 750⌉ tokens por imagem, não importa quanto texto está escrito nela. O ultronpx é o escriba que reescreve o telegrama em letra densa numa folha calibrada — e envia a foto.

Render real do ultronpx: system prompt e documentação de tools do Claude Code renderizados como uma única página PNG de texto denso — Render real do ultronpx: system prompt + tool docs de uma sessão do Claude Code viraram esta única página PNG. 1573 × 1248 px → ⌈1.963.104 ÷ 750⌉ = **~2.618 vision tokens**, independentemente de quantos caracteres estão espremidos na folha. O mesmo bloco em texto denso (~2 chars/token) custaria vários múltiplos disso.

A fórmula

Tokens por dimensão, não por conteúdo

Cada imagem custa ⌈(largura × altura) ÷ 750⌉ tokens de input, no preço normal do modelo. O custo é fixo pela geometria — quanto mais denso o texto dentro da folha, mais barato fica cada caractere.

Imagem	Cálculo	Tokens
500 × 500	250.000 ÷ 750	~334
1092 × 1092	1.192.464 ÷ 750	~1.590
1573 × 1248	1.963.104 ÷ 750	~2.618
1928 × 1928	3.717.184 ÷ 750	~4.956

A conta · 100k tokens densos

O teto físico da técnica

100.000 tokens de contexto denso (~190 mil caracteres) renderizados na densidade máxima que o cap atual de resolução permite:

	Como texto	Como imagem
Volume	100.000 tokens	~2,1 páginas PNG
Tokens cobrados	100.000	~10.300
No bloco ideal	—	~90% menos

E numa sessão agêntica o mesmo contexto é reenviado dezenas de vezes — a diferença se multiplica a cada request.

Os asteriscos honestos: ~90% é o teto do bloco ideal, não da fatura — na conta real entram prosa que continua como texto, turnos recentes protegidos e requests que o gate rejeita; por isso o ultronpx anuncia o número medido (até ~3× por bloco, ~45% de economia em tráfego real), não o teórico. E o teto depende do resample cap de cada geração de modelo: uma página maior que o cap é redimensionada pela API antes de tokenizar — cobrança menor, fidelidade destruída, nenhum erro visível. É exatamente o que os model profiles + fidelity probe existem para impedir: a geometria da página é calibrada por modelo e o recall é medido (0,93 no Fable com o renderer denso), não presumido.

Modelo de segurança

Um proxy no caminho da sua API key precisa merecer confiança

O ultronpx fica entre o Claude Code e a Anthropic — posição que exige garantias explícitas, não promessas.

API key nunca é gravada

A chave vive só no ambiente do cliente. O proxy repassa o header para api.anthropic.com e nunca a escreve em config, log, evento de telemetria nem pixel.

Secrets pinam o bloco como texto

Se o Verbatim Guard detecta um secret no bloco, o bloco inteiro fica fora do render — credencial nunca vira imagem, nem por acidente.

Identificadores byte-exatos

SHAs, UUIDs, IPs e stack traces vão para um sidecar textual antes do render. O Claude cita o commit exato — não uma leitura visual aproximada dele.

Fail-open sempre

Qualquer erro interno degrada para passthrough byte-idêntico — e se um request já imageado volta com 400 da API, o proxy reenvia o original intacto na hora (reforço da v2.2). Ele nunca bloqueia seu fluxo nem corrompe um payload — o pior caso é o comportamento sem ultronpx.

Local-first, zero analytics

Escuta em 127.0.0.1:47821; o único destino de rede é api.anthropic.com — o mesmo do Claude Code sem proxy. Nenhum byte de telemetria sai da sua máquina.

Auditável de ponta a ponta

Cada request modificado deixa rastro em ~/.ultronpx/events.jsonl — o que foi convertido, quanto custou, quanto teria custado. A licença é validada na ativação; depois disso, zero contato com servidores da B2Tech.

Entrega e ativação

Da compra ao proxy rodando

A entrega é automática após o checkout. O template chega por e-mail e GitHub; o ultronpx se ativa com o e-mail da compra. Requer Node.js ≥ 22.

Camada 1 · o template

Receba o Bootstrap Pro

Dois canais de entrega — o zip é a cópia licenciada oficial; o repositório é a conveniência git-native.

Zip com watermark, por e-mail. Snapshot do template com o fingerprint da sua compra em NOTICE.md — sua prova de licença. Guarde o original.
GitHub read-only (opcional). Informe seu usuário no pós-compra e receba convite pro repositório master: histórico, updates e o botão Use this template.
```
# updates futuros, direto do master
git remote add bootstrap <master-repo>
git fetch bootstrap
```
Instancie o projeto. Copie pro repo novo, rode o checklist de instanciação do README e faça o primeiro commit.
```
chmod +x .claude/hooks/*.sh
git init && git add . && git commit
```

Camada 2 · o proxy

Ative o Ultron Mode — 2 comandos

O ultronpx setup faz o fluxo inteiro num comando guiado: cria o config, ativa a licença, instala o proxy como serviço em background (restart automático) e o aponta no seu shell com fallback. Reversível com ultronpx setup --undo.

Instale e rode o setup. A licença chega como código de 6 dígitos no e-mail da compra; o setup encadeia config → licença → serviço → wrapper de shell → verificação.
```
# Node.js ≥ 22
npm install -g ultronpx
ultronpx setup
```
Abra um terminal novo e use o claude. Sem passo diário: o serviço mantém o proxy de pé e o wrapper decide a cada sessão — proxy vivo → comprime; fora do ar → API direta, sem erro.
```
claude          # uso normal, compressão transparente
ultronpx stats  # economia medida (USD/BRL), por dia e sessão
```

Prefere montar peça por peça — ou está sem systemd/launchd? Os comandos individuais (init, activate, doctor, start) continuam existindo; veja debaixo do capô logo abaixo.

Camada 2 · debaixo do capô

O que o `setup` faz por você (e o caminho manual)

Nada de mágica nem config global. O setup monta exatamente o que você faria à mão — e num Windows nativo, WSL sem systemd ou shell fora do padrão (fish) ele imprime estes passos em vez de instalar às cegas. Um proxy por máquina atende todos os seus terminais e projetos; não suba um por projeto.

O serviço em background. No Linux/WSL, uma unit systemd de usuário com Restart=always (morreu, volta em ~2 s) e enable-linger (sobe junto com a máquina, sem terminal aberto). No macOS, um LaunchAgent com KeepAlive.
```
# ~/.config/systemd/user/ultronpx.service (Linux/WSL)
[Service]
ExecStart=$(which ultronpx) start
Restart=always
RestartSec=2
```
O apontamento por sessão, com fallback. Um wrapper claude() no ~/.bashrc/~/.zshrc — nunca um export ANTHROPIC_BASE_URL fixo (isso anularia o fallback; se o setup acha um export antigo no rc, ele avisa mas não edita a linha). Vale em terminais abertos depois — por isso a mensagem final diz "abra um terminal novo".
```
claude() {
  if (echo >/dev/tcp/127.0.0.1/47821) 2>/dev/null; then
    ANTHROPIC_BASE_URL=http://127.0.0.1:47821 command claude "$@"
  else
    command claude "$@"
  fi
}
```

Controles quando precisar

systemctl --user stop ultronpx     # pausa: sessões vão direto pra API
systemctl --user start ultronpx    # retoma a compressão
journalctl --user -u ultronpx -f   # logs do proxy ao vivo
ultronpx setup --undo              # remove serviço + wrapper (config e licença ficam)

No macOS os equivalentes são launchctl unload/load do LaunchAgent — o setup imprime os caminhos. Alcance do fallback: o wrapper redireciona a base URL (todas as rotas — /v1/messages, count_tokens…), decidido no lançamento de cada sessão, não a cada request; se o proxy cair no meio, o systemd o recicla em ~2 s e o retry do Claude Code absorve o intervalo.

Perguntas frequentes

Ficou alguma dúvida? Escreva para bruno@b2tech.io.

Como compro e como recebo?

A compra é feita no checkout da Hotmart — o preço está lá. A entrega é automática: você recebe por e-mail o zip do template com watermark da sua compra (NOTICE.md com fingerprint) e, se informar seu usuário do GitHub, um convite read-only pro repositório master — histórico, updates e o Use this template. A licença do ultronpx é ativada com o e-mail da compra.

O que vem no pacote?

Duas camadas. (1) Claude Code Bootstrap Pro: o baseline .claude/ completo — CLAUDE.md, subagents, skills (/spec, /waves, /verify, /babysit-pr, /security-scan, /vertical-slice), hooks de segurança e continuidade, NOTES.md de memória viva, templates de ADR, OpenAPI, AsyncAPI e STRIDE, árvore Diátaxis e CI skeleton. (2) ultronpx 2.x: o proxy local de compressão visual de contexto, com licença vinculada à mesma compra.

Como o Ultron Mode corta o custo de tokens?

Vision tokens custam pela dimensão da imagem em pixels, não pela quantidade de texto dentro dela. Texto denso consome ~2 caracteres por token; renderizado na grade do ultronpx, chega a ~6 caracteres por vision token — até ~3× mais barato por bloco, com ~45% de economia medida por bloco imageado em tráfego real. A economia depende da densidade do workload: logs, JSONL, lockfiles e dados comprimem muito; prosa esparsa não compensa e o gate a mantém como texto — por design.

O Claude consegue ler o contexto virado imagem?

Sim — modelos Claude leem texto renderizado em imagem com alta fidelidade, e o ultronpx calibra o render por modelo (model profiles + fidelity probe; recall medido de 0,93 no Fable com o renderer denso). O que exige exatidão byte a byte nem vira pixel: o Verbatim Guard extrai SHAs, UUIDs, IPs e stack traces para um sidecar textual antes do render, e o gate adaptativo só converte um bloco quando a telemetria mostra que compensa.

E a minha API key? Meus dados saem da máquina?

A chave vive só no ambiente do cliente: o proxy repassa o header para api.anthropic.com e nunca a grava em config, log, telemetria nem pixel. Em runtime, o único destino de rede é api.anthropic.com — o mesmo do Claude Code sem proxy — e a telemetria de economia fica em ~/.ultronpx/events.jsonl, na sua máquina. A licença é validada na ativação; zero analytics remoto depois disso.

E se o proxy der erro no meio de um request?

Fail-open sempre: qualquer erro interno degrada para passthrough byte-idêntico — o request segue para a Anthropic exatamente como o Claude Code o emitiu. O pior caso do ultronpx é o comportamento que você já tinha sem ele; o proxy nunca bloqueia seu fluxo nem corrompe payloads.

O ultronpx ainda é open source?

A partir da v2, o ultronpx é software proprietário, licenciado mediante a compra do Bootstrap Pro 2.0 Ultron Mode. As versões publicadas até a 1.0.0 permanecem sob MIT, irrevogavelmente. O conceito original é o pxpipe, de teamchong — atribuição e agradecimento mantidos; os diferenciais do rewrite (Verbatim Guard, gate adaptativo, economia auditável, fail-open, local-first) são exclusivos do ultronpx.

É difícil de instalar e configurar?

Não. Depois da compra são dois comandos: npm install -g ultronpx e ultronpx setup. O setup é guiado e resolve tudo num fluxo — config, licença (código de 6 dígitos no e-mail da compra), o proxy como serviço em background com restart automático (systemd de usuário no Linux/WSL, LaunchAgent no macOS) e um wrapper de shell com fallback (proxy fora do ar = API direta, sem erro). A partir daí não existe passo diário: abra um terminal novo e use o claude. Reversível com ultronpx setup --undo; em plataforma sem systemd/launchd, ele imprime os passos manuais em vez de instalar às cegas.

O que preciso para rodar? Posso usar em quantos projetos?

Node.js ≥ 22, Claude Code e a licença ativa. O template pode ser usado em quantos projetos próprios você quiser — o que a licença veta é republicar, revender ou reempacotar o template em si. Quer dominar Claude Code de ponta a ponta? O Bootstrap Pro também acompanha o treinamento Claude Code Architect como bônus.

Comece agora

Arquitetura de projeto sênior,
com o contexto pelo preço que ele deveria custar.

Uma compra, duas camadas: o baseline .claude/ que estrutura todo projeto novo e o proxy que converte blocos densos em PNG quando compensa — com identificadores intactos, fail-open garantido e cada centavo auditado em events.jsonl.

Quero o Bootstrap Pro 2.0 Já comprei — instalar e ativar

zip com watermark + GitHub template · ultronpx via npm + licença · Node ≥ 22 · local-first

Todo projeto nasce com arquitetura sênior — e o contexto denso custa até 3× menos.