Learn one AI task at a time.

Upload a document or spreadsheet, define the evidence boundary, and turn it into a verifiable result.

Turn a broad current question into a scoped, source-backed research report and verify the strongest claims.

Keep related chats, files and reusable instructions together so recurring work does not restart from zero.

Inspect the data first, define the metric, run the analysis, then verify the calculations and assumptions.

Use web search for current facts, open the cited sources, and separate what the source says from ChatGPT’s synthesis.

Turn a future action into a scheduled task, define the cadence and stopping condition, then verify notifications before relying on it.

Set up a focused voice session, give conversational control rules, use interruptions deliberately, and turn the result into text you can verify.

Turn a topic into a guided study session with diagnostic questions, staged explanations, practice and an end-of-session mastery check.

Review what a plugin contains, connect only the app permissions you need, run one bounded task, and verify every external action.

Search your saved ChatGPT content by distinctive words, filter by content type, and distinguish account search from web search.

Use Work for a multi-step task that needs context gathering, planning, analysis, creation and review instead of a single chat answer.

Delegate a bounded browser workflow, sign in only when needed, inspect confirmation requests and take over for sensitive or unsupported steps.

Split independent research questions across specialist subagents, keep writing centralized, then make the main thread reconcile conflicts before producing the final answer.

Create a self-contained document, prototype, diagram or interactive output beside the chat, then edit it in controlled iterations.

Create a project, add durable knowledge, set project instructions and separate recurring work into focused chats.

Frame the question, use Research when available, inspect sources and separate evidence from synthesis.

Choose research sources, edit the research plan, run the report and verify the evidence behind the answer.

Use documents, spreadsheets, photos, video or code as task context, then ask bounded questions and verify the source material.

Turn a repeated prompt pattern into a reusable Gem with stable instructions, optional knowledge and a test loop.

Move a complex deliverable into Canvas, iterate on structure instead of rewriting the whole chat, and export only after a final review.

Import one repository snapshot, map architecture and key symbols, investigate a concrete question, and remember that later GitHub changes do not automatically sync.

Choose exactly which sources Deep Research may use, edit the research plan, inspect source coverage and export a report without blurring private evidence with web claims.

Connect Google Workspace, name the service you want Gemini to use, retrieve only the relevant information and verify sources before creating events or tasks.

Ask a scoped question, let Pro Search gather sources, then refine the answer through follow-ups and citation checks.

Use citations as an audit trail: open them, match them to the exact claim, check date and source quality, then cross-check when necessary.

Use an uploaded document as internal evidence, combine it with web research when needed, and keep the two source types distinguishable.

Move from a visual brief to an image, then iterate by changing one controllable variable at a time.

Use the Create page, write a prompt around visual decisions, generate variations, and refine the strongest direction.

Use a reference image to influence content, composition or colors while keeping the text prompt responsible for the final scene.

Bring an existing image into the current Edit workflow, define what must remain stable, change one visual variable at a time and compare outputs before continuing.

Extract the look you want into a reusable style reference, keep content instructions separate, and test consistency across several different scenes.

Curate a moodboard from representative images, apply it across several unrelated subjects, and keep the board focused on visual language instead of copying one composition.

Create a video from text or references, then refine it through conversational edits instead of restarting every attempt.

Choose the current video model, decide text-to-video or image-to-video, prompt motion clearly and iterate in short shots.

Start from a Midjourney or uploaded image, animate it with low/high motion, then extend or loop only after the base motion works.

Let the input image define appearance and composition, then use the prompt mainly for subject motion, camera motion and temporal progression.

Use a small reference set to lock character identity, generate controlled still variations, then move the strongest frame into an image-to-video workflow.

Storyboard the ad as several short generations, lock product and visual continuity with references, then edit the clips into one coherent sequence instead of asking for a single long generation.

Open a real repository, ask Agent to inspect before editing, make a bounded change, run tests and review the diff.

Start Claude Code inside a repository, let it inspect the project, implement one bounded task, run checks and review every important change.

Put durable repository rules, commands and architecture context into CLAUDE.md so Claude Code starts each session with the right working agreements.

Use allow, ask and deny rules to reduce accidental writes and dangerous commands while keeping a real coding workflow usable.

Split a large coding investigation into specialist subagents with narrow context, tools and deliverables, then integrate the findings in the main session.

Add an MCP server for a specific workflow, inspect exposed tools and permissions, test read-only access, then decide whether write actions are justified.

Turn recurring coding conventions into scoped project rules so Agent gets the right instructions for the files it is changing.

Select the smallest useful files, symbols, docs and terminal evidence so Agent can reason about a task without being distracted by the whole repository.

Treat Agent edits as a reviewable transaction: inspect the diff, run checks, keep Git as the source of truth, and use checkpoints for fast local recovery.

Prepare a repository task for a remote background agent, minimize secrets and ambiguity, then review the resulting branch or diff before merging.

Launch Codex from the correct repository, inspect before editing, set permissions, make one bounded change, run checks and review the result.

Control filesystem, command and network access with the smallest permission profile that still lets the repository task succeed.

Use global and repository-level AGENTS.md files to give Codex durable working agreements, with narrower instructions closer to the code they govern.

Connect a local or remote MCP server, inspect available tools and authentication, test one read operation, and keep external writes under explicit review.

Run deterministic logic at lifecycle events: format after edits, block dangerous commands, inject context or verify completion without relying on Claude to remember.

Turn a repeatable coding workflow into a scheduled, API-triggered or event-driven routine with an explicit scope, approvals and review path.

Use a coordinated multi-agent workflow for large investigations that benefit from parallel hypotheses and independent verification, then keep the final change set bounded.

Make Cursor form hypotheses, add instrumentation, capture runtime evidence, apply one targeted fix and then remove the debugging noise.

Review your whole local diff against the base branch, choose quick or deep review deliberately, fix only confirmed findings and rerun the review.

Configure PR review rules, run Bugbot automatically or on demand, verify findings and use autofix only behind an explicit human merge decision.

Delegate independent review angles to subagents, keep them read-only during discovery, then let the main Codex thread consolidate evidence before any fix.

Run independent Codex chats in separate Git worktrees so experiments, fixes and long-running tasks do not collide with your active checkout.

Choose the correct diff scope, run Codex’s dedicated reviewer, verify prioritized findings and keep the review phase separate from code changes.