+160 XP

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, then goes deep on Gems and personalization, with a 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 front door to Google's models. Your conversation history, Gems, and personalization settings follow you across web and mobile because they are tied to your Google account, not the device.

The model picker at the top of the app offers a few modes. Names shift as Google ships new model generations, but the trade-off stays the same:

  • A fast mode (built on Flash models) for summarization, drafting, and quick answers. This is your default.
  • A thinking mode that spends more time reasoning before it answers.
  • Pro, for the hardest multi-step work. Slower, and worth it when the fast mode gets it wrong.

All modes are multimodal (text, images, audio, PDFs, and on mobile your camera and voice) and carry long context, so dropping a 40-page PDF or an hour-long meeting transcript into one prompt is normal, not a hack. Usage limits on Pro and thinking modes depend on your plan.

What's actually wired in

The Gemini app has more behind it than a chat box. A few capabilities change how you should write prompts:

  • Grounding with Google Search: when freshness matters, Gemini retrieves live results and cites them. This is the same grounding primitive you can switch on via the API later.
  • Google apps access: Gemini can reach into Gmail, Docs, Drive, and Calendar (on eligible personal and Workspace accounts), 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 next to 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 in code. 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.

You'll find Gems in the left panel of the app, with a Gem manager for creating and editing them. Google ships premade Gems (Learning coach, Brainstormer, Writing editor, Coding partner and others), but custom Gems are where the value is.

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, including Google Drive files, that 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 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.

Skip the Gem for one-off tasks. 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. It is specific about structure, owners, and what to do when information is missing.

text
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.

Feed it real meeting input

Two practical ways to get a transcript into the Gem:

  1. Google Meet can produce transcripts and, on eligible plans, "take notes for me" via Gemini. Drop that file straight into the Gem.
  2. Record locally, then attach the audio file. Gemini works from audio directly, so you don't need a separate transcription step.

Knowledge files make this sharper. Upload your team's glossary or a list of project codenames, and the Gem stops mangling "Project Halibut" into "project halibut, the fish." That reference travels with every invocation.

Tighten the Gem like a senior would

First drafts of Gem instructions are always too loose. After a few real meetings you'll spot 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 handles it.
  • Dates hallucinated? The "no date" rule kills it.

The loop is simple. Run it on real input, find the lie or the drift, add one rule, repeat. A mature Gem is mostly accumulated guardrails.

How to create and use Gems in the Gemini app

Watch on YouTube

Personalization: how Gemini adapts to you

Personalization is separate from Gems, and the difference matters. A Gem is task-scoped: one assistant for one job. Personalization is account-scoped: it shapes how Gemini responds to you everywhere.

The controls live in Settings under Personal context. Three layers to know:

Instructions for Gemini (formerly called "Saved info"). Durable facts and preferences you state yourself: "I manage a 6-person data team," "I prefer bullet points over prose," "I write in British English." Gemini applies them going forward. You can view, edit, or delete each one.

Past chats. When this is on, Gemini can recall details from earlier conversations and use them as context, so you don't have to re-explain your project every week. You can turn it off, and Temporary chats are never used for it.

Connected Google data. With your permission, Gemini can draw on context from Google services such as Search history to tailor answers. It's opt-in and toggleable.

If you want a clean, generic answer for a single conversation, start a Temporary chat. It ignores personalization and isn't saved to your history.

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. So keep personal style in Instructions for Gemini and task structure in the Gem. If you hardcode "be concise" into ten Gems, you have ten places to edit when you change your mind.

LayerHoldsExample
Instructions for GeminiStable facts and preferences you state"I lead a data team"
Past chatsContext Gemini picks up from earlier conversationsRemembers your Q3 launch plan
Connected Google dataContext from services like SearchTailored recommendations
Gem instructionsTask structure and rulesThe meeting-notes format
Gem knowledge filesReference material per taskProject codename glossary

Knowledge check

1. Why does your conversation history, Gems, and personalization follow you between the web and mobile versions of the Gemini app?

2. In day-to-day use, when should you prefer the Pro model tier over Flash?

3. What is the best way to understand what a Gem actually is?

MULTIPLE CHOICE

4. Select ALL statements that correctly describe capabilities wired into the Gemini app.

Select all the correct answers.

MULTIPLE CHOICE

5. Select ALL statements that correctly capture the distinction between the Gemini app and Google AI Studio / the Gemini API.

Select all the correct answers.

Sharing Gems and where they live

You can share a custom Gem the way you share a Google Drive file: pick people, set view or edit access, send. Teammates get the same structured output, which turns your meeting-notes Gem from a personal shortcut into a team standard with the same sections, owner rules, and glossary for everyone. On Workspace accounts, admin policies decide whether sharing is allowed, so ask your admin if the option is missing.

This is where a Gem becomes process. When five people summarize meetings the same way, downstream automation (a Sheet of action items, a weekly status digest) gets consistent input to parse.

When you've outgrown a Gem

Gems live in the app and run on demand. You've outgrown one 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, where the assistant decides which actions to take. That's Agent Development Kit (ADK) territory, and at production scale, Vertex AI.

Here's the same meeting-notes logic as an API call. You'll learn the SDK properly later; this is the bridge from Gem to code. The example uses the gemini-flash-latest alias; check the models page for current model IDs if you want to pin a specific version.

python
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-flash-latest",
    config={"system_instruction": SYSTEM},
    contents=transcript,
)

print(resp.text)

The instruction block is nearly identical to your Gem. A well-built Gem is a working spec for the automated version, so nothing is wasted 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 fit; one-off tasks don't. Break-even is the third repeat.
  • Task structure and reference files go in the Gem. Personal style and durable facts go in Instructions for Gemini (formerly Saved info) so they apply everywhere.
  • Past chats memory and connected Google data add context automatically. Use a Temporary chat when you want neither.
  • Make Gems strict, then tighten: forbid invented owners and dates, cap length, and add one guardrail per failure you catch.
  • Share a Gem like a Drive file to turn a personal shortcut into a team standard.
  • When you need triggers, schemas, or autonomous actions, move to Google AI Studio, the Gemini API, ADK, or Vertex AI. Your Gem instructions become the spec.

What to do, from this lesson

These actions are compiled in the role's Playbook.

  • Build a Gem at the third repeat when setup is stable
  • Encode brand behavior as banned-word lists and before/after pairs, not adjectives
  • Split Gem task structure from personal style saved in global info
See the full action playbook →