Repositórios Expostos e Falhas em Deploy: Os Riscos Ocultos de Construir com Lovable, Vercel, Claude Code e Copilot

A nova geração de plataformas de desenvolvimento com IA — Lovable, Bolt.new, v0 da Vercel, Replit Agent, Claude Code e GitHub Copilot — democratizou a criação de software. Em 2026, qualquer pessoa com uma ideia consegue ter um SaaS funcional em produção em poucas horas. Mas essa velocidade cobra um preço que poucos percebem: repositórios públicos, secrets expostos e deploys sem revisão de segurança.

Nesta análise, mapeamos os riscos específicos de cada plataforma, com foco no ecossistema JavaScript/TypeScript que domina essas ferramentas, e fornecemos as correções que todo fundador e desenvolvedor precisa aplicar antes de ir para produção.

O Problema Central: Deploy Instantâneo = Segurança Zero

Todas essas plataformas compartilham um fluxo comum:

1. Você descreve o que quer em linguagem natural
2. A IA gera código React/Next.js/Supabase
3. A plataforma faz deploy automático (Vercel, Netlify, etc.)
4. Você recebe uma URL pública em minutos

O que nenhuma dessas plataformas faz por padrão:

• Revisar o código quanto a vulnerabilidades
• Configurar o repositório como privado
• Rotacionar secrets após o primeiro deploy
• Adicionar headers de segurança
• Implementar rate limiting nos endpoints

Plataforma por Plataforma: Onde Cada Uma Falha

Lovable — Repositório Público por Padrão

Risco crítico: Quando você faz deploy pelo Lovable, ele cria um repositório no GitHub público por padrão. Todo o código-fonte — incluindo lógica de negócio, queries do Supabase, chaves de API hardcoded e estrutura interna — fica visível para qualquer pessoa na internet.

O que atacantes encontram nesses repos:

• Chaves do Supabase (anon key e às vezes a service_role key)
• URLs de API internas e endpoints não protegidos
• Estrutura completa do banco de dados via tipos TypeScript
• Regras de negócio que revelam como burlar o sistema
• Variáveis de ambiente commitadas em .env ou hardcoded

Correção imediata:

# 1. Tornar o repositório privado
# GitHub → Settings → Danger Zone → Change visibility → Private

# 2. Se já estava público, TROCAR todas as chaves
# Supabase Dashboard → Settings → API → Regenerate keys

# 3. Verificar se .env está no .gitignore
echo ".env" >> .gitignore
echo ".env.local" >> .gitignore

# 4. Auditar o histórico do git
git log --all -p | grep -iE "supabase_key|api_key|secret|password|token"
# Se encontrou: as chaves já foram expostas, trocar TODAS

Bolt.new (StackBlitz) — Secrets no Código-Fonte

Risco crítico: O Bolt.new gera projetos completos no browser e frequentemente coloca chaves de API diretamente nos arquivos JavaScript/TypeScript. Como o código roda no client-side, qualquer chave incluída no bundle é visível no DevTools do navegador.

// ❌ O Bolt.new frequentemente gera isso
const supabase = createClient(
  'https://xyzcompany.supabase.co',
  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...' // anon key exposta no bundle
);

// ❌ Pior ainda — service_role key no frontend
const supabaseAdmin = createClient(url, 
  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...' // FULL ACCESS ao banco
);

Correção:

// ✅ Usar variáveis de ambiente (Next.js)
const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
);

// ✅ A service_role key NUNCA vai para o frontend
// Use API Routes (server-side) para operações admin
// pages/api/admin.ts
import { createClient } from '@supabase/supabase-js';
const supabaseAdmin = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY! // Sem NEXT_PUBLIC_ = só server
);

v0 da Vercel — Componentes Sem Sanitização

Risco crítico: O v0 gera componentes React bonitos e funcionais, mas raramente sanitiza inputs do usuário. Formulários, campos de busca e áreas de texto são renderizados sem escape, abrindo portas para XSS (Cross-Site Scripting).

