Gemini 3.5 Flash Masterclass

Run a deep research thread on this topic.

OUTCOME: a structured briefing I can paste into a decision doc
covering what's known, what's contested, and what's worth
verifying before I act.

CONSTRAINTS:
- 600-900 words total
- Three sections: Current consensus · Where credible sources
  disagree · What's still uncertain
- Cite specific sources for every concrete claim (publication +
  date)
- Skip generic background ("X has been growing rapidly")
- Use Google Search grounding throughout

CONTEXT: the topic is [your topic]. My background level on this
is [novice / intermediate / expert]. The decision I'm trying to
make: [what you'll do with the answer].

TEST: a good briefing lets me walk into the decision tomorrow
with a defensible position. Every claim should be traceable to
a source I could check.

GATE: if the topic has changed materially in the last 90 days,
prioritize recent sources. If I'm asking about something
contested (politics, health, finance), surface the disagreement
explicitly rather than picking a side. Flag any claim where
you can't find a credible source.

Summarize this attached document/video into a brief I can use.

OUTCOME: a structured summary that captures what actually matters,
not what the author emphasized.

CONSTRAINTS:
- Three sections: TL;DR (3 sentences) · Key Points (5-8 bullets) ·
  What's Not Said (3 bullets — assumptions, gaps, missing context)
- Numbers over adjectives. Every claim cites a specific figure
  or timestamp.
- Skip the boilerplate intro and the conclusion section
- For video: include rough timestamps for the key points

CONTEXT: the attached file is [PDF / video / audio]. My purpose
in summarizing: [what you'll do with the summary]. The audience
for the summary: [me / my team / my exec].

TEST: a good summary lets the audience above answer "so what?"
in 30 seconds. The "What's Not Said" section should surface
the things you'd ask about if you were genuinely interested.

GATE: if the document is partly outside the model's expertise
(highly technical, legal, medical), flag the sections where you
hedged. If the document references other documents I haven't
shared, note what you're missing.

Triage my inbox from the last 24 hours into a daily digest.

OUTCOME: a single-page digest sorted by what needs my attention
today, what's informational, and what I can safely archive.

CONSTRAINTS:
- Three sections: Needs my attention today · Informational (FYI) ·
  Safe to archive
- For "needs attention": include sender, subject, the specific
  ask, and a draft 2-sentence response if the action is "reply"
- For "informational": one-line summary only
- For "safe to archive": just a count and a category breakdown
  (newsletters, automated, social, etc.)
- Skip anything I sent or replied to myself

CONTEXT: my role is [your role]. My top 3 priorities this week:
[list three]. People I should always treat as priority regardless
of subject: [list names].

TEST: a good digest lets me act on everything in the "Needs
attention" list in under 30 minutes. If that list has more than
10 items, you've been too generous — re-sort.

GATE: if anything looks like a security threat (suspicious
sender, unusual urgency, financial request from unverified
source), surface it at the top with a clear warning instead of
slotting it into the regular triage. Don't help me phish myself.

Draft this Doc in my voice, using context from my Drive.

OUTCOME: a Google Doc draft I can finish in 10 minutes of light
editing, not a generic template I have to rewrite.

CONSTRAINTS:
- Match the voice of [reference Doc title in my Drive]
- Same structure as [reference Doc title], adapted to this topic
- Inline citations to source Docs in my Drive using the [Doc Title]
  format so I can verify each claim
- Length: roughly [target word count]
- Tone: [formal / conversational / technical]

CONTEXT: the topic is [your topic]. The audience is [audience].
The decision or action this Doc supports: [outcome]. Reference
materials in my Drive folder: [folder name].

TEST: a good draft sounds like me, cites what I'd cite, and
makes the same argument I'd make. The 10-minute edit should be
polish, not rewriting.

GATE: if the reference Doc I named doesn't exist in my Drive or
isn't accessible, surface that before drafting (don't fabricate
a "similar" voice). If the source folder is empty or doesn't
match the topic, ask me where the right source materials live.

Set up a Spark routine that runs every weekday at 7am.

OUTCOME: a persistent agent that handles a repeatable task for me
in the background, delivering output where I want it.

CONSTRAINTS:
- The task to repeat: [describe what you want it to do]
- The trigger: [time / event / condition]
- The output location: [send to my inbox / append to a Doc / Slack me]
- The data sources to access: [Gmail / Calendar / specific Drive
  folder / external URL]
- The stop condition: [when to skip a day]

CONTEXT: I want this off my plate so I can stop thinking about
it. Currently I do this manually: [describe the manual process].
What it looks like when done right: [describe success].

TEST: a good routine runs reliably for 30 days without my
intervention. The output should look like what I'd produce
manually, but consistently.

GATE: before activating the routine, walk me through exactly what
data it will access, what it will do with that data, and where
it will send the output. Confirm I want to grant the integrations
listed. Run a dry-run on yesterday's data before going live.

Build me an interactive visual that explains [concept] for
my [audience].

OUTCOME: an interactive in-search experience I can use to
understand the concept hands-on, not just read about it.

CONSTRAINTS:
- The concept must be visually decomposable (not just text)
- Allow me to manipulate at least one variable and see the
  output change
- Cite at least three reliable sources alongside the interactive
- Mobile-friendly (most people will see this on a phone)

CONTEXT: the concept I want to understand: [your concept]. My
background level: [novice / intermediate / expert]. What I'll
do after understanding it: [decision / explanation / project].

TEST: a good experience teaches me the concept faster than a
3-minute video would. After interacting with it for 60 seconds
I should be able to explain the concept to someone else.

GATE: if the concept isn't well-suited to interactive visual
explanation (it's abstract, ethical, or contested), say so and
suggest an alternative format. Don't force a bad visual onto
a concept that needs prose.

Prototype this feature as a spec I can hand to engineering.

OUTCOME: a one-page spec covering the user story, the data model,
the API surface, the failure modes, and the acceptance criteria.
Engineering should be able to estimate from it.

CONSTRAINTS:
- Markdown structure, fits on roughly one screen when rendered
- Five sections: User story · Data model · API surface (endpoint
  shapes, not implementation) · Failure modes · Acceptance criteria
- For each failure mode: how it manifests, what the user sees,
  what the system should do
- For acceptance criteria: testable conditions, not aspirations

CONTEXT: the feature in plain language: [describe]. The system
it lives in: [describe stack]. The users: [describe]. The
constraint that's bounded similar features in this system:
[the gotcha that keeps biting].

TEST: a good spec gives engineering everything they need to start
without coming back to me with clarifying questions. Test it: if
you had to estimate this in story points right now, could you?

GATE: if the feature can be cleanly decomposed into smaller
shippable units, propose the split before drafting one big spec.
If the data model has implications for an existing table or
service, flag the migration concern explicitly.

Build a structured-output JSON pipeline that processes
[input type] into [output type].

OUTCOME: a tested, schema-valid extraction pipeline I can call
from production code. JSON only — no surrounding prose.

CONSTRAINTS:
- Use response_mime_type: "application/json" and a response_schema
- Schema-valid output every time. No prose, no markdown fences.
- Required fields fail loudly; optional fields are explicitly
  nullable
- Include 3 test inputs (happy path, edge case, adversarial)
  and the expected output schema for each

CONTEXT: the input type is [describe — natural language, scraped
HTML, OCR text, etc.]. The downstream consumer needs [describe
what the JSON feeds into]. The current state: [no extraction
yet / hand-rolled regex / different LLM].

TEST: schema-valid on 100% of the test inputs. The adversarial
input should produce a clearly-marked error response in the
same schema, not a hallucinated success.

GATE: if the response schema has ambiguous fields (free-text
strings where I should be using enums, dates without timezone),
propose tighter typing before generating the pipeline. If the
input is sometimes too messy for reliable extraction, surface
that as a recommendation to preprocess upstream.

Build a function-calling agent that completes [task] using
these tools.

OUTCOME: a working agent that plans, calls tools in the right
order, verifies results, and reports back. Production-deployable.

CONSTRAINTS:
- The tools available: [list with signatures]
- The success condition: [how we know we're done]
- The retry policy: [N retries, then fail loudly with context]
- Use parallel function calling where the calls are independent
- Validate every function response before passing to the next
  tool (id, name, response count must match per Gemini 3.5 spec)

CONTEXT: the task is [describe]. Existing systems the agent must
not touch: [list]. The cost ceiling per task: [token or dollar
budget]. The user who'll run this: [who, with what permissions].

TEST: the agent completes the happy-path task in under [time
budget] with under [token budget] tokens. The retry path
exercises in adversarial conditions.

GATE: this is tool-use territory. MCP Atlas benchmark says
roughly 1 in 6 tool calls in adversarial conditions misfires
on 3.5 Flash. Build retries, validate every response, and fail
loudly with full context on the third retry. Do not silently
succeed when the tool call failed.

Answer this question using Google Search grounding.

OUTCOME: a researched answer with inline citations to the
sources Search returned. Every concrete claim is traceable to
a specific URL.

CONSTRAINTS:
- Enable google_search as a tool
- Inline citations in the format [Source: domain.com] after
  every factual claim
- If sources disagree, surface the disagreement explicitly
  (don't pick one and hide the other)
- Prioritize primary sources over aggregators when both are
  available
- Skip claims you can't ground in a source (better to say "I
  couldn't find evidence for X" than fabricate)

CONTEXT: the question is [your question]. The recency requirement:
[any answer / past 90 days / past week]. The trust level needed:
[casual / professional / regulatory].

TEST: a good answer is defensible — every concrete claim is
traceable to a credible source. The citations should be real
URLs, not fabricated.

GATE: if the question is contested (politics, health, finance,
science with active debate), present the spectrum of credible
positions rather than synthesizing them into a single answer.
If recent reporting contradicts older consensus, weight by date
and explain.

Audit these screenshots against [criteria] and report
findings.

OUTCOME: a structured list of findings, each tied to a specific
screenshot, with the offending element identified by position
(approximate bounding region) or text content.

CONSTRAINTS:
- Process each screenshot in order
- For each finding: screenshot #, finding, severity, suggested fix
- Severity scale: critical (blocks user / breaks experience), high
  (visible bug), medium (polish issue), low (nit)
- Group findings by criterion at the end
- Skip findings that aren't material (don't carpet-bomb me with
  pixel-level nits)

CONTEXT: the criteria to audit against: [paste criteria — could
be brand guidelines, accessibility standards, UX heuristics,
spec compliance]. The artifact being audited: [describe — web
app, mobile app, print design].

TEST: a good audit catches the violations that exist and doesn't
flag things that look like violations but aren't. If a single
category has 20+ findings, you're being too generous — re-rank.

GATE: this is multimodal vision work where 3.5 Flash scores
84.2% on CharXiv reasoning. That's strong but not perfect.
Distinguish between findings you're confident about (severity:
high/critical) and findings that need a human to verify
(severity: medium/low). Be explicit about which is which.

This prompt is tested. Export to Antigravity for production
deployment.

OUTCOME: a working Antigravity project I can run locally,
extend, and deploy. Same behavior as the AI Studio prototype
but with proper structure (config, secrets, error handling,
logging).

CONSTRAINTS:
- One-click export from AI Studio (use the Export to Antigravity
  button)
- Verify the project runs on my machine before I extend it
- Production essentials: environment-variable config (not
  hardcoded keys), structured logging at INFO/WARN/ERROR,
  retry logic on tool calls, a README with run instructions
- Same model + thinking_level + tools as the prototype

CONTEXT: the AI Studio prompt I'm exporting from: [paste or
reference]. The runtime target: [local dev / cloud / Antigravity
managed agent]. The team that'll maintain this: [solo / small
team / production].

