1. Antes de começar
O desenvolvimento de software evoluiu. Os desenvolvedores mais bem-sucedidos não apenas escrevem códigos, mas também orquestram ferramentas de IA e agentes para criar soluções melhores e mais rápidas. O ecossistema de ferramentas do Google oferece um pacote abrangente para todo o ciclo de vida: geração de interface, prototipagem e implantação de apps, desenvolvimento de recursos de IA e integração de back-end segura e escalonável. Neste codelab, você vai usar o Google Stitch para projetar a interface, o Google AI Studio para fazer a programação assistida por IA e implantar o app, e o Firebase para desenvolver recursos de IA e armazenar informações em um back-end seguro e escalonável.
O app que você vai criar neste codelab se chama Decide For Me, um assistente de decisões para pessoas indecisas que enfrentam escolhas de vida (como mudar de apartamento, mudar de carreira ou escolher um hobby). O usuário insere um dilema e as prioridades dele na vida, e o app usa a IA para ajudar a decidir com base no que minimiza a decepção a longo prazo. O app também oferece ao usuário uma primeira etapa concreta. A versão final do app será semelhante a esta:

O que você vai aprender
- Projetar interfaces com o Google Stitch.
- Criar um app da Web com vibe coding usando o Google AI Studio.
- Use o Firebase para desenvolver recursos de IA e armazenar informações na nuvem.
- Implantar um app da Web na produção com o Google AI Studio (com tecnologia do Cloud Run).
2. Criar a interface com o Stitch
- Faça o download da imagem de modelo (
DecideForMeScreen.jpeg). Salve-a em uma pasta local onde você possa encontrá-la. - Acesse Stitch, localize o campo de entrada e selecione a opção Web. Neste codelab, vamos focar na experiência da Web, mas você também pode usar o Stitch para gerar telas para dispositivos móveis.
- Faça upload da imagem de simulação:
- Clique em + (o botão de adição).
- Selecione Upload de arquivos.
- Anexe a imagem que você baixou na etapa de configuração (
DecideForMeScreen.jpeg). Esse modelo desenhado à mão permite testar os recursos multimodais do Stitch.
- Copie o comando abaixo e cole-o no campo de entrada:
# General Guidance Create a modern, clean, and highly polished UI for a web application called "Decide For Me" - a hyper-rational decision assistant. CRITICAL: Replicate the exact layout, structure, and element placement shown in the hand-drawn mockup file DecideForMeScreen.jpeg. Do not add any extra menus, sidebars, buttons, or top/bottom navigation bars that are not explicitly drawn in the file. Stick strictly to the skeleton provided in the mockup. # Layout & Structure - Two-Column Split Screen: - Left Side (Main Chat Area): Takes up roughly 70-75% of the screen width. It should feel like a premium, focused workspace. - Right Side (Configuration Panel): A sidebar taking up 25-30% of the screen width with a distinct, subtle background color to separate it from the chat. # Right Panel: Configuration Screen - Header: Title it "My Priorities" with a clean, minimalist typography. - Content Card: A styled card containing a text box or paragraph area showcasing the user's priorities. - Interactions: Include a clear "Edit Priorities" button. When clicked, this area should visually toggle into an editable textarea or input field. # Left Panel: Chat & Dilemma Decision Screen - Chat History: A clean vertical flow of message bubbles. - The first message bubble must be aligned to the left (system message) and say: "Tell me your dilemma". Use a friendly, neutral background color for this bubble. - Bottom Input Area: Instead of a traditional single-line chat bar, create a unified, beautiful "Decision Submission" layout positioned at the bottom: - Dual Input Fields: Place two horizontal or cleanly stacked input fields. - Input 1 label: "Option A" - Input 2 label: "Option B" - Action Button: A prominent, styled "Go" action button to trigger the reasoning loop. # Theme & Aesthetic - Vibe: Hyper-rational, clean, trustworthy, and modern. Use a sophisticated color palette (e.g., deep slates, clean whites/grays, and a sharp accent color like a subtle indigo or teal for active states and buttons). - Spacing & Typography: Use generous whitespace, soft rounded corners (border-radius) for cards and buttons, and a highly legible sans-serif font. - Clique na seta de geração no canto inferior direito do campo de entrada. O Stitch gera a tela e um sistema de design completo, incluindo uma paleta de cores, opções de fonte, iconografia e a aparência geral dos elementos da interface:

