---
title: "Build with Google AI Studio"
description: "Use Gemini and Inttegro to turn a business brief into a secure, working app."
canonical: "https://studio.inttegro.com/ai-builders/google-ai-studio"
format: inttegro-machine-docs/v1
language: "Ruby"
sdk_version: "v10.0.0"
reader_profile: optional
reader_manifest: "https://studio.inttegro.com/machine/ruby/readers/index.json"
reader_identification: "Optional: declare your client only if known and your current-session capabilities; use reader_manifest for supplemental recommendations."
preamble_estimated_tokens: 604
model_token_report: "https://studio.inttegro.com/machine/token-report.json"
preamble_questions: 5
preamble_source: "general"
recommended_mcp_tools: ["design_integration","check_integration_readiness","get_integration_guide"]
estimated_tokens: 2266
token_estimate_method: "utf8_bytes_divided_by_4"
---

## Machine preamble

**Summary:** Use Gemini and Inttegro to turn a business brief into a secure, working app. This Ruby representation uses the selected SDK's native names wherever Studio has a verified mapping.

### Five questions

#### Q1. When should the reader use Build with Google AI Studio?

Use this builder guide when that AI app builder is responsible for generating or extending the application.

#### Q2. What is authoritative on this page?

Use this page for orientation; follow its canonical SDK, guide, API, or MCP links for exact contracts.

#### Q3. What page-specific constraint matters most?

Keep API keys and live commerce calls in the builder’s protected server environment, never generated browser code.

#### Q4. Can Inttegro MCP materially help with this task?

Yes, when the reader has an authenticated MCP connection and the task needs live context, guided planning, or a supported operation. The strongest matches are `design_integration`, `check_integration_readiness`, `get_integration_guide`; their exact roles and boundaries are listed below.

#### Q5. How should the reader verify the answer and continue?

Inspect the generated server boundary, confirm secrets are not client-visible, run the documented end-to-end test, and verify authoritative commerce state.

### Recommended MCP assistance

Use these through an authenticated Inttegro MCP connection. This document remains the contract source.