TEST: clone the exported project, install deps, set env vars,
run the example invocation. Output matches what AI Studio
produced in the prototype.

GATE: if any AI Studio feature I used doesn't have a clean
production equivalent (interactive vision feedback, ad-hoc
prompts), flag it before export. Don't silently drop
functionality in translation.

Scaffold a new [type of app] following our team conventions.

OUTCOME: a working project skeleton I can `cd` into and run
within 60 seconds, structured to match how we build things here.

CONSTRAINTS:
- Match the directory structure of [reference project path]
- Reuse existing tsconfig / pyproject / package.json patterns
- Include the same test runner setup we use elsewhere
- Add an AGENTS.md and CLAUDE.md / GEMINI.md tuned to this app
- Do NOT install new dependencies unless absolutely required;
  prefer what's already in the lockfile

CONTEXT: read AGENTS.md and GEMINI.md first for team conventions.
Look at [reference project path] for the pattern to mirror.
The app I want to scaffold: [describe what it does].

TEST: after scaffolding, I should be able to run the test command
from the README and get a passing empty test suite. The project
should pass our linter and type checker with zero errors.

GATE: before creating files, list every file you're about to
create and wait for my OK. Do NOT modify any existing file in
this repo without explicit permission. If the existing
conventions disagree across the codebase, ask which to follow.