3. Criar o app com o Google AI Studio
- Crie um projeto do Firebase:
- Faça login no console do Firebase usando a mesma Conta do Google que você usou para o Stitch.
- Clique no botão para criar um novo projeto e insira um nome (por exemplo,
Decider App).
- Clique em Continuar.
- Se solicitado, leia e aceite os Termos do Firebase e clique em Continuar.
- (Opcional) Ative a assistência de IA no console do Firebase (chamada de "Gemini no Firebase").
- Neste codelab, você não precisa do Google Analytics. Portanto, desative essa opção.
- Clique em Criar projeto, aguarde o provisionamento do projeto e clique em Continuar.
- Exporte a tela que você criou no Stitch para o Google AI Studio:
- Clique no design gerado no Stitch.
- Clique em Exportar no canto superior direito da tela.
- Confirme se a opção selecionada é Google AI Studio.
- Role para baixo até o campo Descrição.
- Copie o comando abaixo e cole-o no campo Descrição. Substitua [FIREBASE_PROJECT_ID] pelo ID do projeto real da etapa 1. Se você não se lembrar do ID do projeto, ele pode ser encontrado nas configurações do projeto:
# General Guidance Build the "Decide For Me" app: A hyper-rational decision assistant for chronically indecisive people facing life choices (moving apartments, changing careers, picking a hobby). The user enters a dilemma and their top priorities in life. The app will help with the decision. Follow the instructions below to build it: # UI Instructions Using the design artifacts exported from Stitch (the PNG image and HTML file), build a fully functional web application that accurately mirrors the design and layout. # App Architecture & Initialization Instructions - Initialize the latest Firebase JS SDK for client-side services. Use the Firebase project with ID [FIREBASE_PROJECT_ID]. - Enable Firebase Authentication in this project using the Google provider. If a user is not logged in, show a clean, minimalist sign-in state. If the user is logged in, take them directly to the dilemma decision screen. - Initialize Firebase App Check in debug mode with the following code: `self.FIREBASE_APPCHECK_DEBUG_TOKEN = true;` `initializeAppCheck(app, { /* App Check options */ });` # State & Database Management Instructions - User Priorities: - Once authenticated, pull the user's saved priorities from Firebase Firestore at the path: `users/{userId}`. Each document should contain one string field: 'priorities'. - Bind this data to the Right Panel ("My Priorities"). - When the user clicks the "Edit" button, toggle the view to a textarea, with a 'save' button. When saved, write the updated string back to `users/{userId}`. - Make sure to implement and deploy strong Security Rules for Firestore. # UI Stream Update & Display Instructions - Once the user submits option A and option B in the dilemma decision screen, display both options as a single message on the user side of the chat. Then, display a sleek loading state in the main chat panel. Leave the app in this "loading" state and do nothing else, we will process both options and build the server-side thinking later. - Clique em Criar com o Google AI Studio. Isso abre o Google AI Studio em uma nova guia e transfere seus arquivos de design e comando:
- Confirme se o comando foi totalmente transferido.
- Se você vir apenas parte do comando, cole o comando inteiro novamente.
- Clique em Build. O Google AI Studio começa a gerar o app Decide For Me de acordo com seu comando e design de interface:
- Durante a geração, ele sugere designs de interface alternativos (ignore esses designs neste codelab, mas você pode optar por designs diferentes no futuro).
- Quando for solicitado que você ative o Firebase, clique em Ativar.
- Inspecione e verifique o app gerado:
- Teste o app na guia Visualização.
- Mude para a guia Código para analisar todos os arquivos e códigos gerados.
- O Google AI Studio também criou um projeto do Firebase, ativou o Firebase Authentication e o Firestore e configurou o Firebase na sua base de código. Você vai acessar e trabalhar com esse projeto do Firebase na próxima etapa deste codelab.
4. Registrar o token de depuração do App Check
Quando o Google AI Studio gera o app, ele cria um projeto do Firebase e conecta o app a ele. Você precisa acessar esse Projeto do Firebase e registrar seu ambiente de desenvolvimento em um serviço de segurança importante chamado Firebase App Check.
Acessar seu projeto do Firebase
- Encontre o ID do projeto do Firebase criado pelo Google AI Studio:
- Acesse a guia Código no Google AI Studio.
- Abra o arquivo
firebase-applet-config.json. - Copie o valor do campo
projectId.
- Acesse o console do Firebase e pesquise o projeto usando esse ID.
Registrar o token de depuração
Seu app pode usar o Firebase App Check para proteger seus serviços de back-end e modelos de IA contra abusos, garantindo que o tráfego de entrada seja proveniente apenas de apps legítimos.
Como o app está sendo executado no ambiente de pré-lançamento do Google AI Studio, ele usa o provedor de depuração do App Check (self.FIREBASE_APPCHECK_DEBUG_TOKEN = true). Quando o app da Web é carregado, o Firebase gera automaticamente um token de depuração no console para desenvolvedores do navegador.
- Encontre seu token de depuração:
- No Google AI Studio, abra as ferramentas para desenvolvedores do navegador enquanto visualiza a prévia do app:
- Chrome, Edge ou Firefox: pressione F12 (ou clique com o botão direito do mouse em qualquer lugar da visualização e selecione Inspecionar) e, em seguida, selecione a guia Console.
- macOS: pressione Cmd+Option+I e selecione a guia Console.
- Nos registros do console, localize a mensagem de depuração do App Check:
AppCheck debug token: "123a4567-b89c-12d3-e456-789012345678". You will need to safelist it in the Firebase console for it to work. - Copie a string do token (sem as aspas).
- No Google AI Studio, abra as ferramentas para desenvolvedores do navegador enquanto visualiza a prévia do app:
- Registre seu token de depuração:
- No console do Firebase, acesse Segurança > App Check > guia Apps.
- Encontre seu app da Web na lista, clique no menu de três pontos (⋮) e selecione Gerenciar tokens de depuração.
- Clique em Adicionar token de depuração, cole o token copiado, insira um nome como
Google AI Studio Previewe clique em Salvar.

