How to Prompt Google Gemini: Text, Files, Images, and Video

To prompt Gemini effectively, name the exact task, attach or paste the inputs the model should use, set constraints and an output structure, then verify the result against those requirements. Treat the first answer as a draft. Google's prompt design strategies emphasize clear instructions, constraints, and an explicit response format, and they treat prompting as iterative.

Gemini is not one product. The consumer Gemini app, Google AI Studio, the Gemini API, and Vertex AI expose overlapping ideas with different controls. Image understanding is not the same as Nano Banana image generation. Video understanding is not the same as video generation. Google's Gemini Apps help also notes that Gemini can make mistakes, so verify important answers.

This page is Gemini-product specific. For general fundamentals, see What Is Prompt Engineering?. For portable video craft, see the AI Video Prompt Guide. For model-neutral image fundamentals, see the AI Image Prompt Guide.

Pick the surface that matches the job. A feature in one place is not automatically available in every Gemini interface.

• Gemini consumer app (Gemini Apps help): everyday chat, drafts, summaries, multimodal Q&A, file and image uploads where enabled. Natural-language prompts work well here. It is not a substitute for API system_instruction, JSON Schema, or function declarations.
• Google AI Studio (aistudio.google.com): developer experimentation across Gemini text and multimodal models, Nano Banana, video models, and related tools before you move a prompt into an app.
• Gemini API (models index): build with text and multimodal models, image models, video models, system instructions, structured outputs, function calling, grounding, and file inputs. Capability matrices are per model code.
• Vertex AI / Gemini Enterprise Agent Platform (Generative AI overview): enterprise deployment, governance, and grounding in the Google Cloud stack. Console, IAM, billing, and rollout timing can differ from the consumer Gemini API.

Product-interface capabilities and API capabilities are related, not identical. Always check the surface you are actually using.

This guide uses TCI-COEV: Task, Context, Inputs, Constraints, Output structure, Examples, and Verification. It is a practical checklist created for GetBetterPrompts, not an industry standard. Related ideas appear in Google's prompt design docs and in API features such as system instructions, schemas, and tools.

