The Gemini app, gems, and personalization

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.

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

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:

| Layer | Holds | Example |

|---|---|---|

| Saved info | Stable facts about you | "I lead a data team" |

| Personalization | Context from your Google data | Tailored recommendations |

| Gem instructions | Task structure and rules | The meeting-notes format |

| Gem knowledge files | Reference material per task | Project codename glossary |

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 APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →, or a Workspace automation.
• Programmatic control over models, grounding, and output schemas. Move to Google AI Studio and the Gemini APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →.
• 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 APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition → 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 APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →.

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 APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →, ADK, or Vertex AI. Your Gem instructions become the spec.