// ❌ Gerado pelo v0 — XSS via dangerouslySetInnerHTML
function UserProfile({ bio }: { bio: string }) {
  return <div dangerouslySetInnerHTML={{ __html: bio }} />
}

// ❌ Gerado pelo v0 — renderiza URL sem validação
function ExternalLink({ url }: { url: string }) {
  return <a href={url}>Visitar</a>
  // Atacante pode usar: javascript:alert(document.cookie)
}

Correção:

// ✅ Usar biblioteca de sanitização
import DOMPurify from 'dompurify';

function UserProfile({ bio }: { bio: string }) {
  return <div dangerouslySetInnerHTML={{ 
    __html: DOMPurify.sanitize(bio) 
  }} />
}

// ✅ Validar URLs antes de renderizar
function ExternalLink({ url }: { url: string }) {
  const isValid = url.startsWith('https://') || url.startsWith('http://');
  if (!isValid) return null;
  return <a href={url} rel="noopener noreferrer">Visitar</a>
}

Claude Code — Poder Extremo, Zero Guardrails

Risco crítico: O Claude Code tem acesso total ao sistema de arquivos e terminal. Ele gera código funcional rapidamente, mas frequentemente:

• Cria servidores Express sem CORS configurado
• Implementa autenticação JWT com secret fraco
• Gera package.json com dependências desatualizadas
• Não adiciona validação de input nos endpoints

// ❌ Express server típico gerado pelo Claude Code
const express = require('express');
const app = express();
const jwt = require('jsonwebtoken');

app.use(express.json());
// Sem CORS, sem helmet, sem rate limit

app.post('/api/login', (req, res) => {
  const { email, password } = req.body; // Sem validação
  // ...verifica no banco...
  const token = jwt.sign({ userId: user.id }, 'secret123'); // Secret fraco
  res.json({ token }); // Sem httpOnly cookie, sem expiração
});

Correção:

// ✅ Express server seguro
import express from 'express';
import helmet from 'helmet';
import cors from 'cors';
import rateLimit from 'express-rate-limit';
import { z } from 'zod';
import jwt from 'jsonwebtoken';

const app = express();
app.use(helmet()); // Headers de segurança
app.use(cors({ origin: process.env.ALLOWED_ORIGIN, credentials: true }));
app.use(express.json({ limit: '10kb' })); // Limitar payload
app.use(rateLimit({ windowMs: 15 * 60 * 1000, max: 100 }));

const loginSchema = z.object({
  email: z.string().email().max(255),
  password: z.string().min(8).max(128),
});

app.post('/api/login', async (req, res) => {
  const parsed = loginSchema.safeParse(req.body);
  if (!parsed.success) return res.status(400).json({ error: 'Invalid input' });

  // ...verifica no banco com query parametrizada...
  const token = jwt.sign(
    { userId: user.id },
    process.env.JWT_SECRET!, // Secret forte em .env
    { expiresIn: '1h' }     // Expira
  );
  
  res.cookie('token', token, {
    httpOnly: true,   // Não acessível via JavaScript
    secure: true,     // Só HTTPS
    sameSite: 'strict'
  });
  res.json({ success: true });
});

GitHub Copilot — Autocomplete Que Ignora Contexto de Segurança

Risco crítico: O Copilot completa código baseado em padrões estatísticos, não em requisitos de segurança. Ele frequentemente sugere:

• eval() para processamento dinâmico
• Queries SQL concatenadas (em ORMs como Prisma com $queryRaw)
• Comparações de senha com === ao invés de funções timing-safe
• Configurações de CORS com origin: '*'

Google Apps Script / Google AI Studio — Permissões Excessivas

Risco crítico: Scripts gerados por IA para Google Workspace frequentemente solicitam escopos OAuth muito amplos — acesso total ao Drive, Gmail e Sheets quando só precisariam de uma planilha específica.

