Gemini · Gems, extensions, and knowing what to reach for
Gems, apps, and knowing what to reachreachThe number of unique people exposed to your message in a given period. Unlike impressions, reach counts each person once, no matter how often they see it.View full definition → for
Gems hold reusable instructions, apps (Google's current name for what used to be called extensions) give Gemini live reach into your services and the web, and a plain prompt is still the fastest path for a one-off job. The skill that separates someone who *uses* Gemini from someone who is fluent with it is knowing which of these to reach for before you start typing.
This lesson is about that decision. We will define each tool precisely and show where it lives in the product. Then we will walk a single real task through all three so the trade-offs are concrete.
Three tools, three jobs
Think of these as points on a spectrum from "stateless and instant" to "persistent and connected."
- Plain prompt: a single conversation. No saved configuration, no special powers beyond the model's native abilities (reasoning, native multimodality, long context). Fastest to start, nothing to maintain.
- Gem: a saved, reusable configuration of Gemini. You write persistent instructions once (role, tone, output format, steps to follow) and optionally attach reference files as knowledge. A Gem is *your* custom version of the assistant for a recurring job.
- App (formerly extension): a connector that lets Gemini take action in or pull live data from a specific service. Examples include Google Workspace (Gmail, Drive, Docs), Maps, YouTube, Flights, and a growing list of third parties. Apps are about *reach*, not personality.
A Gem changes *how* Gemini behaves. An app changes *what it can touch*. They are independent, and you can use both at once.
If you learned Gemini before 2025, you will see "extensions" in older tutorials and videos. The concept is the same. Only the name and the menu location changed.
Where each one lives
Gems and apps both live in the Gemini app. You create and manage Gems in the Gem manager (the "Explore Gems" / "New Gem" area in the sidebar). Apps are managed under Settings → Apps, where you connect the Google services and third parties you want Gemini to reach.
This lesson covers the consumer-facing Gemini app. The APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →-level and Vertex AI equivalents (function calling, grounding, agents) are a separate layer we will name at the end, because the decision logic is the same even when the plumbing differs.
The decision example
Here is one task, run three ways. You are a consultant. Every Monday you write a short status update for three clients, in their preferred tone, summarizing last week's work and flagging risks.
Run 1: plain prompt
If you only ever did this once, you would paste your notes and ask:
"Turn these notes into a client status update. Professional but warm tone. Three sections: Done, In Progress, Risks. Keep it under 200 words."
This is correct. For a single task, writing a Gem first would be overhead with no payoff. If you will not repeat the instructions, do not save them.
The plain prompt breaks down once you do this weekly across three clients. You end up re-typing the same formatting rules every time and copy-pasting tone preferences you keep forgetting.
Run 2: a gem
Now make it a Gem. You write the instructions *once* and they apply to every conversation you start with that Gem.
A good Gem instruction reads like an onboarding doc for a new assistant. Structure it:
Role: You are my client status-update writer.
Task: Convert my raw weekly notes into a status update.
Format:
- Three sections, in this order: Done, In Progress, Risks.
- Each item is one line, starting with a verb.
- Total under 200 words.
Tone: Professional but warm. Confident, never apologetic about delays;
state the mitigation instead.
Rules:
- If I give no risks, write "No risks flagged this week."
- Always end with one sentence offering a call if useful.
- Ask me which client this is for before writing.You can also attach knowledge files to a Gem: a doc of each client's tone preferences, your service descriptions, a glossary. Gemini treats these as reference context for every chat with that Gem. That attached knowledge is what separates a Gem from a clever saved prompt.
Your Monday workflow becomes: open the Gem, paste notes, answer "which client," done. The instructions never drift.
Gems can also be shared, much like a Drive file. If a colleague writes the same Monday updates, share the Gem with them so you both work from one set of rules instead of two drifting copies. Official guidance lives on Google's Gems help page.
Create your own Gems in the Gemini app
Run 3: connect an app
The Gem still has a gap: you are pasting notes manually. Your actual notes live in a Google Doc, and the client emails you reference are in Gmail. This is a *reach* problem, so it is an app problem.
With the Google Workspace apps connected, you can prompt:
"@Google Drive find my doc 'Acme weekly notes' and @Gmail pull any emails from Acme this week, then write the status update."
Gemini retrieves the live content and feeds it into the task. The *instructions* still come from the Gem, and the *data* now comes through apps. Personality and reach are doing separate jobs.
A few honest limits:
- Apps act on *your* data with your permissions. They have no access you do not have.
- The set of available apps changes often, and some depend on your account type and region. Check Settings → Apps for what is live for you rather than assuming.
- Treat app access as a capability you turn on at the account level and invoke per prompt. Do not assume a Gem guarantees a specific app will be used. If the task depends on Drive, say so in the prompt or in the Gem's instructions.
When grounding matters
If your task needs *current* facts (today's news, a live statistic, a recent product change), use grounding with Google Search. In the Gemini app this is the built-in ability to consult the web and cite sources. It is distinct from apps, which reach into specific named services. Rule of thumb: an app to touch *a system* (your Drive, Maps), grounding to verify *a fact* against the live web.
A decision checklist
Run any task through these questions in order:
- Will I repeat these instructions? No → plain prompt. Stop here.
- Does it need persistent rules, tone, or attached reference knowledge? Yes → make a Gem.
- Does it need live data or actions in a real service (my email, files, Maps)? Yes → connect the relevant app.
- Does it need current facts from the open web? Yes → use grounding with Search.
These are additive. The Monday task ended up using a Gem *and* apps, which is normal. The mistake is jumping to step 2 or 3 for a job that step 1 already solved.
The overcomplication trap
The most common error among capable people is building a Gem for something they will do twice. A Gem has a maintenance cost: when your client's tone preference changes, you must remember to update the Gem and its knowledge files. For recurring, high-value work that cost pays off fast. For a one-off, it is pure friction. Match the tool to the frequency and stakes, not to how impressive it feels.
Model choice is a separate axis
One more thing the three tools do *not* decide: which model runs them. Gems and apps work across Gemini's faster and more capable modes. Pick the fast option (Flash) for quick, high-volume, straightforward generation. Pick Pro or a thinking mode when the task needs deeper reasoning or large, complex context. The status-update Gem runs fine on Flash. A Gem that analyzes a 90-page contract against a risk rubric wants Pro. Make both choices deliberately.
Knowledge check
1. What is the core distinction between a Gem and an extension in Gemini?
2. For a task you will only ever do once, which tool does the lesson recommend reaching for and why?
3. Why would a consultant writing the same client status update every Monday benefit from creating a Gem rather than reusing a plain prompt?
4. Select ALL statements that correctly describe extensions in the Gemini app.
Select all the correct answers.
5. Select ALL statements that are true about how these three tools relate to one another.
Select all the correct answers.
Where this goes when you outgrow the app
The Gemini app is the right surface for personal and team workflows. When a workflow needs to run without you in the chair, or needs to ship inside software, the same concepts reappear under different names. Knowing the mapping saves you from relearning the decision.
- Reusable instructions (the Gem idea) become a system instructionsystem instructionThe hidden set of instructions that defines how an AI assistant behaves before any user types a question: its role, tone, limits and rules.View full definition → plus reference content in the Gemini API, prototyped in Google AI Studio. Same job, now version-controlled in code.
- Reach (the app idea) becomes function calling: you describe tools to the model, and it decides when to call them and with what arguments. Grounding with Google Search is also available as an API feature for live facts.
- Multi-step, autonomous behavior is where you move to the Agent Development Kit (ADK) for building agents, and to Vertex AI on Google Cloud when you need enterprise deployment, governance, and scale.
For developer-side automation, Gemini CLI brings the model to your terminal and Gemini Code Assist brings it into your IDE. Inside Workspace, Apps Script lets you script Gemini-powered automation across Docs, Sheets, and Gmail.
Here is the API-level version of our Monday Gem. The system instruction *is* the Gem's instruction block:
from google import genai
from google.genai import types
client = genai.Client()
response = client.models.generate_content(
# Alias that tracks the current Flash model; pin an exact version in production.
model="gemini-flash-latest",
config=types.GenerateContentConfig(
system_instruction=(
"You are a client status-update writer. Convert raw notes into "
"three sections (Done, In Progress, Risks), under 200 words, "
"in a professional but warm tone. If no risks are given, write "
"'No risks flagged this week.'"
)
),
contents="Notes: shipped onboarding flow, started billing migration, "
"vendor API was flaky Thursday.",
)
print(response.text)These are the same instructions you wrote into the Gem, now testable and embeddable in a product. Check the models page for current model names before pinning one, since Google retires older versions on a schedule. The checklist did not change. Only the surface did.
Key Takeaways
- Start with the cheapest tool that works. A plain prompt is correct for anything you will not repeat.
- Use a Gem when instructions, tone, or reference knowledge recur. Write it like an onboarding doc, attach knowledge files, and share it if teammates do the same job.
- Connect an app (the feature formerly called extensions, now under Settings → Apps) when you need live data or actions in a real service. Use grounding with Search when you need current facts from the open web.
- Tool choice and model choice are separate decisions: Flash for speed and volume, Pro or thinking modes for deep reasoning.
- The same ideas scale up to system instructions, function calling, and agents in the Gemini API, AI Studio, ADK, and Vertex AI. Learn the decision once and apply it at every level.
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
- Use @-mention extensions for app data, search grounding for public web facts