Refactor [legacy framework] codebase at [path] to Next.js.

OUTCOME: the codebase is converted to Next.js with the existing
test suite still passing, the existing user-facing behavior
preserved, and the migration broken into reviewable chunks.

CONSTRAINTS:
- Deploy subagents in parallel across independent files
- File-by-file migration with two reviewers per file (one for
  correctness, one for adversarial behavior preservation)
- Each migrated file gets reviewed before being marked complete
- Use the existing project conventions for Next.js (read
  GEMINI.md, look at any pilot files already migrated)
- Save progress as you go — interrupted runs should resume from
  the last checkpoint

CONTEXT: the legacy framework: [Vue / Angular / Backbone / raw
HTML]. The path: [path]. The test suite: [path to tests]. Pilot
files already migrated: [paths or "none yet"]. The deployment
target: [Vercel / self-hosted / etc].

TEST: the migration is complete when every source file is in
Next.js, the existing test suite passes on the migrated
codebase, the linter is clean, and the build produces equivalent
output.

GATE: before fanning out subagents, propose the migration plan:
the dependency graph, the wave order, the per-file budget. Wait
for my approval. If during the run a wave reveals coupling that
prevents parallel work, STOP that wave, surface it, and ask
whether to redesign. Do not ship a half-migrated codebase as
"making progress."