// ❌ appsscript.json com permissões excessivas
{
  "oauthScopes": [
    "https://www.googleapis.com/auth/drive",        // Acesso TOTAL ao Drive
    "https://www.googleapis.com/auth/gmail.modify",  // Pode MODIFICAR emails
    "https://www.googleapis.com/auth/spreadsheets"   // Todas as planilhas
  ]
}

// ✅ Escopos mínimos necessários
{
  "oauthScopes": [
    "https://www.googleapis.com/auth/drive.file",             // Só arquivos criados pelo app
    "https://www.googleapis.com/auth/gmail.readonly",          // Só leitura
    "https://www.googleapis.com/auth/spreadsheets.currentonly" // Só a planilha atual
  ]
}

A Bomba-Relógio dos Repositórios Públicos

O problema mais grave e menos discutido: bots automatizados varrem o GitHub 24/7 procurando por secrets expostos. Ferramentas como TruffleHog, GitLeaks e scrapers maliciosos detectam chaves de API em menos de 30 segundos após um commit público.

Dados do mercado:

• O GitHub reportou em 2025 que detectou e revogou automaticamente mais de 100 milhões de secrets em repos públicos
• Pesquisa da GitGuardian mostra que 1 em cada 10 desenvolvedores já expôs um secret em repo público
• O custo médio de um vazamento de chave de API para startups é de US$ 4.500 em uso indevido antes da revogação

O Que Fica Exposto em um Repo Público Típico de Vibe Coding

Checklist de Segurança Para Plataformas JavaScript de Vibe Coding

Aplique estes 15 itens antes de considerar qualquer projeto pronto para produção:

1. ☐ Repositório configurado como privado no GitHub
2. ☐ .env e .env.local no .gitignore
3. ☐ Nenhuma chave hardcoded — todas em variáveis de ambiente
4. ☐ Supabase Row Level Security (RLS) ativado em todas as tabelas
5. ☐ service_role key nunca no frontend (só em API Routes/server)
6. ☐ Helmet.js (ou headers equivalentes) ativado
7. ☐ CORS restrito ao domínio de produção
8. ☐ Rate limiting em todos os endpoints públicos
9. ☐ Inputs validados com Zod ou equivalente (server-side)
10. ☐ npm audit sem vulnerabilidades críticas
11. ☐ JWT com secret forte, expiração e httpOnly cookies
12. ☐ dangerouslySetInnerHTML protegido com DOMPurify
13. ☐ Google Apps Scripts com escopos OAuth mínimos
14. ☐ Git history auditado com GitLeaks ou TruffleHog
15. ☐ Dependabot ou Snyk ativado no repositório

Impacto Para o Mercado Brasileiro

No Brasil, estima-se que 65% dos novos micro-SaaS em 2026 são construídos total ou parcialmente com ferramentas de Vibe Coding. A combinação de repositórios públicos com a LGPD em plena aplicação cria um cenário de risco singular:

• Repositório público com schema do banco = mapa para extração de dados pessoais
• Chave do Supabase exposta = acesso direto ao banco com dados de usuários brasileiros
• Startup que sofre vazamento via repo público pode enfrentar multa de até R$ 50 milhões da ANPD

A mensagem para o ecossistema de startups brasileiro: Vibe Coding é acelerador, não substituto de segurança. Os 30 minutos gastos configurando repositório privado e variáveis de ambiente podem evitar meses de crise.

Conclusão

Lovable, Bolt.new, v0, Claude Code e Copilot são ferramentas extraordinárias que estão redefinindo quem pode construir software. Mas a facilidade de deploy mascara riscos sérios — especialmente repositórios públicos e secrets expostos no ecossistema JavaScript.

O código gerado funciona. Mas funcionar e ser seguro são coisas fundamentalmente diferentes. A responsabilidade de fechar essa lacuna é do desenvolvedor, não da IA.