5. Testar o app
Agora que seu projeto está conectado e o token de depuração está registrado no App Check, teste os recursos básicos: Authentication e Firestore.
- Teste a autenticação do usuário e salve as prioridades:
- Na prévia do app Decide For Me no Google AI Studio, teste a tela de autenticação fazendo login com uma Conta do Google.
- Salve suas prioridades de vida usando o painel à direita (Minhas prioridades).
- Verifique a autenticação no console do Firebase:
- Acesse o console do Firebase e abra Authentication.
- Confirme se a Conta do Google que você usou para autenticar no app Decide For Me está listada:

- Verifique o repositório de dados do Firestore:
- Abra o Firestore no console do Firebase.
- Confirme se as prioridades estão armazenadas em um documento no caminho
users/{userId}:

6. Criar um fluxo de decisão com tecnologia de IA usando o Firebase
Seu app vai usar a IA para as ações Decida por mim. Use o Firebase para criar esse fluxo de decisão com tecnologia de IA.
Configurar o Firebase AI Logic
- Ative a API Gemini Developer no Firebase AI Logic:
- Abra a Lógica de IA do Firebase no console do Firebase e clique em Começar.
- Selecione API Gemini Developer e siga as instruções no console para ativar a API.
- Defina as configurações do Firebase AI Logic:
- Acesse a guia Configurações.
- Ative a opção Aplicar o modo somente de modelo para Aplicado.
- Ative a opção Aplicar o modo de usuários autenticados para Aplicado.
Criar um modelo de comando de servidor
Neste codelab, você vai usar modelos de comando de servidor para suas interações com a API Gemini usando o Firebase AI Logic.
Antes de prosseguir com o modelo, leia o seguinte para entender por que é importante armazenar a configuração do modelo, as instruções do sistema e os comandos do lado do servidor:
- Proteção da propriedade intelectual: retira os comandos do dispositivo cliente e os mantém seguros no back-end.
- Prevenção de ataques de injeção de comandos: o cliente só pode preencher variáveis específicas com a validação de esquema de back-end.
- Atualização sem lançamentos de apps: é possível atualizar comandos, instruções do sistema e configurações de modelo no console sem lançar uma nova versão do app.
Veja como criar e testar um modelo de comando do servidor:
- Crie o modelo de comando do servidor:
- Acesse a guia Modelos de comando.
- Clique em Criar modelo.
- Selecione Modelo em branco.
- Crie seu primeiro modelo usando as seguintes informações:
- Nome do modelo: Decider Flow
- ID do modelo:
decider-flow - Configuração (frontmatter)
model: "gemini-3.5-flash-lite" input: schema: priorities: "string, user's core priorities" optionA: "string, option A under consideration" optionB: "string, option B under consideration" output: format: json schema: verdict: string justification: string firstStep: string - Comando e instruções do sistema (opcionais)
Adicione um{role "system"} You are the Decider Agent, a multi-stage reasoning engine that combines the roles of an honest and polite behavioral economist, a long-term strategic forecaster, and an executive decision coach. Your job is to take a user's dilemma and their core priorities, run them through a rigorous, adversarial 3-phase thinking process, and output a highly analytical, reasoning-backed final verdict. You must be direct, sharp, and realistic. Do not give generic platitudes or claim that "both options are great." You must force a clear choice. {role "user"} # Context & Inputs You are analyzing a critical life decision for the user. Base your entire multi-phase reasoning flow strictly on these three specific inputs: - User's Core Priorities: {{priorities}} - Option A under consideration: {{optionA}} - Option B under consideration: {{optionB}} Execute your reasoning flow through the following three phases: # Phase 1: Cynical Breakdown (Input-Driven Analysis) Analyze {{optionA}} and {{optionB}} strictly through the lens of the user's explicit {{priorities}}. Do not evaluate them in a vacuum. - Identify the hidden flaws, compromises, and psychological costs embedded in both choices. - Pinpoint exactly how {{optionA}} could directly conflict with or undermine their {{priorities}}. - Pinpoint exactly how {{optionB}} could directly conflict with or undermine their {{priorities}}. - Uncover any cognitive biases (like status quo bias or loss aversion) the user might be falling for in either option. # Phase 2: Long-Term Regret Projection Project the user 5 years into the future. Apply the Regret Minimization Framework to both paths: - The {{optionA}} Timeline: Quantify the absolute worst-case, deep, structural 5-year regret of choosing this path. Focus heavily on failures of courage vs. failures of action based on their {{priorities}}. - The {{optionB}} Timeline: Quantify the matching 5-year regret for this path. - Contrast these two timelines. Which option carries the kind of regret that fundamentally breaks the user's {{priorities}}? # Phase 3: Final Recommendation & Action Step Synthesize the cynical critiques and long-term regret scores. Weigh them against the user's {{priorities}} to determine which choice minimizes long-term disappointment. - Verdict: You must declare either {{optionA}} or {{optionB}} as the definitive winner. No compromise, no "it depends," and no hybrid options. - Justification: Provide a sharp, reasoning-backed explanation showing why the losing option was eliminated based on the Phase 1 and Phase 2 analysis. - First Step: Give one microscopic, low-friction task the user can execute within the next 15 minutes to commit to or move toward the chosen verdict.{}extra em torno de{role "system"}e{role "user"}para escrever as instruções do sistema e o comando na sintaxe correta:
- Entrada de teste
{ "priorities": "Be financially stable, have a good work-life balance where I can travel twice a year", "optionA": "Buy a house for 615000 British pounds with a mortgage of 2800 per month for the next 35 years", "optionB": "Keep renting for 2400 per month for the foreseeable" }
- Clique em Salvar modelo.
- Teste o modelo:
- Clique em Executar teste de comando.
- Localize a Resposta de teste e verifique se ela tem todos os campos especificados no comando (
verdict,justificationefirstStep). - Se tudo estiver de acordo com a resposta esperada, use o ícone de bloqueio no canto superior direito do modelo para garantir a estabilidade da versão e evitar modificações acidentais.
Seu modelo está pronto para ser usado pelo app.
7. Usar o modelo de comando Decider no app
Faça com que seu app da Web use o modelo:
- Volte para seu app no Google AI Studio.
- Peça ao agente do Google AI Studio para implementar a ação Decide For Me:
- Copie o seguinte comando:
Now let's implement the "Decide For Me" button action. When clicked, it should call the Firebase AI Logic SDK using a Template Generative Model. The prompt is stored in a prompt template with the id "decider-flow". When calling the API, pass the following variables as the input payload object: - priorities - optionA - optionB The API will return a JSON object. Handle the response asynchronously and extract: - verdict - justification - firstStep Once the data is received, update the UI state to append a new message to the chat array. Ensure it renders as a system chat bubble positioned on the left side of the chat screen, mapping these three fields clearly into the bubble's layout. Please provide the necessary front-end component state updates and the Firebase SDK call. - Cole o comando na entrada de chat do Google AI Studio e clique em Enviar.
- Copie o seguinte comando:
- Verifique a configuração e teste o assistente de decisão:
- Aguarde até que o Google AI Studio termine de adicionar o Firebase AI Logic ao seu app.
- Mude para a guia Código e verifique se há uma chave de API no arquivo
firebase-applet-config.json. Se a chave de API do Firebase não estiver no arquivo de configuração, peça ao Google AI Studio para importá-la. - Mude para a guia Visualização.
- Envie as opções A e B e verifique se a IA retorna o veredito da decisão, a justificativa e a primeira etapa.
Para referência, o código gerado pelo Google AI Studio deve ser semelhante a este:
const aiInstance = getAI(app);
const templateModel = getTemplateGenerativeModel(aiInstance);
const result = await templateModel.generateContent('decider-flow', {
priorities: priorities,
optionA: optA,
optionB: optB
});
const rawText = result.response.text();
// Parse response text to extract fields
const cleaned = rawText.replace(/```json|```/g, '').trim();
const parsedData: { verdict?: string; justification?: string; firstStep?: string } = JSON.parse(cleaned);
const verdict = parsedData.verdict;
const justification = parsedData.justification;
const firstStep = parsedData.firstStep;
Depurar e monitorar solicitações
Se o app encontrar erros, não gerar uma resposta ou se você quiser inspecionar o tráfego da API em detalhes, use as ferramentas de análise e monitoramento integradas do Firebase AI Logic:
- No console do Firebase, acesse Serviços de IA > Lógica de IA > guia Monitoramento de IA.
- Verifique as métricas quantitativas no painel:
- Volume e status das solicitações: verifique se as solicitações recebidas chegam ao back-end e retornam
200 OKou falham com erros de cliente ou erro de servidor. - Latência: inspecione o gráfico de latência para verificar o tempo de resposta de ponta a ponta.
- Contagens de tokens: monitore o uso de tokens de entrada e saída por solicitação.
- Volume e status das solicitações: verifique se as solicitações recebidas chegam ao back-end e retornam
- Inspecione traces de solicitações individuais para uma depuração detalhada:clique em um trace de solicitação específico na tabela de traces para inspecionar o payload.
- Entradas: confirme se as variáveis (
priorities,optionAeoptionB) foram transmitidas corretamente pelo app cliente. - Saídas: confira o texto bruto gerado pelo modelo para verificar se ele retornou um JSON válido que corresponde ao esquema.
- Detalhes do erro: se uma solicitação falhar, verifique o registro de erros de trace para identificar motivos como tokens inválidos do App Check, rejeição de autenticação, limites de cota ou erros de validação de comando.
- Entradas: confirme se as variáveis (
- Resolva problemas com o Google AI Studio:
- Se você identificar um erro no trace (por exemplo, análise de resposta JSON malformada ou parâmetros ausentes), copie a mensagem de erro ou o payload.
- Volte ao Google AI Studio e peça ao assistente para corrigir o problema correspondente no código do app.
8. Opcional: implantar o app
Agora que o app funciona no modo de pré-lançamento, implante-o na produção.
Para proteger seus endpoints do Firebase na produção, configure um provedor de atestado de produção para uso com o Firebase App Check. Neste codelab, você vai usar o reCAPTCHA v3.
Primeiro, implante o app para receber o URL ativo exato. Assim, você pode registrar o domínio específico com o reCAPTCHA em vez de permitir todos os apps ai.studio.
Implante o app e configure o reCAPTCHA:
- Implante o app da Web com o Google AI Studio:
- No Google AI Studio, clique em Publicar na barra de navegação de cima.
- Clique em Começar, revise ou personalize o nome e a descrição do aplicativo e clique em Publicar seu app.
- Aguarde o Google AI Studio criar e implantar o app (geralmente de 1 a 2 minutos).
- Copie o URL curto gerado (por exemplo,
https://decide-for-me-123.ai.studio) e anote o domínio (por exemplo,decide-for-me-123.ai.studio).
- Crie chaves do reCAPTCHA v3 no Google reCAPTCHA:
- Acesse o Admin Console do Google reCAPTCHA.
- Insira um rótulo (por exemplo,
Decide For Me - Production). - Selecione Tipo de reCAPTCHA > reCAPTCHA v3 (com base em pontuação).
- Na seção Domínios, adicione o domínio exato implantado do app (por exemplo,
decide-for-me-123.ai.studio, omitindohttps://e todos os caminhos) ou um domínio personalizado, se você planeja usar um. - Aceite os Termos de Serviço e clique em Enviar.
- Mantenha essa guia aberta: você vai precisar da Chave do site (chave pública do cliente) e da Chave secreta (chave privada do servidor).
- Registre sua chave secreta no console do Firebase:
- Acesse o App Check no console do Firebase.
- Acesse a guia Apps.
- Localize seu aplicativo da Web na lista, clique nele (ou no menu de três pontos ⋮) e selecione reCAPTCHA v3.
- Cole sua chave secreta do reCAPTCHA no campo e clique em Salvar.
- Configure o app cliente para usar
ReCaptchaV3Provider:- No Google AI Studio, mude para o painel de chat e peça ao assistente para atualizar sua configuração do App Check para produção:
Please update our Firebase App Check initialization to use ReCaptchaV3Provider with the reCAPTCHA site key "YOUR_RECAPTCHA_SITE_KEY", while retaining support for debug tokens in non-production environments. - Se você revisar o código diretamente na guia Código, verifique se a inicialização do App Check corresponde a esta estrutura:
import { initializeAppCheck, ReCaptchaV3Provider } from "firebase/app-check"; const appCheck = initializeAppCheck(app, { provider: new ReCaptchaV3Provider("YOUR_RECAPTCHA_SITE_KEY"), isTokenAutoRefreshEnabled: true }); - Depois de atualizar o código, publique novamente o app no Google AI Studio para enviar a configuração atualizada do App Check ao site ativo.
- No Google AI Studio, mude para o painel de chat e peça ao assistente para atualizar sua configuração do App Check para produção:
- Verifique o tráfego de produção e monitore o App Check:
- Abra o URL do aplicativo ativo em uma janela anônima do navegador, faça login com o Google e teste o envio de um dilema.
- Volte para o App Check no console do Firebase e inspecione as guias APIs e Monitoramento para verificar se as solicitações estão sendo registradas corretamente para o Firestore e o Firebase AI Logic.
9. Conclusão
Parabéns! Você criou um app útil com recursos de IA do zero, usando as ferramentas da pilha de criação do Google. Este é só o começo. Há muito mais que você pode fazer com as ferramentas do Google. Agora você tem um projeto na nuvem do Firebase + Google Cloud. Conheça todos os serviços disponíveis para você.
Acesse este link para resgatar o selo Jornada do Builder Concluída.
Para continuar sua jornada, acesse goo.gle/builders para o próximo laboratório.
Se você já usa o Antigravity 2.0, a plataforma dedicada do Google para orquestrar vários agentes autônomos em paralelo, pode exportar rapidamente seu projeto do Google AI Studio e importá-lo para o Antigravity para continuar trabalhando nele localmente. O Antigravity tem Habilidades de Agente para Firebase disponíveis para instalação com um clique. Essas habilidades também oferecem suporte para desenvolvimento para dispositivos móveis, o que ajuda a replicar esse app em ambientes Android e iOS, se você quiser.