Deploy parallel subagents to analyze this codebase against
[criterion].

OUTCOME: a consolidated report covering every part of the
codebase, with findings organized by severity and category.
Independent verification on every finding before it reaches
the report.

CONSTRAINTS:
- Split the codebase by directory; one subagent per top-level
  directory or service
- Each subagent reports findings in a structured format
  (file:line, severity, category, suggested fix)
- Adversarial verification subagent reviews each finding —
  false positives get removed before the final report
- Aggregate report deduplicates findings that span multiple
  subagents

CONTEXT: the codebase root: [path]. The criterion to analyze
against: [security / performance / dead code / convention
compliance / etc]. Examples of what counts as a finding: [paste
2-3 examples]. Examples of false positives: [paste 1-2 examples].

TEST: a good analysis finds the real issues and doesn't fill
the report with style nits. If a category has 100+ findings,
it's probably a false-positive class — flag it and ask whether
to refine.

GATE: before deploying subagents, show me the directory split
plan and the per-subagent budget. If two directories share so
much coupling that a parallel analysis will produce duplicates,
say so and suggest a different split.

Build [game / interactive app] using a builder-player loop
with two collaborating agents.

OUTCOME: a working playable artifact developed through rapid
self-improvement. The builder agent writes code; the player
agent plays / tests / breaks it. They iterate until convergence.

CONSTRAINTS:
- Agent A (builder): writes code to satisfy the spec
- Agent B (player): plays the game / exercises the interface,
  finds bugs, edge cases, and unsatisfying mechanics; reports
  back to the builder
- Cycle until the player can't find new issues or the budget
  is exhausted
- Final output: working artifact + a log of the iteration cycle
  so I can see what was discovered and fixed

CONTEXT: the game/app to build: [describe in detail — mechanics,
controls, win condition, tech stack]. The target experience:
[describe what good looks like]. The token / time budget:
[bounds].

TEST: a good final artifact is genuinely fun or genuinely useful,
not just functionally complete. The iteration log should show
the player agent finding real issues and the builder agent
fixing them.

GATE: before starting the loop, both agents share their
understanding of the spec. If they disagree on what's being
built, resolve that before iterating. Stop the loop if the
player runs out of meaningful findings — don't iterate for
the sake of token spend.

Adversarially review the diff in [PR URL or branch name].
Find what's wrong with it.

OUTCOME: a findings list ranked by severity, each finding tied
to a specific line, with the fix described in one sentence.
Don't praise. Findings only.

CONSTRAINTS:
- Severity scale: critical (production breakage), high (latent
  bug), medium (maintainability), low (style/nit). Don't pad
  with low-severity items.
- For each finding: file:line, severity, one-sentence issue,
  one-sentence fix