Task: [what to produce]
Context: [who it's for; known facts; do not invent X]
Inputs: [list attached files/images and what they are]
Constraints: [length, tone, exclusions]
Output structure: [bullets / table / JSON fields…]
Examples: [optional short sample]
Verification: [cite sources | validate JSON | check 3 facts | compare to checklist]

Skip empty parts. Use Verification for visible checks: citations, schema validation, spot-checks, or visual QA. Do not ask the model to reveal hidden chain-of-thought or private internal reasoning as proof that an answer is correct. Some Gemini models use an internal thinking process; treat that as model behavior, not a user verification method. See Google's thinking docs.

For text work, put the job first, then the rules. Ask for the format you need: paragraphs, bullets, a table, or labeled sections. If the thread drifts, start a new chat instead of stacking conflicting corrections.

Weak:

Write about remote work.

Improved:

Task: Write a 200-word briefing for a team lead deciding whether to keep hybrid work.
Context: B2B SaaS, 40-person company, no HR legal advice.
Constraints: Neutral tone; 3 short sections with headings; no statistics unless labeled as illustrative.
Output structure: Heading + 2 bullets per section.
Verification: Flag any claim that would need a citation.

Why this is more controllable: task, audience, exclusions, structure, and verification replace an open-ended topic.

Consumer-app example: “I'm drafting a customer email. Keep it under 120 words, friendly, no emojis. Ask one clarifying question at the end if the refund policy is unclear. Here is the draft: …”

For portable writing patterns beyond Gemini, see How to Write Better AI Prompts.

When the source already exists as a file, attach it instead of paraphrasing it from memory. Google's document understanding docs describe PDF analysis with native vision for layout-aware tasks such as text, tables, and charts. Prefer the Files API for large or reused documents. Page and size limits are time-sensitive; confirm them on the page you use.

Weak:

Summarize this PDF.

Improved:

You are analyzing the attached PDF (Q2 product roadmap).
Task: Extract decisions, owners, and open questions.
Constraints: Use only information visible in the PDF; if a field is missing, write "Not stated".
Output structure: Markdown table with columns Decision | Owner | Due date | Open question.
Verification: Quote a short phrase from the PDF next to each Decision.

Why this is more controllable: the model is grounded in the file, invention is forbidden, and each claim has a checkable excerpt.

Image understanding analyzes an existing image. It is not image generation. Google's image understanding docs cover captioning and visual question answering. Multimodal prompts work best when you label each input and say what must come from the image versus from your notes.

Image-understanding weak:

What's in this image?

Improved:

Attached: store-shelf photo.
Task: List visible SKUs and any price tags you can read.
Constraints: Do not guess occluded text; say "unreadable" instead.
Output structure: Numbered list: item name | estimated facing count | price text or unreadable.
Verification: Separate "Visible" from "Inferred" if you must interpret packaging.

Why this is more controllable: it separates perception from inference and constrains hallucination on unreadable text.

Multimodal weak:

Compare these and write ads.

Improved:

Inputs: (1) product photo of a matte black water bottle; (2) pasted brand voice notes below.
Task: Propose 3 Instagram captions.
Constraints: No health claims; mention dishwasher-safe only if visible on the label in the photo; max 40 words each.
Output structure: Caption | on-image text overlay ≤6 words | rationale (1 sentence).
Verification: Mark any detail not visible in the photo as "from brand notes" or omit it.

Why this is more controllable: claims are bound to specific inputs, and seen facts stay separate from provided notes.

System instructions: In the Gemini API, put durable role, tone, and format rules in system_instruction, and keep the turn-specific task in the user input. See Google's text generation docs and Vertex's system instructions guidance.

The consumer app often blends durable rules and the instance into one message. Related product features such as custom instructions or Gems are useful, but they are not identical to API system_instruction.

API-oriented pattern:

• system_instruction: “You rewrite customer-support email drafts. Tone: plain, friendly, no emojis. Never invent policy. If policy is missing, ask one clarifying question instead of asserting terms.”
• User input: “Rewrite this draft under 120 words: …”

Why this is more controllable: durable rules stay stable across turns while each request carries only the instance.

Structured outputs: When you need machine-readable fields, configure structured output with a JSON Schema in the API rather than hoping chat JSON always parses. See structured outputs.

Weak (chat-only):

Return JSON with the invoice fields.

Improved (API-oriented field contract):

Fields: vendor (string), invoice_date (YYYY-MM-DD or null), total (number or null), currency (string or null), line_items (array of {description, amount})
Rule: null when not present; do not invent totals.

Why this is more controllable: schema fields plus a null policy beat open-ended “return JSON” requests.

Function calling / tools: The model can propose tool calls; your app must declare and execute them. See function calling. The model does not magically run your backend.

Grounding and visible source verification: Grounding with Google Search is an API tool that can fetch web sources and return citations when enabled for a supported model. Consumer-app Search features are a different control surface. Grounding helps factuality; it does not eliminate the need to verify critical facts yourself.

Nano Banana is Google's name for Gemini's native image generation family. Official image generation docs currently describe multiple model IDs with different speed, quality, reference, and resolution profiles, including Nano Banana Pro (gemini-3-pro-image), Nano Banana 2 (gemini-3.1-flash-image), and Nano Banana 2 Lite (gemini-3.1-flash-lite-image). Pick a specific model ID; do not treat “Gemini image” as one capability set.

Prompt with full descriptive sentences: subject, setting, lighting, composition, exclusions, and aspect ratio when the surface accepts it. Iterate conversationally on supported models: generate, then change one variable at a time.

Weak:

Make a cool cafe.

Improved:

A cozy coffee shop on a rainy afternoon, seen through a foggy window, with warm yellow light inside and blue-gray tones outside. No logos, no readable brand names, 3:2, warm interior / cool exterior contrast.

Why this is more controllable: subject, lighting, composition, exclusions, and ratio replace a vague aesthetic request.

Time-sensitive capability notes from current docs (re-check before you ship a workflow): official materials describe mixing up to 14 reference images with different object, character, and style slot budgets by model; Nano Banana 2 documents 0.5K / 1K / 2K / 4K and additional aspect ratios; Lite is documented as 1K-only and not optimized for multiple references or multi-turn sequential editing. Generated images include a SynthID watermark. Check Google's usage policies before commercial workflows that involve real people or brand assets.

For deeper image craft, see the AI Image Prompt Guide and the Midjourney and Nano Banana cheat sheet. Browse ready-to-copy Gemini AI photo prompts with example images, or try prompts in the image prompt tool.

Video understanding analyzes an existing clip: describe it, answer questions, or extract moments. See Google's video understanding docs. Video generation creates a new clip from text, images, or related workflows. Do not collapse both into “Gemini video.”

As of the current Gemini API video generation documentation, Google recommends Gemini Omni Flash as the default model for video generation, highlighting multi-input reasoning and multi-turn conversational editing. Use Veo 3.1 when you need capabilities such as scene extension, last-frame control, or legacy-pipeline integration. On the models index, Omni Flash may appear as Preview; treat availability and status as time-sensitive.

Current Veo 3.1 Gemini API documentation describes about 8-second outputs at 720p, 1080p, or 4K with natively generated audio, video extension, first-and-last-frame workflows, up to three reference images, and landscape 16:9 or portrait 9:16. Those are Veo-specific documented options, not universal Gemini video limits.

One continuous-action example:

A ceramic mug fills with steaming coffee as morning light streams through a kitchen window. Slow push-in on the mug. Warm, golden tones.

For SCAAL structure, continuity, aspect-ratio pedagogy, and cross-vendor workflow selection without rankings, use the AI Video Prompt Guide. Keep this section focused on Gemini access and the understanding-versus-generation split.

Choose a model by the job and the model card, not by a quality leaderboard. Text and multimodal understanding models, Nano Banana image models, and video models are different tools. Example only: the gemini-3.5-flash model page lists a 1,048,576-token input limit and a 65,536-token output limit. Image models document smaller windows. Never state one universal Gemini context size.

As of Google's June 2026 Interactions API overview, Interactions is generally available and recommended for new work; generateContent remains supported. Feature parity and preview badges change; read the docs for the API path you call.

This guide does not rank Gemini against other vendors. Write portable structure (task, inputs, constraints, verification), then adapt to the surface and model you use that day.

The earlier sections already show weak-to-improved prompts for text, documents, image understanding, multimodal ads, structured fields, Nano Banana, and video. The pattern is the same each time:

• name one success condition
• label inputs
• forbid invention where grounding matters
• specify output structure or schema
• define a visible verification step

If a result fails, change one variable: tighter constraints, a clearer output shape, a better-matched model, or a fresh chat. Do not add five new goals in the same turn.

• Unsupported or invented facts: require “Not stated,” attach source files, enable Search grounding when appropriate, demand citations, and verify outside the model.
• Ignored formatting: restate the output structure, use JSON Schema in the API, or start a new chat if the thread drifted.
• Overloaded prompts: split tasks; keep one TCI-COEV success condition; iterate.
• Conflicting instructions: put durable rules in system instruction, resolve conflicts explicitly, and remove duplicates.
• Weak source grounding: attach docs, use the grounding tool, ask for quotes or URLs, and human-check critical claims.
• Capability mismatch: do not expect chat to guarantee schema validation, a text model to generate images, Veo to be the conversational default when Omni Flash is documented as the default generation path, or Lite image models to handle heavy multi-reference sequential edits. Match task → surface → model card.

Do not ask the model to reveal hidden chain-of-thought as verification. Use the Verification step in TCI-COEV instead.

• Task and success condition are explicit
• Context states what not to invent
• Inputs are attached or pasted, and labeled
• Constraints cover length, tone, and exclusions
• Output structure is specified (or schema configured in the API)
• Surface matches the job (app vs Studio vs API vs Vertex)
• Model capabilities match the job (text vs image gen vs video gen vs understanding)
• Time-sensitive limits (duration, resolution, refs, tokens) checked on the official model or doc page the same day
• Grounding or tools enabled only when needed and available
• Verification step defined (citations, schema validate, spot-check, visual QA)
• One variable chosen to change if the first result fails
• No request for hidden chain-of-thought

Prompt Gemini with a clear task, labeled inputs, constraints, and a verifiable output shape. Choose the right surface and model for text, files, image understanding, Nano Banana generation, video understanding, or video generation.

Treat Omni Flash versus Veo, app versus API, and understanding versus generation as distinct choices. Verify important results yourself, then improve the prompt one change at a time.