The Gemini app, gems, and personalization

Stop retyping the same three paragraphs of setup every time you summarize a meeting: build a Gem once and call it for the rest of the year. This lesson tours the Gemini app surface, then goes deep on Gems and personalization, using a real meeting-notes assistant as the worked example.

The Gemini app is a surface, not a single thing

The Gemini app (gemini.google.com on web, plus the iOS and Android apps) is the consumer-facing front door to Google's models. The same conversation history, Gems, and personalization settings follow you across web and mobile because they are tied to your Google account, not the device.

Two model tiers matter day to day:

• Flash: fast, cheap, high-throughput. Your default for summarization, drafting, and quick reasoning.
• Pro: deeper reasoning, harder multi-step tasks, longer chains of thought. Slower, worth it when Flash gets it wrong.

You pick the model from the selector at the top of the app. Both are natively multimodalmultimodalAI that works across several input and output types at once: text, images, audio, video and data, instead of one format only.View full definition → (text, images, audio, PDFs, and on mobile, your camera and voice) and both carry long context, so dropping a 40-page PDF or an hour-long meeting transcript into a single prompt is normal, not a hack.

What's actually wired in

The Gemini app is not a bare chat box. A few capabilities change how you should think about prompts:

• Grounding with Google Search: for questions where freshness matters, Gemini can retrieve live results and cite them. This is the same grounding primitive you can later switch on via the APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →.
• Workspace access: if you're on an eligible Google Workspace plan, Gemini reaches into Gmail, Docs, Drive, and Calendar so you can ask "summarize the thread with Priya about the Q3 launch" without copy-pasting.
• Canvas: an interactive workspace for drafting docs and code side by side with the chat, so edits are iterative instead of one-shot.

Keep the distinction sharp: the Gemini app is the product you chat with. Google AI Studio and the Gemini API are where you build with the same models programmatically. We cover those later in the path. This lesson stays in the app.

Gems: configure once, reuse forever

A Gem is a saved, reusable version of Gemini that you preconfigure with instructions, tone, and optionally reference files. Think of it as a named assistant with a job description baked in. Instead of pasting your "act as my meeting summarizer, output these sections, use this tone" preamble every session, you save it once and the Gem remembers.

You'll find Gems in the left panel of the Gemini app under "Gems," with a Gem manager for creating and editing them. Google ships several premade Gems (Learning coach, Brainstormer, Writing editor, Coding partner), but the real power is custom Gems.

A Gem holds:

• A name (how it shows up in your list)
• Instructions (the system-prompt-style brief: role, steps, output format, constraints)
• Knowledge files (optional uploads the Gem can always reference)

The official walkthrough lives at support.google.com under "Create and use Gems."

When a Gem beats retyping

**Use a Gem when the *setup* is stable but the *input* changes every time**. Meeting notes are the canonical case: the format you want never changes, only the transcript does. Same logic for a recruiting-screen Gem, a release-notes Gem, or a "rewrite this in our brand voice" Gem.

Do not build a Gem for a one-off task. The overhead isn't worth it. The break-even is roughly the third time you catch yourself pasting the same instructions.

Worked example: the meeting-notes Gem

Here's the instruction block I'd put in a meeting-notes Gem. Notice it's specific about structure, owners, and what to do when information is missing.

You are my meeting-notes assistant. I will paste a raw transcript
or rough notes. Produce output in exactly this structure:

## TL;DR
Three bullets max, plain language.

## Decisions
- Each decision on one line, with who made the call.

## Action items
- [ ] Task — Owner — Due date (write "no date" if none stated)

## Open questions
- Anything unresolved or needing follow-up.

Rules:
- Never invent owners or dates. If unclear, write "unassigned".
- Quote a name only if it appears in the input.
- Keep it under 250 words unless action items demand more.
- If the input is not a meeting, say so and stop.

Save that as a Gem called "Meeting Notes." From now on the workflow is: open the Gem, paste the transcript (or attach the recording), send. No preamble, ever.

Feed it real meeting input

Two practical ways to get a transcript into the Gem:

1. Google Meet can produce transcripts and, on eligible Workspace plans, "take notes for me" via Gemini. Drop that transcript file straight into the Gem.
2. Record locally, then attach the audio file. The Gem's native multimodality means it can work from the audio directly; you don't need a separate transcription step.

The Gem's knowledge files are where this gets sharp. Upload your team's glossary or a list of project codenames as a knowledge file, and the Gem stops mangling "Project Halibut" into "project halibut, the fish." That reference travels with every invocation, no re-pasting.