- End with one of two verdicts: READY TO MERGE or DO NOT MERGE:
  [reason]. No middle ground.

CONTEXT: the PR description is [paste description]. The
specification it was supposed to satisfy: [paste spec or link].
Existing code patterns: read GEMINI.md and the files adjacent
to the diff.

TEST: a good review finds the thing the author missed. If the
diff genuinely has no issues, say so — but don't invent issues
to fill a quota.

GATE: this is adversarial mode. You did not write this code.
Your job is to find what's wrong with it. If the diff matches
the spec and looks correct, your finding should be "DO NOT
MERGE: the spec itself is insufficient" or "READY TO MERGE."
Don't soften findings to be polite. Don't hedge. Speak in
observations, not suggestions.

Generate a Kotlin Android app skeleton for [app concept].

OUTCOME: a buildable Android Studio project with the core
screens scaffolded, a working build, and a runnable APK on the
emulator.

CONSTRAINTS:
- Kotlin + Jetpack Compose (no XML layouts unless I ask)
- Material 3 design system, light + dark mode support
- Single-module architecture for now (don't pre-modularize)
- Include navigation between the core screens
- Include one example unit test and one example UI test
- Min SDK 24, target latest stable

CONTEXT: the app concept: [describe]. The 3-5 core screens:
[list]. The single most important user flow: [describe end
to end]. My experience level with Android: [novice /
intermediate / experienced].

TEST: clone the project, open in Android Studio, sync Gradle,
run on emulator. The core flow above works end-to-end. Light
and dark mode both render correctly.

GATE: if the app concept needs platform-specific permissions
(camera, location, microphone, contacts), surface them with the
manifest entries before generating. If the concept fundamentally
needs a backend (auth, sync, storage), scope this prompt to the
client only and propose the backend separately.

Spin up a Managed Agent to autonomously complete [task] in
its sandbox.

OUTCOME: the agent executes the task to completion, reports
back with the artifacts produced, and shuts down cleanly. No
manual intervention required.

CONSTRAINTS:
- Use the antigravity-preview-05-2026 managed agent model
- Sandbox environment: Linux with Bash, Python, Node.js,
  browsing, file management
- Mount the necessary repo or GCS bucket so the agent can read
  source materials
- Define custom skills as markdown files for any task-specific
  patterns
- Budget cap: [tokens or time] — fail the run if exceeded

CONTEXT: the task: [describe in detail]. Source materials the
agent needs access to: [repo / bucket / URLs]. Output destination:
[where the artifacts go when complete]. Success criteria: [how
we know it worked].

TEST: a good run produces the expected artifacts at the output
destination and a clean exit log. The agent should not have
asked for human intervention beyond the initial spec.

GATE: this agent runs autonomously in its sandbox. Before
launching, walk me through every tool it will use, every
resource it will access, and every output location it can
write to. Confirm I've granted the necessary IAM permissions
on the mounted resources. If the task isn't well-suited to
autonomous execution (requires judgment calls a human should
make), say so before launching.

Audit this Google Workspace tenant against [policy or criterion]
and produce a structured findings report.

OUTCOME: a JSON report (schema-valid) covering every account /
Drive / file / setting that violates the policy, with severity,
remediation step, and the API call needed to fix.

CONSTRAINTS:
- Use the Admin SDK and Drive API via function calling
- Output as JSON conforming to a defined schema (no prose)
- For each finding: account/resource ID, finding category,
  severity, remediation step, the exact API call to remediate
- Group by severity at the report root, then by category
- Skip user accounts that are dormant (last activity > 90 days)
  unless the policy explicitly covers them

CONTEXT: the tenant domain: [domain]. The policy or criterion:
[paste — could be security baseline, compliance requirement,
license audit, etc]. Examples of violations: [paste 2-3]. Things
that look like violations but aren't: [paste 1-2].

TEST: schema-valid JSON, every finding traceable to a specific
resource, the remediation steps are real API calls that would
work if executed. Run a sample remediation on one low-severity
finding to verify the API call format.

GATE: this audit reads sensitive tenant data. Confirm my OAuth
scopes are correct before starting. Do NOT execute any
remediation API calls during the audit — the report is read-only.
If the audit surfaces something that looks like an active
security incident (data exfiltration, credential exposure),
elevate it to the top of the report with a clear warning.