- [`design_integration`](https://studio.inttegro.com/machine/ruby/inttegro-mcp/tools.md#design_integration) — read-only integration guidance. Elicits the integration goal, AI app builder, server runtime, SDK preference, and checkout approach, then returns a platform-aware build and test plan without accepting credentials.
- [`check_integration_readiness`](https://studio.inttegro.com/machine/ruby/inttegro-mcp/tools.md#check_integration_readiness) — read-only integration guidance. Audits platform secret storage, server-runtime compatibility, idempotency, errors, state verification, checkout returns, and messaging consent without receiving source code or credentials.
- [`get_integration_guide`](https://studio.inttegro.com/machine/ruby/inttegro-mcp/tools.md#get_integration_guide) — read-only integration guidance. Returns a focused implementation sequence and canonical Studio links for authentication, checkout, orders, catalog, messaging, idempotency, or testing.

## Document content

# Build with Google AI Studio

[Google AI Studio](https://aistudio.google.com/) can turn a business brief into
a working web or Android experience, show it in a live preview, and help you
publish it. Inttegro MCP can prepare the integration plan; the finished app then
performs live Inttegro work through a protected server.

[Open Google AI Studio](https://aistudio.google.com/) · [Read the Google AI Studio documentation](https://ai.google.dev/gemini-api/docs/aistudio-build-mode)

:::warning Planning and the published app are separate

Google documents external MCP tools for the **Agents playground**, while app
creation happens in **Build mode**. Use the agent to produce an Inttegro-aware
plan, then give that approved plan to Build mode. The published app must call
the Inttegro API from server code—it does not inherit the agent's MCP access.

:::

## Plan with Inttegro MCP

1. Open the **Playground** in Google AI Studio and switch to **Agents**.
2. In the agent's tool configuration, connect the Inttegro MCP server at
   `https://mcp.inttegro.com` using the least privilege available.
3. Keep write operations subject to human approval and test with disposable
   Inttegro data.
4. Ask the agent to call `design_integration`, review the returned plan, and
   carry only the approved brief into Build mode.

Google's [Agents playground guidance](https://ai.google.dev/gemini-api/docs/aistudio-agents)
covers external MCP tools, least privilege, test data, and human oversight.

## Paste this into Build mode

Open [Google AI Studio Build mode](https://ai.google.dev/gemini-api/docs/aistudio-build-mode)
and start with the approved plan from the previous step. If you skipped the
Agents playground, add links to the relevant Inttegro Studio operation pages so
Gemini has the exact contracts rather than asking it to guess.

### Prompt

> **Copyable prompt:**
>
> **Business outcome**Build \[describe what a customer or team member should be able to accomplish]
> for \[describe the business and its users]. Make it feel native to the business,
> and preserve any existing visual language, authentication, and data.**Understand the experience before changing it**
>
> 1. Read the approved Inttegro integration plan and inspect every current file,
>    screen, user flow, data source, and server boundary that it affects.
> 2. Ask me one concise round of questions for unresolved business decisions. Do
>    not ask me to paste an Inttegro credential into the prompt.
> 3. Show me the recommended journey, the Inttegro operations it uses, what data
>    stays in this app, failure and recovery states, and a definition of done.
>    Wait for approval before building.
>
> **Build the approved journey**
>
> - For a web app, put every live Inttegro call in AI Studio's server-side
>   runtime. Browser code may call that boundary but must never receive the
>   Inttegro credential.
> - Add `INTTEGRO_API_KEY` through **Settings → Secrets** and read it only in
>   server code. Never put it in browser code, a prompt, source control, logs, or
>   an error response.
> - Inspect the actual server runtime before choosing a client. Use the official
>   Inttegro TypeScript SDK only when the runtime satisfies its documented Node.js
>   requirement; otherwise make exact server-side HTTPS calls from the Studio
>   operation references.
> - For an Android app, never put `INTTEGRO_API_KEY` in the APK. Use a separate
>   authenticated backend for privileged Inttegro work and expose only the narrow
>   actions the mobile experience needs.
> - Validate and authorize browser or mobile input at the server boundary. Use a
>   stable idempotency key for every mutation, and look up the authoritative
>   resource after redirects, timeouts, or uncertain results.
> - Build complete loading, success, empty, retryable-error, and terminal-error
>   states. Do not copy Inttegro resources into local storage without a specific
>   business reason.
>
> **Verify and publish**Run the project's checks and `check_integration_readiness`. Exercise the full
> happy path and one safe failure path in Preview at mobile and desktop sizes.
> Inspect generated code and browser traffic for accidental client-side Inttegro
> calls. Fix failures before publishing, then report the server files changed,
> the single secret I must configure, test evidence, and the one action I should
> take next.

## What Google AI Studio should create

- one obvious journey from the user's intent to a confirmed outcome;
- a narrow, authenticated server action for each Inttegro workflow;
- protected secret access in server code only;
- stable idempotency and authoritative recovery after uncertain results;
- useful feedback for every waiting, success, and failure state; and
- a reviewed project that can be synchronized to GitHub or published.

Google's [server and secrets guide](https://ai.google.dev/gemini-api/docs/aistudio-fullstack)
describes the protected runtime, third-party credentials, and external API
calls available to Build mode.

## Choose the right publishing path

For a web experience, AI Studio can publish the app to a managed
[Cloud Run](https://cloud.google.com/run/docs) service. Review the generated
code, configure the required secret, and verify
the deployed browser traffic before sharing the URL. The official
[deployment guide](https://ai.google.dev/gemini-api/docs/aistudio-deploying)
explains the available publishing tiers and URLs.

If you connect GitHub, treat the repository as the durable record: review the
diff, run the same checks outside the preview, and merge through your normal
review process. For Android, keep privileged Inttegro operations on the separate
backend even when the generated client is ready for device testing.