Tighten the Gem like a senior would

First drafts of Gem instructions are always too loose. After a few real meetings you'll notice failure patterns and patch them:

• Owner getting assigned to whoever spoke last? Add: "Assign an owner only when the transcript explicitly says X will do Y."
• Output drifting long? The word cap above handles it.
• Dates hallucinated? The "no date" rule kills it.

This is the loop: run it on real input, find the lie or the drift, add one rule, repeat. A mature Gem is mostly accumulated guardrailsguardrailsRules and controls that keep an AI system inside safe, legal and on-brand boundaries, blocking outputs and actions that cross the line.View full definition →.

Personalization: how Gemini adapts to you

Personalization is separate from Gems, and the distinction matters.

• A Gem is task-scoped: it shapes one assistant for one job.
• Personalization is account-scoped: it shapes how Gemini responds to *you* across everything.

Two layers to know:

Saved info. You can tell Gemini durable facts about yourself ("I manage a 6-person data team," "I prefer bullet points over prose," "I write in British English") and it applies them going forward. Manage these in settings under "Saved info." This is the lightweight, always-on personalization.

Personalization with your Google data. With your permission, Gemini can draw on relevant context from Google services (for example, Search history) to tailor answers. This is opt-in and toggleable. Turn it off if you'd rather keep responses generic, or keep it on when you want recommendations that actually fit your patterns.

Gems plus personalization stack

These layers compose. Your account-level "I prefer concise British English" applies *inside* the meeting-notes Gem too, without you writing it into the Gem instructions. So keep personal style preferences in Saved info and keep task structure in the Gem. Don't duplicate them. If you hardcode "be concise" into ten Gems, you have ten places to edit when you change your mind.

A clean division of labor:

Sharing Gems and where they live

Gems are tied to your account, but in Workspace contexts you can share a custom Gem with teammates so everyone gets the same structured output. That turns your meeting-notes Gem from a personal shortcut into a team standard: same sections, same owner rules, same glossary, for everyone in the org. Admin policies on Workspace plans govern whether sharing is enabled, so check with your workspace admin if the option is missing.

This is the moment a Gem stops being a convenience and becomes process. When five people summarize meetings the same way, downstream automation (a Sheet of action items, a status digest) suddenly has consistent input to parse.

When you've outgrown a Gem

Gems are powerful but bounded. They live in the app, run on demand, and can't take actions on their own. You've outgrown a Gem when you need:

• Automation on a trigger (summarize every meeting the moment its transcript lands). That's a job for Apps Script calling the Gemini API, or a Workspace automation.
• Programmatic control over models, grounding, and output schemas. Move to Google AI Studio and the Gemini API.
• Multi-step tools and orchestration (the assistant decides which actions to take). That's the Agent Development Kit (ADK) territory, and at production scale, Vertex AI.

Here's the same meeting-notes logic as an API call, which is where you'd go to automate it. You'll learn the SDK properly later in the path; this is just the bridge from "Gem" to "code."

from google import genai

client = genai.Client()  # reads GEMINI_API_KEY from your environment

SYSTEM = (
    "You are a meeting-notes assistant. Output: TL;DR (3 bullets), "
    "Decisions, Action items as '[ ] Task — Owner — Due', Open questions. "
    "Never invent owners or dates; write 'unassigned' or 'no date'."
)

transcript = open("standup.txt").read()

resp = client.models.generate_content(
    model="gemini-2.5-flash",
    config={"system_instruction": SYSTEM},
    contents=transcript,
)

print(resp.text)

The instruction block is nearly identical to your Gem. That's the point: a well-built Gem is a working spec for the automated version later. You're not throwing work away when you graduate from app to API.

Key Takeaways

• Build a Gem when setup is stable and input changes. Meeting notes, release notes, and brand-voice rewrites are ideal; one-off tasks are not. The break-even is the third repeat.
• Split responsibilities cleanly: task structure and reference files go in the Gem; your personal style and durable facts go in Saved info so they apply everywhere automatically.
• Make Gems strict, then tighten. Add explicit rules against inventing owners and dates, cap the length, and patch one guardrail each time you catch a failure on real input.
• Use knowledge files for stable reference material (glossaries, codenames) so the Gem stops mangling your team's vocabulary.
• Know the exit ramp: when you need triggers, schemas, or autonomous actions, move from the app to Google AI Studio, the Gemini API, ADK, or Vertex AI. Your Gem instructions become the spec.