Best AI prompts.

Wide establishing shot of [location] at [time of day], [weather] atmosphere, layered foreground/midground/background, cinematic color palette [colors], natural architectural detail, no lettering --ar 16:9

Character design reference for [character]: full-body view, recognizable [costume and silhouette], neutral pose, uniform studio lighting, plain background, clear facial and costume details --ar 2:3

Packaging moodboard for a [product] brand: four coordinated design directions expressed as visual materials, photography, forms and colors; arrange as coherent inspiration board, exclude readable words --ar 3:2

Transform the supplied [image reference] into a [style] illustration while retaining the subject silhouette, key spatial relationships and main color accents. Prioritize consistency with the supplied reference --ar 4:5

Original noir alley scene with wet pavement, dramatic overhead light and a lone silhouette, detailed atmospheric depth, no lettering --ar 16:9

Minimalist poster background featuring layered paper-cut mountain shapes, earthy muted palette, clean negative space for later copy --ar 2:3

Architectural concept of [fictional museum], textured concrete and warm timber, overcast daylight, wide-angle exterior, no text --ar 3:2

Original creature turnaround: [distinctive alien design], front profile and three-quarter views with consistent markings, plain background --ar 16:9

Macro editorial photograph of [botanical specimen] with delicate translucent details, shallow focus and museum-style lighting --ar 4:5

Choose a compatible vector dimension for [embedding model].

Insert [authorized vectors] into Milvus with stable IDs.

Build a Milvus similarity index for [retrieval collection].

Run a vector search for [sample query embedding].

Apply scalar filters to [Milvus search results].

Compare dense and hybrid Milvus search for [test queries].

Check retrieval latency under [sample request load].

Review Milvus collection snapshots before [schema migration].

Audit Milvus for access controls, stale vectors and index drift.

Use MindMac Inline Mode in [approved writing app] to rewrite [owned paragraph] for clarity.

Create a reusable MindMac prompt template for [weekly report formatting] using fixed headings.

Compare two MindMac-supported chat providers on [same non-sensitive question] for answer consistency.

Organize [project-related conversations] into MindMac folders and label them by topic.

Review MindMac conversation search for [previously discussed project decision] and verify its context.

Set a MindMac keyboard shortcut for [approved inline action] and test app-specific conflicts.

Use a locally hosted model endpoint with MindMac for [offline experiment] and note capability limits.

Export [non-sensitive MindMac conversation] in a supported format for archival review.

Audit MindMac provider credentials, Keychain storage, inline app permissions and API usage cost.

Use MindStudio's visual blocks to transform [structured input].

Add a branching step for [complete versus missing form fields].

Compare two supported models on [same internal research task].

Connect a read-only API for [authorized company data].

Create a MindStudio agent with [approved knowledge context].

Test [MindStudio workflow] when an integration times out.

Prepare a human review step before [content publication].

Inspect a failed MindStudio run for [first failing block].

Audit model costs, input privacy and external tool permissions.

Write an MDX quickstart for [approved endpoint] using a real request and response example supplied by the API team.

Document [API authentication] with required headers, scope restrictions and an explicit key-handling warning.

Set up a preview workflow for [documentation change] using a separate branch before publishing.

Check the Mintlify site navigation for [developer journey] and identify missing prerequisite pages.

Prepare an FAQ section based on [real support questions], distinguishing confirmed answers from open items.

Review [AI documentation assistant responses] against source pages for dead links and unsupported examples.

Create a consistent error-reference format for [API status codes], including trigger, meaning and recovery.

Audit [documentation page] for heading hierarchy, accessible examples and broken internal anchors.

Draft a release-notes entry for [verified API change] without inventing deployment dates or compatibility claims.

Cluster [workshop sticky notes] into themes with Miro AI.

Create an editable Miro flowchart from [documented process].

Ask a Miro Sidekick to question [project assumptions].

Generate a Miro workshop board layout for [team kickoff].

Translate [approved board notes] in Miro and check meaning.

Identify next actions from [retrospective notes] with Miro AI.

Compare two Miro process maps for missing decision steps.

Review Sidekick access before using [confidential board].

Audit AI-generated board content for unsupported commitments.

Explain a failing [Python traceback] using the supplied code and propose the smallest testable fix.

Compare two approaches to [SQL query optimization] and state which assumptions need an execution plan.

Research [public policy question] using linked sources and distinguish current regulations from commentary.

Prepare a first-draft summary of [internal notes] while flagging names and decisions not explicitly recorded.

Create a repeatable prompt for transforming [CSV rows] into validated JSON without inventing missing values.

Compare [two model-generated translations] of [technical manual excerpt] for changed numbers and negations.

Structure [meeting agenda] from supplied unresolved issues with realistic discussion time allocations.

Design a creative brief for an original [book cover] and specify text that needs final typesetting.

Audit [Le Chat response] for fabricated citations, unsupported file assumptions and action claims without evidence.

Log metrics and parameters for [MLflow training run].

Compare two MLflow runs using [same validation set].

Log [trained model] with its input signature and dependencies.

Register [approved model version] in MLflow Model Registry.

Inspect MLflow artifacts for [failed training run].

Evaluate [classification model] with an appropriate MLflow evaluator.

Evaluate [LLM responses] with mlflow.genai.evaluate and chosen scorers.

Create a GenAI evaluation dataset from [approved test cases].

Audit MLflow permissions, model lineage and reproducibility.

Review [chosen ModelScope model card] for task capability, download requirements and permitted usage.

Browse ModelScope datasets for [research objective] and verify provenance, license and sensitive-data restrictions.

Use a ModelScope hosted inference demo on [non-sensitive test input] and record observed limitations.

Install a supported ModelScope Python pipeline for [text classification] using pinned package versions.

Compare two ModelScope models on [same test examples] with consistent evaluation criteria.

Explore a ModelScope Studio for [image or text task] while checking its deployment and data sharing rules.

Prepare a local inference plan for [selected model] including memory, framework and model-file requirements.

Review ModelScope fine-tuning documentation for [approved model] and determine which training assets are needed.

Audit a ModelScope workflow for model license, dataset consent, evaluation leakage and reproducibility.

Create a practice backing track by muting [lead guitar stem] from [authorized recording].

Slow [difficult instrumental passage] to [practice tempo] while keeping pitch stable, where supported.

Detect chords in [owned rehearsal track] and verify ambiguous changes by listening to the original.

Shift the key of [authorized song] by [number of semitones] and check vocal-range suitability.

Build a loop around [four-bar phrase] in Moises for repeated instrument practice.

Compare Moises beat detection with [manual tap tempo] to correct a misleading tempo result.

Export [practice mix] at the available audio quality and confirm the output includes only permitted content.

Organize [setlist songs] with clear titles and training notes before a rehearsal session.

Audit [separated vocal and instrumental] for artifacts, timing offsets and licensing limitations.

Customize [Mojo text animation] to emphasize an approved call to action without obscuring key facts.

Build a three-slide Mojo Story series from [owned product photos] and consistent brand colors.

Compare two Mojo templates for [short mobile promotion] based on text readability and pacing.

Use Mojo's brand kit to apply [approved logo and fonts] to [social video] where supported by the plan.

Prepare a square version of [vertical Mojo design] and check cropping on smaller screens.

Add licensed background music from Mojo's library to [approved reel] and confirm rights.

Generate a Mojo 3D animated title for [short video intro] and review the output before using it.

Add auto captions to [approved talking-head video] where the current plan supports them, then correct errors.

Audit Mojo content for license, incorrect claims, contrast, watermark limits and publication permissions.

Generate a lifestyle product scene for [approved packaged item] without changing its printed label or dimensions.

Compare clean white-background and branded-color variants for [product listing photo] using a fixed crop.

Create an outdoor scene for [licensed product image] while preserving realistic perspective and shadows.

Review [Mokker generated image] for floating objects, distorted text, added accessories and inaccurate packaging.

Prepare social and catalogue crops from [approved Mokker output] with safe space around the product.

Specify a seasonal photography theme for [product collection] using consistent lighting and material cues.

Compare [four generated backgrounds] for brand fit, subject contrast and misleading product claims.

Create a product-photography brief using [brand-approved colors], shooting angle and negative visual constraints.

Document source-image permission, editing decisions and export sizes for [final marketing asset].

Ask Monica to extract [specified topics] from [authorized PDF] and verify quoted passages.

Compare two Monica chat models on [same non-sensitive question] while recording factual differences.

Use Monica Search for [research query] and independently inspect the referenced webpages.

Draft [approved customer reply] in Monica using verified details and a chosen professional tone.

Translate [public webpage] with Monica and manually check terminology in the bilingual view.

Summarize [authorized YouTube tutorial] with Monica and verify key moments using timestamps.

Improve clarity in [owned paragraph] using Monica's selected-text writing action without changing its meaning.

Generate an original visual concept in Monica Art for [fictional campaign], then review text artifacts.

Audit Monica's browser extension permissions, uploaded documents, model choice and sensitive-data handling.

Create a step-by-step plan in MonkeyLearn to complete [task] efficiently, including inputs and expected output.

Use MonkeyLearn to turn these inputs into a practical deliverable for [audience]: [inputs]

What is the best workflow in MonkeyLearn for [specific task], and what trade-offs should I consider?

Use MonkeyLearn to improve this existing workflow for [goal] by identifying bottlenecks and concrete next steps: [workflow]

Use MonkeyLearn's Sentiment analysis capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use MonkeyLearn's Keyword extraction capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use MonkeyLearn's Custom text classification models capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use MonkeyLearn's No-code model training interface capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use MonkeyLearn's API for programmatic integration capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Investigate a Monte Carlo volume anomaly on [daily events table] using historical row counts and upstream jobs.

Use Monte Carlo field-level lineage to trace [incorrect KPI column] back to its source and transformations.

Review an automated data quality alert for [production table] and separate observed symptoms from likely causes.

Compare incident frequency for [data domain] across two equal reporting periods using consistent severity categories.

Plan a schema-change alert in Monte Carlo for [critical dataset] and identify affected downstream dashboards.

Use Monte Carlo incident triage to assign ownership and document evidence for [verified data issue].

Evaluate a suggested monitor for [new data product] against known freshness, quality and cost requirements.

Create a runbook for [late-arriving source data] that distinguishes recovery checks from destructive backfills.

Audit a Monte Carlo rollout for data access, monitoring coverage, alert fatigue and traceable remediation.

Time-block [three priority tasks] around [fixed meetings] with buffers and explicit due dates.

Build a weekly planning routine for [project backlog], separating hard deadlines from flexible tasks.

Create a meeting booking link for [available consultation windows] with time zone and buffer settings checked.

Reschedule [uncompleted tasks] into realistic open slots without silently missing their original deadlines.

Plan a focus afternoon using [task estimate list] and preserve a protected lunch break.

Review [recurring calendar events] for double bookings and overly fragmented working hours.

Prepare a plan for [cross-timezone call] that checks daylight saving changes for all participants.

Compare [planned time blocks] to [actual work notes] and identify the largest sources of scheduling drift.

Audit Morgen-connected calendars for unnecessary permissions, exposed event details and duplicate integrations.

Animate [licensed landscape photo] into a short clip while retaining the original foreground and horizon structure.

Compare [two supported video models] in Morph Studio using the same scene description and evaluate motion stability.

Organize [three generated shots] on the Morph Studio canvas in a clear beginning, middle and ending sequence.

Use video style transfer on [authorized source clip] while keeping the subject recognizable and respecting its license.

Create a [vertical social clip] from [approved product story] and check crop, movement and unintended text.

Generate a scene with [fictional character] and [simple action] with explicit costume and camera constraints.

Review a video preview for duplicated limbs, flickering backgrounds and abrupt cuts before re-generating.

Prepare a two-model comparison for [film brief] using frame consistency, prompt adherence and credits consumed.

Export [selected Morph Studio clip] in an available format and review output rights for the chosen plan.

Create [synthetic customer test records] with the MOSTLY AI SDK.

Compare source and synthetic column distributions for [sample data].

Generate mock test data for [application staging environment].

Review synthetic-data quality reports for [trained generator].

Check whether synthetic rows expose [rare original records].

Create relational synthetic samples for [linked test tables].

Use the MOSTLY AI SDK in local mode for [authorized sample].

Inspect [synthetic data] for schema mismatch and invalid values.

Audit synthetic-data privacy controls, lineage and permitted uses.

Create a realistic weekly plan in Motion that protects [number] hours of focus time while meeting these deadlines: [deadlines].

Use Motion to replan my day after this urgent task was added: [task]. Show what should move and why.

Build a project schedule in Motion for [project], including dependencies, milestones, owners, and target dates.

Use Motion to identify which tasks are most at risk of missing their deadlines given this workload: [tasks].

Create a time-blocking plan in Motion for [goal] while keeping existing meetings fixed.

Use Motion's project dependencies to sequence these tasks and flag anything that cannot start yet: [tasks].

Turn this project outline into a Motion plan with actionable tasks, estimated durations, dependencies, and deadlines: [outline].

Use Motion to balance work across a small team for this project: [work items]. Avoid overloading any one person.

Create a recurring planning workflow in Motion for weekly prioritization, automatic rescheduling, and deadline review.

Review calibration and capture-space requirements before a Move.ai markerless motion session.

Prepare a short Move.ai test performance covering [walking and turning] to assess tracking quality.

Compare Move.ai capture of [slow and fast actions] for joint stability and movement fidelity.

Check how occlusion in [multi-camera scene] affects the resulting markerless body animation.

Review [Move.ai motion output] for foot sliding, joint jitter and unrealistic rotations.

Document camera setup, lighting and performer consent for a repeatable Move.ai capture.

Prepare a production handoff of [approved motion sequence] in a verified supported export format.

Compare motion data from [two recorded takes] using consistent review criteria in downstream animation software.

Audit a Move.ai workflow for performer rights, system availability, scene suitability and quality assurance.

Check the status of my existing IT support ticket [ticket ID] in Moveworks and identify any action requested from me.

Search authorized HR policy articles in Moveworks for [leave-policy question], citing the current source document.

Use Moveworks to locate the approved form for [employee equipment request] and identify the required fields.

Ask Moveworks to find the documented process for requesting access to [approved application], without bypassing approvals.

Review Moveworks knowledge-search results for [internal onboarding question] and compare the cited articles for freshness.

Find my open service requests in Moveworks and group them by waiting-on-employee versus waiting-on-support status.

Use Moveworks to troubleshoot [software installation problem] with available knowledge guidance before filing a ticket.

Identify the proper escalation route in Moveworks when [account access issue] cannot be resolved with documented self-service.

Draft a concise service-desk follow-up using the ticket status and accessible supporting articles returned by Moveworks.

Create a MuAPI image-to-video test from [owned image] with a short motion description and bounded duration.

Compare two available MuAPI model endpoints for [same creative task] using equivalent inputs and output criteria.

Implement status polling for an asynchronous MuAPI generation job and handle pending, failed and completed states.

Set a budget and retry cap for [batch image workflow] and log failed-task responses without exposing API secrets.

Check MuAPI's model documentation before choosing [video model], as names and capabilities may change.

Design a multi-step media pipeline that saves [generated image], then submits an approved derivative video request.

Test missing files, oversized input and malformed parameters against a MuAPI integration in a safe environment.

Review [generated media] for brand marks, artifacts, false text and unauthorized likeness before use.

Audit a MuAPI workflow for model licensing, consent, API-key protection, request costs and reproducibility.

Compare two genre and mood combinations for [podcast opening] with identical duration and volume.

Create a looping ambient soundtrack for [licensed game scene] and check whether the loop seam is audible.

Specify a steady tempo and restrained instrumentation for [spoken tutorial] so the soundtrack does not mask speech.

Produce three music variations for [approved campaign] and rank them by pacing and emotional tone.

Choose a longer underscore for [presentation segment] and plan natural transitions between themes.

Review [Mubert-generated track] for abrupt changes, clipping and excessive repetition before use.

Document track license and plan-specific commercial rights before placing [music] in a paid advertisement.

Create a soundtrack handoff for [video editor] including file format, duration, fade plan and source attribution.

Compare [two audio exports] at matched loudness to select the clearest mix for [mobile playback].

Call the documented MultiOn web browse endpoint for [public research question] and inspect the returned content.

Start a MultiOn local browsing session with the Chrome extension enabled for [non-sensitive website navigation].

Design a read-only MultiOn agent task to compare [public feature pages] across two software vendors.

Use MultiOn to retrieve [public event details] from a specified URL and verify dates against the original page.

Build a bounded MultiOn browsing task that navigates [approved documentation site] and summarizes matching articles.

Test MultiOn browser automation against [non-sensitive sample form] without submitting or changing production data.

Compare outputs from two MultiOn runs on [same public page] and identify omissions or inconsistent extracted fields.

Design a MultiOn session failure-handling checklist for [navigation timeout or page layout change].

Audit a MultiOn agent workflow for API-key secrecy, allowed domains, action limits, access consent and output verification.

Create platform-specific captions for [repurposed brand clip] with a clear source link and verified product language.

Identify high-information moments in [recorded webinar] rather than selecting only emotionally charged statements.

Plan a monthly social content calendar using [published videos] with topic diversity and no duplicate clips.

Adapt [existing horizontal video] into 9:16 with speaker-aware reframing and legible embedded graphics.

Compare clip-selection candidates for [customer Q&A] on clarity, completeness and audience relevance.

Create an approved brand kit for [social video batch] with consistent logo size and subtitle treatments.

Prepare a review sheet for [AI-generated subtitles] checking names, quoted figures and missing negations.

Audit [scheduled video posts] for wrong dates, duplicate publishing and mismatched audience targeting.

Compare [two weeks of published clips] using actual retention and engagement metrics without attributing outcomes to AI alone.

Compare two licensed Murf voices for [training lesson] and score pronunciation, naturalness and pacing.

Adjust speaking rate and pauses in [narration] to fit [slide timings] without omitting factual details.

Mark challenging names and technical terms in [voiceover script] for manual pronunciation review.

Create a two-speaker dialogue from [authorized educational script] with consistent voice assignments.

Prepare a short narration for [customer onboarding] while retaining approved brand terminology and dates.

Synchronize [Murf voiceover] with [existing video timeline] and flag sentences that exceed available duration.

Review [generated speech] for misread abbreviations, clipped endings and unwanted emphasis.

Plan an accessible audio version of [approved instruction text] with measured pace and clear navigation.

Check the selected voice, cloning permissions and commercial license before using [Murf recording] in production.

Collect [licensed visual references] for [design project] and search by their visual attributes.

Save [approved meeting insight] as a note and locate it later using a specific concept from the text.

Review [saved bookmarks] for duplicates, expired links and information that should not be retained.

Build a reading shortlist from [saved long articles] and separate urgent research from optional inspiration.

Collect [web clippings about topic] and summarize recurring themes using only the visible saved evidence.

Use a browser save action to archive [authorized page] and verify that the correct source URL was retained.

Find [previously saved visual concept] by describing its colors, materials and composition.

Create a personal knowledge review workflow to revisit [high-value notes] without sharing private material.

Audit [mymind collection] for sensitive credentials, unsupported privacy assumptions and unclear source ownership.

Create a MySpicy AI custom adult fictional character named [name], specifying role, personality, clothing, non-explicit boundaries and opening situation.

Start a MySpicy noir detective scene with [adult fictional character] in [city] and present one actionable clue without controlling my character's reply.

Write a MySpicy lighthearted romance introduction for two consenting adults meeting at [event], with natural dialogue and gradual relationship development.

Develop a MySpicy fictional character who manages [family farm] and has a realistic daily routine, three recurring concerns and distinct speaking habits.

Explore a MySpicy workplace drama with [fictional CEO character], maintaining professional boundaries while negotiating [business conflict].

Continue my MySpicy story using [short recap] and ask the character to preserve the previous scene's names, setting and unresolved questions.

Create a MySpicy fantasy companion who acts as an [archivist] and guides the player through a ruined library without giving away hidden answers.

Compare three MySpicy preset character introductions by originality, clarity of setting and opportunities for a two-way conversation.

Improve my MySpicy custom persona [description] by removing conflicting instructions, clarifying the tone and writing one natural first message.

Connect [authorized SaaS API] to [read-only reporting destination] using securely stored credentials.

Create a branching workflow that routes [urgent ticket] and [routine ticket] to different teams.

Build an n8n AI agent that retrieves [approved internal knowledge] and refuses unsupported account-specific answers.

Define tool permissions for [n8n AI agent] so record updates require explicit approval.

Add a deduplication key to [new order trigger] to prevent repeat processing after retries.

Plan bounded error retries for [unreliable HTTP request] and send an alert when the limit is reached.

Review [workflow execution history] to find the first failing node and reproduce it with test input.

Create a scheduled data export for [approved records] with pagination, timestamps and access limits.

Prepare a regression and rollback checklist for [updated n8n workflow] before activating it.

Create a visual summary of [research explanation] while keeping its stated limitations.

Display [verified quarterly metrics] in a simple infographic with accurate units and dates.

Organize [product comparison criteria] into a decision tree with supporting evidence.

Create a project timeline from [documented phases] showing owners and dependencies.

Visualize the causes of [recorded operational issue] using the evidence in [brief].

Compare two diagram layouts for [complex process] on readability and logical structure.

Explain [approved system architecture] as a visual with components and data flow.

Adapt [existing visual] to a presentation format with readable text and clear headings.

Check [generated diagram] for invented connections, missing sources and contrast problems.

Match changes in a visual sequence to the rhythm of [licensed instrumental music].

Draft a three-shot visual plan for [fictional landscape] with consistent composition.

Generate an alternative view of [approved scene] with matching style and lighting.

Compare motion stability between [two generated clips] using the same source prompt.

Create a short looping background for [artist presentation] with a consistent focal point.

Check a portrait-format animation for safe framing and readable details.

Review a generated animation for flicker, deformed shapes and unwanted labels.

Prepare an editor handoff from [approved sequence] showing cuts and durations.

Check export settings and permitted use for [selected animation] before publication.

Cluster [approved keyword list] in NeuralText and map each cluster to one distinct content page.

Run NeuralText SERP analysis for [target keyword] and identify recurring topics covered by ranking pages.

Create a NeuralText content brief for [topic] specifying reader intent, article angle and required evidence.

Compare two competing keyword clusters in NeuralText to avoid publishing overlapping search-intent pages.

Use NeuralText's AI writing assistant to draft [article section] from a verified editorial brief.

Review a NeuralText content brief against [published article] and list missing useful subtopics without keyword stuffing.

Export a NeuralText keyword research set for [campaign] and group targets by informational versus commercial intent.

Use NeuralText content feedback to improve the structure and readability of [draft article] while preserving facts.

Plan a four-week SEO editorial calendar from NeuralText keyword clusters, with distinct URLs and verification checkpoints.

Add [approved product facts] to neuroflash Brand Hub knowledge so future drafts use consistent terminology.

Draft three neuroflash social ad variations for [verified offer] using the selected brand voice.

Use neuroflash ChatFlash to propose [newsletter introduction] from approved audience and product facts.

Compare neuroflash text generated with and without [brand voice] and identify unsupported product claims.

Use neuroflash PerformanceFlash to pre-test short headlines for [campaign goal] and compare the predicted scores.

Revise [landing-page call to action] in neuroflash based on PerformanceFlash associations, then schedule human review.

Create a neuroflash email draft for [audience segment] using approved tone, benefits and consent-safe language.

Organize reusable neuroflash prompts for [team content workflow] with a clear briefing and approval process.

Audit a neuroflash campaign draft for factual accuracy, brand consistency, audience fit, license constraints and human sign-off.

Audit [existing article] in the Content Editor and list relevant NLP terms that are genuinely missing, not just low-frequency keywords.

Compare the structure of [three ranking pages] and suggest a more useful outline with original examples.

Rewrite [thin product comparison paragraph] for clarity while retaining the exact feature and pricing evidence.

Plan internal links from [five related pages] to [pillar article] with distinctive anchor text.

Group [keyword list] into informational, commercial and navigational intent before planning the next article.

Use the content score as a diagnostic for [draft], then identify recommendations that would introduce keyword stuffing.

Prepare an evidence-led FAQ section for [topic] answering unanswered buyer questions without inventing capabilities.

Check [optimized article] for duplicate headings, unsupported statistics and weak citations before publishing.

Define a 28-day Search Console comparison for [updated page] using query groups and a realistic indexing lag.

Start a Nextpart roleplay in [fantasy kingdom] and introduce a branching decision where my character determines what happens next.

Use Nextpart's multilingual chat to run a short scene in [language], keeping the same adult character personality and explaining unfamiliar words on request.

Generate a Nextpart character portrait matching [fictional description] and compare it with the in-chat character's established appearance.

Try a Nextpart voice interaction with [fictional guide] and check whether speech timing and pronunciation remain comprehensible.

Write a Nextpart companion opening scene set in [space station] that invites collaborative worldbuilding instead of narrating the player's thoughts.

Resume a Nextpart conversation after [previous scene summary], listing key facts and unresolved choices so the story retains continuity.

Design a Nextpart original-character adventure with two competing objectives and ask the AI to present consequences without forcing one ending.

Build a Nextpart historical-fantasy dialogue with [adult fictional character] in [setting], clearly separating invented history from real-world facts.

Compare a Nextpart character's text, voice and generated-image presentation for consistent name, mannerisms and visual description.

Compare two available art models on [same concept] and document differences in composition and artifact rate.

Create a character portrait for [original RPG hero] with a consistent armor motif and neutral background.

Participate in [daily art challenge] with an original prompt, noting any theme and community submission rules.

Explore color palette alternatives for [fantasy book illustration] while keeping the same subject silhouette.

Improve [owned low-resolution generated art] with an upscale and inspect eyes, fine lines and typography.

Use an image reference to propose three distinct lighting treatments for [original illustration].

Generate a square abstract art tile for [music cover] that leaves space for manually added credits.

Review [NightCafe gallery work] for originality and appropriate reuse rights before external publication.

Prepare export QA for [selected print artwork] covering dimensions, color banding and unwanted details.

Turn [onboarding guide] into a week-one checklist for [role], preserving required security steps, working links and escalation contacts.

Summarize [project notes] as completed work, blockers, owner-dependent actions and open risks; link every finding back to a source page.

Using [planning document], draft minimum, balanced and ambitious project scopes with deliverables, trade-offs and missing estimates clearly marked.

Translate [knowledge-base article] into [language] while maintaining product names, headings, tables and links; flag uncertain terminology for human review.

Convert [product launch meeting notes] into a structured database of decisions, owners, deliverables and explicit status values.

Prepare a project retrospective from [completed sprint pages] identifying recurring blockers and supporting examples.

Find conflicting instructions across [three policy documents] and create a source-linked correction queue without choosing a version blindly.

Rewrite [knowledge-base entry] for new employees, keeping actual process links and required approval steps intact.

Build an executive weekly digest from [team project updates] with finished work, upcoming commitments and items lacking recent evidence.

Build Codex entries in Novelcrafter for [characters, places and world rules] and check for contradictory facts.

Outline [three-act story] in Novelcrafter and mark where each character's motivations change.

Draft a scene in Novelcrafter using [approved outline beats] while preserving the planned point of view.

Use a configured AI provider in Novelcrafter for [fictional dialogue revision] and compare it with the original.

Add [fictional character relationship] to the Codex so later scenes retain the established history.

Review [chapter] in Novelcrafter for continuity against the stored world-building reference entries.

Create alternative scene beats for [plot problem] and evaluate pacing and character agency.

Organize [multiple character arcs] in Novelcrafter without merging distinct story timelines.

Audit an AI-assisted Novelcrafter draft for continuity errors, unattributed borrowed text and privacy of unpublished manuscripts.

Build a leakage-safe validation split by Numerai era for [model approach], and explain why random row splitting is inappropriate.

Train a baseline model on Numerai's obfuscated features, then compare its validation correlation against [alternative model].

Generate a Numerai submission file from [trained model] and check row IDs, prediction range, missing values and expected format.

Compare [candidate model A] and [candidate model B] using Numerai's published CORR and MMC evaluation metrics.

Use Numerai benchmark predictions to evaluate whether [new model] adds useful signal beyond a standard baseline.

Create a reproducible Numerai model experiment log covering dataset version, feature selection, hyperparameters and validation eras.

Plan a Numerai tournament submission workflow using the documented API, with credentials stored securely and no unattended staking.

Analyze [model's historical Numerai round scores] and distinguish provisional scores from fully resolved round results.

Review the risks of optional NMR staking for [model], including possible token burns, before deciding whether to stake; do not place a stake.

Write a Triton config.pbtxt for [sample model] with verified input and output tensor dimensions.

Enable Triton dynamic batching for [batchable inference workload] and benchmark throughput versus latency.

Compare Triton CPU and GPU instances for [same supported model] under identical request concurrency.

Create a Triton ensemble of preprocessing, model inference and postprocessing for [defined prediction task].

Use Triton model repository metadata to confirm which versions of [approved model] are currently loaded.

Benchmark Triton request performance with [representative sample traffic] while monitoring resource saturation.

Review Triton instance_group sizing for [GPU deployment] to prevent memory overcommit.

Create a rollback plan for [new model version] with health checks and a verified previous version.

Audit Triton deployment for public endpoint exposure, model-file trust, batching side effects and monitoring.

Select a classification target for [verified lead conversion dataset].

Identify missing values and leakage risks in [training data].

Compare candidate input features for [sales forecasting model].

Design a time-series forecast for [monthly verified revenue].

Evaluate model accuracy on [held-out test data].

Prepare a real-time prediction API use case with permission limits.

Explain [prediction output] with uncertainty and known limitations.

Review data balance before using [model] for decisions.

Document monitoring and retraining triggers for [deployed model].

Adapt [Instagram announcement] for LinkedIn without changing the claim, launch date or intended action.

Build an Ocoya publishing calendar for [campaign week] using approved assets and named reviewers.

Write an on-brand caption for [event photo] with accessible image description and a clear CTA.

Prepare a sequence of educational posts from [verified article], keeping original source attribution.

Generate two graphic layout directions for [seasonal promotion] using our approved palette and logo.

Audit [scheduled posts] for missing media, incorrect time zones and duplicated announcements.

Compare [two caption drafts] on clarity, brand fit and unsupported promises before scheduling.

Summarize available Ocoya post analytics for [campaign] without claiming unproven causal effects.

Check [AI-created social post] for invented offers, broken links and missing publication approval.

Download and run [specified supported open model] with Ollama, then record the exact model tag.

Use the Ollama CLI to inspect installed models before switching the default for [local app].

Create an Ollama Modelfile for [approved system instruction and temperature settings] without embedding secrets.

Send a non-sensitive test request to the Ollama local API and validate the response format.

Compare two Ollama models on [same fixed evaluation prompts] for answer quality, speed and memory use.

Use an Ollama embedding model to vectorize [authorized short text] and verify output dimension.

Connect [approved developer application] to the documented Ollama API endpoint with bounded timeouts.

Test the difference between an Ollama cloud model and a locally hosted model for [non-sensitive task].

Audit an Ollama setup for model licenses, resource limits, local storage, cloud routing and exposed network endpoints.

Draft a welcome email for [new subscribers] using an approved offer and opt-out rules.

Plan an abandoned-checkout workflow with trigger filters, suppression and a clear exit.

Create two factual subject lines and preheaders for [product launch].

Adapt [approved email promotion] to SMS while checking consent and message length.

Design a post-purchase sequence with appropriate delay and verified product details.

Compare [loyal customer segment] to [at-risk segment] using observed order dates.

Verify product recommendations in [email] against real inventory and pricing.

Review [campaign results] with delivered, clicked and converted totals by date.

Test [segment-based automation] for unsubscribed contacts and repeated entry.

Use NoNoise AI on [high-ISO wildlife photo] and check detail preservation.

Apply Tack Sharp AI to [slightly blurred photo] and inspect halos.

Use a subject mask to brighten [portrait] without changing its background.

Combine subject and sky masks using ON1 Photo RAW Mask Layers.

Enlarge [owned photo] with Resize AI and compare Standard and Highest Quality output.

Try Sky Swap AI on [owned landscape] and assess horizon edges.

Build a nondestructive RAW-editing workflow for [travel photo collection].

Use ON1 keyword tools to organize [owned photo library] and verify metadata.

Export [edited photo] for [print or web] and inspect resolution and color.

Run a Python ONNX Runtime inference session on [sample tensor] and compare results against a baseline.

Select the correct ONNX Runtime Execution Provider for [CPU, CUDA or supported accelerator] and confirm availability.

Benchmark ONNX Runtime inference latency for [model] using warm-up requests and repeated fixed inputs.

Investigate a shape mismatch error in [ONNX model] by checking declared tensor names and dimensions.

Apply a supported ONNX Runtime graph optimization setting to [test model] and compare output accuracy.

Compare ONNX Runtime CPU and GPU execution on [same model and dataset] for latency and memory.

Prepare a deployment plan using ONNX Runtime Web for [approved browser inference feature].

Check compatibility and operator support before deploying [exported PyTorch model] in ONNX Runtime.

Audit an ONNX Runtime inference pipeline for unsafe model files, numerical drift, input validation and hardware fallback.

Use Open WebUI to build a RAG workflow over these internal documents: [document set]. Define ingestion, retrieval, and answer-citation behavior.

Design an Open WebUI deployment for a team that requires SSO, role-based access, and private model access.

Create an Open WebUI tool workflow that lets users call [internal API/tool] from chat while limiting permissions appropriately.

Use Open WebUI's code execution capability to analyze this dataset safely: [dataset/task]. Describe the expected input and output boundaries.

Design a plugin for Open WebUI that supports [workflow], including the trigger, inputs, processing steps, and returned result.

Create a model-routing policy in Open WebUI for [team], balancing privacy, latency, and task quality.

Use Open WebUI to create a shared knowledge assistant for [department] with retrieval over approved internal sources only.

Plan an Open WebUI authentication setup using [OIDC/LDAP/SSO] and role-based permissions for [user groups].

Create a test checklist for an Open WebUI deployment covering model access, RAG quality, tool permissions, identity controls, and auditability.

Compare Coder's automatic routing with a single large-model baseline on [three real issues], recording accepted fixes, time and actual model spend.

Configure OpenAgents Coder to leave [production deployment] behind a human approval gate while allowing safe read-only repository analysis.

Trace a Coder session fixing [unit test regression] and identify which model handled exploration versus the final patch.

Use Coder with [Claude Code or OpenCode agent] to investigate [repository bug] and verify that switching model routes preserves task context.

Review an OpenAgents Coder routing decision for [complex refactor] to check whether the selected model had sufficient code context.

Prepare a benchmark for [Rust project] using OpenAgents Coder that measures passing tests and regression safety rather than only token costs.

Set explicit Coder approval boundaries for [merge, secret access, payment and DNS change] before allowing an agent to operate tools.

Inspect the Coder activity trace for [task] to reconstruct what the agent read, ran and modified during the session.

Document an OpenAgents Coder evaluation for [team] with supported agent harnesses, local setup prerequisites, data routing and rollback.

Use Codex to reproduce [bug steps] in [project], identify the root cause and implement a minimal fix together with a regression test.

Review [pull request] with Codex for API compatibility, unsafe logging and missing edge-case tests; report confirmed defects with file and line references.

Create a Codex implementation plan for [feature] that preserves current interfaces, identifies dependencies and keeps production deployments outside the requested scope.

Refactor [legacy module] with Codex while retaining function signatures; run relevant tests and summarize the observed diff rather than claiming unrun checks.

Build a Codex-driven test harness for [webhook handler] using sandbox fixtures, signature verification and idempotent retry scenarios without calling production services.

Investigate [CI build failure] through Codex by checking toolchain versions, dependencies and failing logs before proposing a narrow patch.

Use Codex Code Review and repository AGENTS.md rules to check [PR] for protected response fields or sensitive-data boundaries, separating violations from style suggestions.

Prepare a staged Codex migration of [old library] to [new library] with compatibility tests, a rollback plan and an explicit approval gate before changing dependencies.

Have Codex document a local setup for [application] using actual manifest files and safe environment-variable names, then verify each example command.

Create three visual styles for [licensed campaign] while keeping the message and palette constant.

Use [owned reference image] for a new composition without changing real product labels.

Refine [portrait composition] while preserving the expression and approved costume.

Replace the background in [authorized product photo] without distorting the actual item.

Inpaint [specific flaw] in [owned artwork] without changing neighboring elements.

Extend [licensed landscape] beyond its original frame with matching horizon and shadows.

Compare [four OpenArt outputs] for composition, anatomical artifacts and brief adherence.

Plan a consistent fictional character series with shared clothing and lighting cues.

Review [selected image] for rights, unwanted text and export quality before publication.

Configure OpenClaw Easy with a local Ollama model for [non-sensitive chat task] before enabling cloud providers.

Connect a dedicated low-privilege test channel in OpenClaw Easy and confirm only intended messages reach the agent.

Compare local and cloud-model responses on [same harmless task] while recording which data leaves the device.

Prepare an OpenClaw Easy agent skill for [read-only documentation search] with explicit forbidden actions.

Configure a scheduled OpenClaw Easy reminder for [routine personal task] and verify timezone and notification destination.

Test OpenClaw Easy handling of disconnected messaging accounts and expired credentials without sending duplicate replies.

Review a community OpenClaw skill's requested permissions, source code and update provenance before installation.

Audit OpenClaw Easy settings for unrestricted shell commands, third-party skills, exposed API keys and unwanted automations.

Document a safe OpenClaw Easy rollback plan covering channel disconnection, local data cleanup and credential revocation.

Outline a private OpenDAN setup for [offline note-organizing task], checking available app modules, storage location and the actual supported runtime.

Create a test plan for an OpenDAN task automation that classifies [non-sensitive text files] and requests approval before moving or rewriting anything.

Compare outputs from [local model A] and [local model B] in an OpenDAN-supported application on [summarization task], recording accuracy and resource use.

Design an OpenDAN AI-app prototype that retrieves [approved local knowledge] and answers with references, treating retrieval support as a capability to verify.

Build a deployment checklist for OpenDAN on [test computer] with local model requirements, network permissions and an uninstall/rollback path.

Prepare a privacy review of an OpenDAN application for [personal notes], identifying whether inputs remain local or go to third-party endpoints.

Draft acceptance tests for an OpenDAN multi-model task involving [document tagging] so repeated runs do not silently overwrite labels.

Plan a small OpenDAN AI-app-store evaluation of [two productivity apps], checking origin, updates, access permissions and data-export options.

Audit an OpenDAN task result from [test run] for provenance, unintended external calls and any changes that occurred without human approval.

Compare major guideline recommendations about [diagnostic screening topic] in [jurisdiction], citing the relevant guideline versions and describing where they disagree.

Summarize randomized trials of [intervention] for [condition], recording population, comparator, outcomes, harms and certainty rather than claiming a universal winner.

For this [clinical scenario with no identifying details], identify evidence that may inform a clinician's differential diagnosis and clearly note missing patient context.

Check whether [commonly repeated medical claim] is supported by systematic reviews or high-quality trials; distinguish robust findings from preliminary signals.

Produce an evidence table on [treatment class] that separates reported benefits, adverse events, contraindications and study limitations with citations.

Find published studies about [rare-condition question] and state which conclusions rely on small samples, case reports or extrapolated data.

Review the source trail for this OpenEvidence answer [answer text], checking whether quotations, populations and outcome numbers match the cited papers.

Summarize changes between [older guideline year] and [newer guideline year] for [clinical topic], highlighting recommendations that require local practice verification.

Prepare a clinician-facing briefing on [new research finding], with the study design, primary result, important caveats and questions for specialist judgment.

Map [approved customer events] into Optimove unified profiles and check missing identifiers.

Design an Optimove post-purchase journey with suppression for customers who opted out.

Compare [two customer segments] using purchase recency and recorded engagement.

Configure a next-best-action test for [retention campaign] and document its decision rules.

Plan an Optimove email and push journey with permitted channels and contact frequency caps.

Set up an Optimove control-group experiment for [campaign] and define its success metric.

Validate freshness and duplication in Optimove event data for [cart-abandonment scenario].

Review [customer journey] in Optimove for conflicting messages and exclusion rules.

Compare campaign performance by Optimove audience while accounting for attribution limits.

Use Optuna trial.suggest_float to sample [learning rate] on a log scale within approved bounds.

Define an Optuna search space for [model depth, regularization and optimizer] with clear parameter constraints.

Set an Optuna trial budget for [training experiment] and record objective direction and stopping conditions.

Use an Optuna pruner with intermediate metrics on [training task] and check that trials report valid steps.

Compare two Optuna samplers for [same optimization task] while keeping trial count and validation data fixed.

Persist an Optuna study to [approved storage] and demonstrate safe resumption after interruption.

Visualize Optuna parameter importance for [completed study] and avoid treating correlations as causation.

Review best-trial hyperparameters against a held-out test set without tuning to the test result.

Audit an Optuna experiment for data leakage, random-seed drift, exhausted compute and misleading trial comparisons.

Automatically reframe [landscape interview] into 9:16 while keeping the active speaker and visual aids visible.

Generate captions for [short clip] and manually review proper nouns, amounts and speaker changes.

Compare clip candidates from [webinar] by audience usefulness rather than treating a virality score as a guarantee.

Create a caption style guide for [brand short-form videos] with safe margins and controlled emphasis.

Prepare a single-topic edit from [multi-topic interview] with a clear setup, one insight and a factual ending.

Plan export versions for [TikTok, Shorts and Reels] considering crop and caption interface differences.

Audit [automatically selected highlights] for misleading omissions and sentence fragments.

Align [OpusClip brand kit] with approved fonts, colors and product terminology.

Build a human approval process for [batch of AI shorts] covering context, music rights, captions and scheduled destinations.

Compare Oracle-supported enterprise language model options for [summarization workload] using accuracy, cost, latency and data-residency constraints.

Outline a secure Oracle Cloud generative-AI workflow that classifies [support ticket] and routes it to an approved system without changing records automatically.

Create an evaluation set for an Oracle-hosted retrieval assistant on [technical documentation] covering factual answers, missing evidence and hallucination cases.

Plan an Oracle AI application that summarizes [contract documents] with a source-quotation audit and explicit reviewer approval for legal conclusions.

Design identity and access controls for [OCI agent service] so it sees only approved datasets and keeps confidential values out of logs.

Compare managed generative-AI capabilities and an embedded Oracle application AI workflow for [business need], outlining integration trade-offs.

Develop a model-routing experiment in OCI for [high-volume classification] with cost, performance and consistent result-quality measurements.

Specify monitoring for an Oracle generative-AI workflow that captures response time, source retrieval failures, safety escalations and model-version changes.

Prepare an Oracle enterprise-AI rollout plan for [team] including sandbox verification, human approval points, operational dashboards and rollback.

Capture decisions about [project launch date] with the exact spoken context and timestamp.

Train a custom vocabulary list for [technical product names] and spot-check transcription accuracy.

Summarize [one-hour interview] with themes, notable direct quotes and clearly labeled uncertainty.

Find previous discussion of [budget approval] in searchable Otter transcripts and reconcile any conflicting accounts.

Prepare an action register from [weekly sync] with named owners only when a person explicitly volunteered.

Compare [Otter AI meeting summary] with [full transcript] for omitted qualifications and incorrect numbers.

Create a meeting follow-up email with source-backed decisions and an accessible link to the original notes.

Plan recording consent and sharing permissions for [multinational team] before enabling a meeting assistant.

Review automatic slide captures and transcript alignment for [presentation recording] before distributing notes.

Draft a concise reply to this message that confirms [decision] and asks for [missing information].

Prioritize the messages I should handle first and explain why.

Create an Outlook rule for messages matching these conditions: [conditions].

Review my inbox context and identify the follow-ups I am most likely to miss.

Review [long email conversation] and draft a reply that addresses all outstanding questions while citing exact commitments.

Find messages about [project decision] and produce a dated timeline, distinguishing proposal from approval.

Prepare an inbox triage plan for [busy week] that separates urgent deadlines, delegated items and newsletter noise.

Suggest safe Outlook rule criteria for [vendor notifications], including exclusions for actual customer replies.

Create a follow-up checklist from [sent project emails], flagging promised deliverables that have no confirmed response.

Draft a first-touch email based only on [approved value proposition] and CRM history.

Set a follow-up task for [prospect] after a documented phone conversation.

Review [two Outreach sequences] for duplicated messages and mismatched time zones.

Create a call preparation brief from [authorized opportunity notes] and recent interactions.

Compare reply and meeting rates for [campaigns] using consistent date ranges.

Flag accounts with stalled activity and assign a human-approved next step.

Audit CRM synchronization for duplicate contacts and stale opportunity stages.

Prepare an A/B test of [email opening] while holding audience and offer stable.

Check generated personalization for unsupported prospect assumptions before sending.

Build a Pabbly Connect two-step automation for [synthetic signup event], mapping required fields and validating missing values before the next action.

Configure a Pabbly Connect webhook trigger for [test JSON payload] and verify request authenticity, field names and duplicate-event handling.

Design a Pabbly Connect workflow to send [approved internal notification] when [authorized CRM record] meets a documented condition.

Use Pabbly Connect's filter or conditional routing for [synthetic lead category], checking that only eligible records reach the intended action.

Map data between [two connected permitted apps] in Pabbly Connect and check that dates, arrays and empty fields are handled correctly.

Test a Pabbly Connect multi-step workflow for [authorized order event] using sandbox/test data before enabling any customer-facing action.

Compare a Pabbly Connect automation run's output with [expected synthetic input-output examples] and document failures for manual review.

Prepare a Pabbly Connect workflow audit for [approved app connection], covering scopes, secrets, error recovery and repeated notifications.

Document [Pabbly Connect automation] with trigger, action order, test payload, data minimization, owner and a safe disable/rollback procedure.

Edit [manuscript introduction] for scholarly tone without changing citations.

Shorten [methods section] without losing reproducibility details.

Improve transitions in [literature review] without inventing evidence.

Check [journal manuscript] for inconsistent technical terminology.

Clarify [results paragraph] while distinguishing observation from inference.

Review [discussion] for causal claims beyond the study design.

Turn [reviewer feedback] into a section-by-section revision checklist.

Proofread [table captions] for units, variables and sample sizes.

Verify [Paperpal suggestions] do not alter figures or source attribution.

Organize [literature review on topic] in Paperpile using topic folders and labels for study design.

Find and merge duplicate records in Paperpile after importing [reference library] and check the merged metadata.

Use Paperpile to locate PDFs for [selected citations] and mark which full texts still require legitimate access.

Highlight and annotate [owned or licensed research PDF] in Paperpile, then export a summary of key findings.

Insert citations from Paperpile into [Google Docs manuscript] and generate a bibliography in [chosen journal style].

Use the Paperpile Word integration to update references in [draft document] without manually retyping citations.

Share an approved Paperpile folder with [research team] and review permissions before inviting collaborators.

Export [selected Paperpile references] as BibTeX or RIS for transfer to [another citation manager].

Audit [Paperpile research collection] for incomplete DOI metadata, duplicate studies and misattributed sources before submission.

Create a Prowork accounts-receivable aging report from [approved invoice and payment data], recording the aging rules and a trace to every source row.

Build a Prowork purchase-order matching Flow from [PO data and supplier invoices] that flags quantity or price discrepancies for manual approval.

Ask Prowork to explain how [existing Flow] calculates [metric], showing its source steps, filters and transformations before changing any logic.

Validate a Prowork inventory reconciliation for [two warehouses] using real sample rows, duplicate-SKU cases and explicit treatment of missing items.

Prepare a Prowork operational exception dashboard for [late orders], showing which event timestamps and SLA rules produced each flagged record.

Convert [documented manual finance procedure] into a Prowork Flow with approved transformations and an inspectable branch for unusual transactions.

Design a Prowork Flow triggered by [new email attachment] that validates file structure, runs a read-only analysis and notifies the owner of errors.

Review a proposed Prowork Flow edit against [prior approved version], checking downstream reports, permission changes and rollback before deployment.

Create a Prowork month-end reporting checklist covering data lineage, reconciliation samples, human sign-off and a managed scheduled run.

Use ParagraphAI Reply to respond to [pasted non-sensitive customer inquiry] while addressing each question explicitly.

Apply ParagraphAI Fix to [owned paragraph] to correct spelling and grammar without changing factual meaning.

Use ParagraphAI Edit to make [message] friendlier while retaining commitments, dates and specific terminology.

Compare ParagraphAI formal and casual editing styles on [approved announcement] and choose the version suited to [audience].

Shorten [draft update] with ParagraphAI to fit [word limit] without dropping essential facts or caveats.

Build a reusable ParagraphAI template for [weekly status report] with sections for progress, blockers and decisions.

Translate [approved non-sensitive message] into [target supported language] with ParagraphAI and review local phrasing.

Draft a ParagraphAI response to [professional networking message] that acknowledges the sender without inventing credentials.

Use ParagraphAI's writing history to revisit [previously approved draft] and compare revisions for changed claims.

Set up Parsemania capture from [Google Drive bills folder] and flag duplicate invoice numbers or unreadable attachments before sending anything to accounting.

Match [supplier invoice] against [purchase order] in Parsemania, comparing vendor, amounts and line items and holding discrepancies for human approval.

Define a Parsemania exception rule for [invoice exceeding PO tolerance], preserving evidence and blocking ledger export until finance review.

Create a Parsemania ingestion workflow for [scanned receipt photo] that extracts tax, currency and vendor details while marking low-confidence fields.

Prepare a Parsemania export mapping from approved bills to [QuickBooks or Xero], specifying tax-code rules and test-only verification first.

Investigate why Parsemania matched [invoice] to the wrong PO by reviewing supplier IDs, line descriptions and the match evidence.

Design a Parsemania month-end queue showing invoices awaiting a PO, flagged duplicates, approved items and failed accounting exports.

Create a Parsemania audit-trail checklist for [AP workflow] showing original document, extracted fields, matching decision and reviewer approval.

Run a Parsemania predeployment test with [ten synthetic invoices] covering multiple currencies, partial POs, duplicate submissions and invalid vendor information.

Create a PatternedAI geometric tile with [three shapes], precise edge continuity and [specified repeat density].

Upload [owned fabric motif] into PatternedAI and convert it to a seamless repeat without visibly cut edges.

Recolor [approved seamless design] in PatternedAI into three colorways matching [supplied brand palette].

Use PatternedAI to correct visible seams in [owned repeating pattern] and inspect all four tile boundaries.

Make a coordinated pattern collection in PatternedAI from [hero floral], [small coordinate] and [subtle stripe].

Preview [approved seamless pattern] on a PatternedAI garment or home textile mockup and adjust motif scale.

Upscale [approved surface pattern] in PatternedAI for [print dimension] and check repeat continuity at production size.

Prepare [owned seamless design] for textile printing with 300-DPI PNG export, checking plan support and resolution.

Compare PNG versus available vector exports of [approved pattern] and document any plan-specific limits or color separation needs.

Ask Paxton to locate [relevant case law] on [pleading standard] and compare the quoted holding with the primary opinion.

Upload [authorized sample case file] to Paxton and summarize the chronology with page-level references and unresolved facts.

Draft an outline for [motion type] in Paxton using verified matter facts, then route all citations and arguments to licensed counsel for review.

Compare [two uploaded authorized contracts] in Paxton and identify differences in renewal, termination and indemnity clauses.

Use Paxton to prepare a draft deposition question outline based only on [reviewed witness materials], flagging unsupported assumptions.

Build a legal research memo in Paxton for [jurisdiction-specific issue], separating binding precedent from persuasive sources.

Review Paxton's legal research citations for [proposed brief] by opening each primary-source decision and checking subsequent treatment.

Analyze [authorized discovery documents] in Paxton to find potentially conflicting dates, with citations back to the record.

Audit a Paxton-assisted matter for confidentiality, privilege, jurisdiction limits, stale authority and mandatory lawyer sign-off.

Find [safety requirement] in [uploaded manual] and cite its page.

Compare [two reports] using consistent metrics, units and periods.

Extract [fees and dates] from [PDF statement] and flag unreadable rows.

Answer [policy question] only from [uploaded document] with citations.

Explain [dense paragraph] clearly without changing its meaning.

Make a checklist from [procedural PDF] with page references.

Find inconsistent definitions in [two uploaded specifications].

Verify [AI summary] against the PDF for missing limitations.

List open questions when the provided PDFs lack sufficient evidence.

Use PearAI to trace [reported runtime error] from its stack trace to relevant functions without modifying production.

Ask PearAI's coding agent to draft unit tests for [existing function] and review test assumptions before running.

Plan a PearAI refactor of [small component] that keeps the public API and behavior unchanged.

Use PearAI to propose a patch for [reproducible bug] and inspect the diff before applying it.

Review PearAI-generated changes to [configuration file] for credentials, destructive commands and dependency upgrades.

Compare [two code approaches] in PearAI for readability, type safety and expected performance.

Ask PearAI to identify missing error handling in [API client module] and suggest bounded retries and tests.

Use PearAI's available model selection to evaluate [same non-sensitive coding task] and compare resulting changes.

Prepare a PearAI development handoff for [feature request] with changed files, test commands, unresolved risks and manual review.

Test two lighting styles on [approved package image].

Place [original product] in a realistic home scene.

Prepare a vertical crop with full product visibility.

Compare three backdrops for contrast and brand fit.

Remove distractions from [owned photo] and review edges.

Create a seasonal background without added product accessories.

Check image outputs for distorted labels and colors.

Keep a consistent set of backdrops across [five SKUs].

Verify source permissions and image quality before publishing.

Outline a 15-second ad video from [verified offer] with a clear opening.

Compare four ad concepts for [buyer segment] against one campaign brief.

Resize [approved creative] for square and vertical placements with safe margins.

Design an A/B test for two hooks using the same audience and landing page.

Check generated ad copy against actual pricing and specifications.

Create a brief based on [owned past winning ads] without copying competitors.

Treat creative performance predictions as estimates requiring live testing.

Review generated visuals for false logos and changed packaging.

Prepare a compliance and human-approval checklist before ad publication.

Build a shared button component with focus and disabled states.

Define reusable color and spacing tokens for [brand].

Create a clickable prototype for [user journey].

Use CSS Grid for a responsive [product card] layout.

Compare navigation designs for keyboard accessibility.

Prepare developer handoff notes with CSS specifications.

Identify redundant styles in the shared design library.

Review prototype error, loading and empty states.

Check contrast, text scaling and mobile touch targets.

Use Pepper's Agent Atlas findings to identify [three content gaps] and separate verified omissions from recommendations that need a human strategist.

Build a Pepper Search Everywhere Optimization brief for [software category] spanning owned pages, AI engines and relevant third-party platforms.

Compare [brand] visibility before and after a Pepper content update using an unchanged set of tracked prompts and clearly dated evidence.

Prepare a Pepper content campaign proposal for [product] that includes original subject-matter input, editorial review and precise conversion goals.

Review Pepper's AI-search recommendation for [landing page] against first-party product facts and avoid unsupported claims about rankings or citations.

Create a Pepper digital-PR research queue for [industry topic] with credible sources, legitimate outreach targets and a disclosure policy.

Use Pepper's cross-surface audit to identify conflicting [brand descriptions] across directories and recommend owner-approved consistency updates.

Design a monthly Pepper growth report with Search Console data, AI-answer mentions, qualified leads and explicitly stated attribution limits.

Prioritize Pepper content and GEO experiments for [next quarter] by business relevance, original evidence and measurable review dates.

Research whether [claim] is supported. Prioritize primary studies, official filings and firsthand statements; give evidence for and against, publication dates, and what remains uncertain.

Build a reading list on [technical topic] for [experience level]: five authoritative sources published since [year], each with URL, date, key contribution and one limitation.

Find the original source behind this statistic: [statistic]. Trace it to the originating dataset or study rather than repeating secondary articles; report definition, sample, date and cautions.

Provide a timeline of [industry event] from [date range], with five dated milestones linked to original announcements or documents. Distinguish what happened from later analysis.

Research [vendor feature claim] by locating the vendor release note and comparing it with current product documentation.

Create a source-audited buyer brief for [two AI software products] separating trial availability, pricing and geographic restrictions.

Compare [conflicting news accounts] of [event], tracing each disputed point to a dated primary record.

Explain [technical standard] using official specifications first and clearly distinguish implementation guidance from normative rules.

Check whether [research topic] has an updated systematic review and summarize inclusion limits without treating citations as proof.

Compare Persado-generated messaging variants for [two consenting customer segments] without assuming either will outperform.

Configure a Persado campaign briefing for [retention objective] with approved brand vocabulary and prohibited claims.

Generate emotion-informed SMS variations in Persado for [verified promotion] and check consent and channel limits.

Design a Persado language experiment for [campaign] with a control, outcome metric and predeclared evaluation period.

Review Persado copy suggestions for [regulated offer] against the approved legal and compliance checklist before release.

Use Persado's reporting to identify which tested wording variants performed better for [defined audience and metric].

Plan a Persado web-message personalization test for [eligible visitor segment] without using sensitive traits.

Compare Persado performance of [approved creative variants] across email and web while accounting for differences in attribution.

Audit a Persado campaign for brand consistency, permissions, approval trail, experiment integrity and misleading claims.

Build an Agno multi-agent team for [workflow], assigning responsibilities and defining how agents hand work to one another.

Create an Agno workflow that persists state across steps for [process] and can resume safely after an interruption.

Use Agno to connect an agent to these tools or MCP servers: [tools]. Define which actions require explicit approval.

Design an AgentOS deployment for [use case] with sessions, tracing, evaluations, and human approval checkpoints.

Use Agno to compare two model providers for the same agent task and define an evaluation rubric for quality, latency, and reliability.

Create a structured-output Agno agent that converts [input] into this schema: [schema]. Include validation and failure handling.

Build an Agno research team that gathers evidence, checks conflicting claims, and produces a source-aware summary for [topic].

Use Agno to add observability to an existing agent workflow, including traces, session history, evaluation signals, and failure diagnostics.

Design a private-cloud Agno architecture for [organization], showing where models, tools, AgentOS, and the control plane fit.

Check [handwritten fraction problem] was recognized correctly before solving.

Compare the worked steps for [two methods of solving a quadratic] and identify where they differ.

Explain why [chosen sign change] is valid in a step-by-step solution.

Use the graph of [linear equation] to connect slope and intercept to its formula.

Check [student solution] against Photomath steps to find the first arithmetic error.

Practice [three percentage word problems] and describe how each expression was set up.

Explain [system of two equations] with substitution and verify the result in both originals.

Distinguish a transcription error from a mathematical error in [camera-scanned worksheet].

Create a revision note from [worked problem] highlighting the rule to use on similar exercises.

Create a realistic studio background for [approved handbag photo] without changing the product color or geometry.

Prepare a batch of [50 ecommerce thumbnails] using consistent margins and native product proportions.

Compare [background variations] for [catalogue item] while ensuring the images do not imply false product accessories.

Erase [unwanted prop] from [owned product photograph] without removing the item’s genuine features.

Design a marketplace-ready hero image for [SKU] that respects the platform’s background and dimension rules.

QA [batch background removals] for transparent edge halos, missing fine details and accidental item deletion.

Create seasonal product-photo scenes for [existing listing], maintaining accurate packaging and logos.

Prepare a high-resolution export checklist for [Photoroom assets] including crop, alpha channel and compression.

Design an API-assisted image-processing workflow for [authorized catalogue], logging per-image failures and review exceptions.

Draft five Jacquard email subject and preheader variants for [offer] targeting [audience], each with a distinct angle and no unsupported performance promise.

Generate compliant Jacquard push-notification variations for [customer journey moment], with [character limit] and [mandatory wording].

Create an email, push and in-app message family for [campaign] in Jacquard, keeping the offer and legal disclosure consistent across channels.

Use Jacquard's brand checks to review [copy draft] against [brand guide] and identify terminology, capitalization and compliance concerns.

Create a human-review workflow for a Jacquard campaign: draft variants, check claims, approve stakeholders and record the launch decision.

Outline a Jacquard creative test for [campaign objective], defining a control, variant hypotheses, measurement window and guardrails without predicting guaranteed lift.

Personalize [core value proposition] for [three customer segments] in Jacquard without changing price, eligibility, claims or legal requirements.

Review the signals available from [campaign report] and propose five Jacquard messaging hypotheses to validate with further experiments.

Prepare a Jacquard-to-[supported marketing platform] handoff checklist covering creative fields, audience mapping, preview tests, approvals and rollback.

Reflect back the main concerns in [journal excerpt] without assuming an underlying diagnosis.

Practice a respectful conversation with [colleague] about [specific issue], including possible misunderstandings.

Create a brief morning planning conversation around [three priorities] and realistic energy levels.

Help me compare options for [personal project] by listing trade-offs I have explicitly mentioned.

Act as a listening partner while I describe [stressful event], and ask what kind of response I need.

Prepare a gentle voice-conversation practice for [foreign language greeting] with short pauses.

Turn [long reflection] into an actionable question and a small next step chosen by me.

Check whether your summary of [previous chat] includes assumptions I never provided and invite corrections.

Create a privacy reminder before discussing [sensitive personal information] in an AI conversation.

Create a vertical event-poster layout from [approved headline and photo] with readable typography.

Generate an original illustrated mascot for [fictional coffee shop] with three consistent pose ideas.

Use generative fill on [owned workspace photo] to add [plant] with realistic perspective and shadows.

Prepare a social-media collage from [four licensed photos] with consistent cropping and contrast.

Compare alternative color treatments of [campaign image] while protecting brand colors and product accuracy.

Remove [background] from [hair-detail portrait] and check fine edges at full resolution.

Create reusable branded templates for [five social posts] with approved fonts and safe logo placement.

Inspect [AI-enhanced small photo] for over-sharpened faces, invented lettering and other artifacts.

Prepare export versions of [Picsart artwork] for square, story and banner placements without cutting off the main subject.

Summarize [recorded webinar] into three short clips without removing qualifiers from the speaker’s claims.

Match stock imagery to [educational script] without portraying unrelated footage as a real product demo.

Generate captions for [video interview] and verify names, amounts and omitted negative statements.

Create a narrated explainer from [approved text] with pacing appropriate for technical vocabulary.

Prepare a consistent brand layout across [five short videos] with logo, font and caption-safe margins.

Compare a text-to-video draft with [source document] to identify unsupported details and missing context.

Convert [long horizontal presentation] into [vertical social cut] with protected charts and readable titles.

Build an editing checklist for [stock media, narration and subtitles] before publishing Pictory content.

Plan a multilingual version of [short training video], marking terminology requiring human translation review.

Find a saved [API example] by describing its purpose.

Compare two stored functions for error handling.

Summarize a saved documentation example with its source link.

Share reviewed code without credentials or private data.

Retrieve a previous [helper function] and check API compatibility.

Group related snippets and flag duplicate versions.

Prepare boundary tests for [saved parser function].

Review generated suggestions for deprecated code calls.

Audit stored developer snippets for exposed secrets.

Generate a short fantasy-video concept from [original written prompt] with a consistent subject and lighting.

Create a playful animation of [fictional object] transforming into [second fictional object] without visible text artifacts.

Compare two [image-to-video generations] for geometry changes, identity drift and frame flicker.

Design a lip-sync test with [authorized voice] and [consented portrait], checking consonant timing.

Plan sound effects for [original animated scene], aligning audio cues with actual movement.

Create three stylistic treatments of [licensed footage] while preserving the order and meaning of its events.

Generate a looping [abstract liquid pattern] for a mobile hero without abrupt first/last frame changes.

QA [AI video clip] for distorted hands, unexpected background elements and missing intended action.

Export [selected Pika clip] with correct aspect ratio, playback speed and disclosure where synthetic content might confuse viewers.

Workflow: Ingest [sample document collection] with deterministic IDs, chunk metadata (source, timestamp, tenant), and embeddings. Upsert in batches; verify duplicate handling and query a known example.

Workflow: For [RAG question], generate an embedding using the same model used at indexing, query top-k with a tenant metadata filter, and inspect retrieved sources before asking an LLM to answer with citations.

Workflow: Evaluate semantic vs hybrid retrieval on [20 labeled questions]. Record recall@k, precision, latency and failure examples; adjust lexical/vector balance only after baseline measurement.

Workflow: Design namespace and metadata filters for [multi-tenant app], test that tenant A cannot retrieve tenant B documents, and verify deletion/upsert behavior with audit logs.

Design a vector index update for [new embedding model] with a migration namespace and compatibility checks.

Trace why [specific known passage] is missing from retrieval by checking chunking, embedding and metadata filters.

Create a deletion-validation workflow for [withdrawn documents], verifying stale vector copies cannot be retrieved.

Plan vector-search monitoring for [customer FAQ] using labelled questions, response latency and relevance thresholds.

Compare namespace strategies for [multi-team application] and enforce isolation through authorized tenant metadata.

Plan the steps to install [trusted AI application] in Pinokio, including expected model downloads, disk space and supported operating system.

Use Pinokio to start [locally installed inference app] and verify that its browser interface is reachable only on the intended host.

Inspect the install, start and update scripts of [Pinokio launcher] for shell commands, downloads and destructive file operations.

Document how to stop and restart [local AI server] from Pinokio, distinguishing the launcher from the underlying application.

Compare two Pinokio launchers for [same open-source model] on maintainer activity, dependencies and hardware requirements.

Troubleshoot a failed Pinokio installation of [approved app] by collecting the log, identifying the failed dependency and testing a safe fix.

Prepare a local-only Pinokio trial of [model] using non-sensitive sample files and verify that it does not require cloud API keys.

Plan a backup of [Pinokio app settings and owned outputs] before updating or reinstalling its launcher.

Create a Pinokio safety checklist for [community AI launcher] covering source trust, disk and GPU limits, permissions, secrets and rollback.

Map source fields into [destination request] with checked types.

Run a scheduled status check against [authorized endpoint].

Retry rate-limited API calls a bounded number of times.

Ignore repeated events using a stable record identifier.

Use managed credentials for connected services.

Transform [API response] into a report with only approved fields.

Test missing and malformed webhook payloads before activation.

Inspect failed runs to find the first broken workflow step.

Create a monitoring and rollback checklist for the finished automation.

Workflow: Import [lead CSV] after deduplicating by email/company, map organization and contact fields, record source attribution, and manually verify ten sampled records before automation.

Workflow: Set up activity reminders when a deal has no next action for [N] days. Exclude Won/Lost deals, assign the deal owner, and test with one sample deal before enabling automation.

Workflow: Build a forecast view for [quarter] by stage, expected close date and deal value. Flag stale opportunities and missing amounts; distinguish forecast from contracted revenue.

Workflow: Create a lightweight lead qualification routine using [firmographic criteria] and existing Pipedrive fields. Review scored leads manually and track false positives before using any AI suggestions.

Design a lost-deal reason taxonomy for [sales team], with clear categories and fields for evidence-based notes.

Build an automation that creates a follow-up task after [approved deal-stage change] and excludes already closed opportunities.

Identify pipeline hygiene issues in [exported deals], including duplicates, missing close dates and unowned next steps.

Compare [two sales forecast scenarios] under documented conversion assumptions without representing either as guaranteed revenue.

Draft a sales-manager dashboard showing lead source, activity recency and deal value, with consistent currency and status rules.

Turn this script into a polished production plan with scene, pacing and audio guidance: [script]

Create three variations of this concept with Pipio AI for different audiences or platforms: [concept]

Improve this production brief for clarity, pacing, consistency and audience engagement: [brief]

Use Pipio AI to turn these source materials into a publish-ready asset while preserving the intended message: [inputs]

Use Pipio AI's AI-powered digital avatars capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use Pipio AI's Text-to-speech engine with multi-language support capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use Pipio AI's Customizable video templates capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use Pipio AI's Background removal and replacement capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Use Pipio AI's API access for automated video generation capability to complete [specific goal] for [audience]. Show the result and briefly explain the key decisions.

Create a clear executive summary slide from [verified revenue data].

Build a sales presentation for [approved product] without inventing customer outcomes.

Rewrite [crowded slide] as a headline, three supporting points and one visual.

Apply [brand typography and palette] consistently across [team presentation].

Prepare speaker notes for [presentation] using only facts in the briefing document.

Compare two slide layouts for [complex workflow] on readability and hierarchy.

Collaborate on [draft proposal] with clear owners and reviewer comments.

Check charts in [Pitch deck] for correct units, axes and source attribution.

Audit [final slides] for accessibility, image rights and unverified claims.

Use PixelBin's transformation Playground to resize [product photo] for a 1200-by-1200 storefront tile without stretching the subject.

Create a PixelBin transformation preset for [approved image dimensions, output format and quality] and apply it to test assets.

Apply PixelBin's background-removal transformation to [owned product image] and inspect fine edges for missing details.

Use a PixelBin transformation URL to deliver [approved hero image] in WebP for web and JPEG for a fallback use case.

Compare PixelBin source and transformed image file sizes for [page gallery] while checking visible sharpness and color.

Set up a bulk PixelBin transformation job for [authorized collection of product photos] using a saved preset.

Check how PixelBin delivers [image] through its CDN URL and document cache and URL changes for a responsive-image rollout.

Connect [approved external image storage] to PixelBin following the documented connector requirements and least-privilege permissions.

Audit a PixelBin media workflow for token security, original-image retention, asset permissions, transformations and delivery costs.

Use Pixelcut to replace the background behind [approved apparel photo] with a consistent brand color without altering the product.

Create three Pixelcut Product Studio scene variations for [owned product shot] and check that dimensions and branding remain accurate.

Remove [unwanted object] from an owned photo with Pixelcut's Magic Eraser, then check the reconstructed background for artifacts.

Upscale [small product image] in Pixelcut and compare texture fidelity and artificial details against the original.

Expand [owned square image] into a vertical social-media crop using Pixelcut's outpainting tool while preserving the main subject.

Batch-remove backgrounds from [authorized image set] in Pixelcut and verify padding, edge quality and export consistency.

Create matching product thumbnails from [approved catalog photos] using Pixelcut batch editing and consistent sizing.

Compare a clean white studio background with [approved lifestyle setting] in Pixelcut for [product], checking against misleading visuals.

Audit Pixelcut outputs for invented product details, image rights, subscription limits and print-versus-web resolution.

Remove [background] from [product image] and inspect object edges at full resolution.

Extend [licensed landscape image] to fit [banner dimensions] without changing its original subject.

Replace [unwanted object] in [street photograph] and check continuity of shadows and pavement texture.

Create a layered poster composition for [fictional event] with separate foreground, illustration and headline areas.

Resize [social artwork] while keeping fine print and logos inside safe areas.

Test one-click enhancement on [low-light photo] for detail retention and realistic color.

Develop three edited variations of [approved campaign photo] using distinct but brand-safe looks.

Check [AI-generated visual asset] for nonsensical text and artifacts before using it in an advertisement.

Prepare a transparent PNG export of [edited product cutout] and verify canvas dimensions and alpha quality.

Generate a short shot of [fictional city street] with clear camera direction.

Create an image-to-video clip from [authorized landscape] with stable horizon.

Compare two motion settings on the same [original artwork] for unwanted distortions.

Plan a vertical clip for [approved campaign] with mobile-safe framing.

Test a slow camera move around [fictional object] without duplicating its geometry.

Generate two lighting variations of [short cinematic scene] with unchanged action.

Review [PixVerse output] for flicker, abrupt subject changes and unwanted text.

Prepare a shot list connecting [three generated clips] into a simple narrative.

Check permitted use, crop and export resolution for [selected final clip].

Import [owned performance video] into Plask and extract a single-performer 3D motion sequence using available tracking options.

Compare Plask motion capture V1 and V2 on [same test clip], focusing on foot sliding, stability and body rotation.

Enable multi-person tracking in Plask for [consenting two-person performance] and check subject separation and credit use.

Import [licensed humanoid 3D character] into Plask and retarget [captured motion] to the rig.

Review a Plask animation for joint jitter and misplaced feet, then adjust the motion or scene before export.

Prepare a Plask scene with [approved character], simple lighting and camera placement for a short animation preview.

Export [approved Plask motion sequence] as FBX for Blender and check whether the expected rig and frame range imported correctly.

Compare Plask FBX, BVH and GLB exports for [specific downstream animation workflow] and document differences.

Review [Plask production shot] for performer consent, source video rights, model licensing, motion artifacts and render costs.

Use [owned photo] as an image-editing reference to explore three lighting styles without altering the subject.

Create a series of matching social graphics for [product launch] with consistent visual motif and aspect ratios.

Replace [undesired background prop] in [licensed image] while preserving foreground details and shadows.

Extend the canvas of [approved landscape] to [16:9] with coherent clouds, lighting and horizon.

Compare [two generated design drafts] for composition, focal clarity and invented visual elements.

Explore a minimalist illustration of [original mascot] in three colorways while keeping distinctive markings.

Prepare product-photo concept imagery for [fictional brand] without inventing reviews or measurable claims.

Inspect [generated design asset] for inaccurate typography, distorted faces and perspective errors.

Export [selected artwork] for a website hero with sufficient resolution, safe margins and clear copyright review.

Create four composition variants in a local Playground v2 Diffusers pipeline for [scene] and record seed, steps and configuration for reproducibility.

Test the Playground v2 aesthetic checkpoint on [fantasy portrait prompt], comparing subject consistency across seeds instead of reporting only the best sample.

Compare Playground v2's output with [other installed open model] using the same 1024px prompt and a human-rated evaluation rubric.

Write a Diffusers Python inference setup for the published Playground v2 checkpoint on [supported hardware], including memory checks and no unverified commands.

Explore an architectural visualization prompt for Playground v2 with [room dimensions and material palette], then flag physical geometry errors for review.

Run a prompt ablation with Playground v2 for [product render], changing lighting, background and lens description one variable at a time.

Prepare a Playground v2 illustration set for [editorial article] with consistent visual palette and varied scenes, keeping rights and model license under review.

Measure image quality on [ten original prompts] from Playground v2 using consistent sampling settings and a documented human-evaluation sheet.

Document the checkpoint source, intended 1024px output, model-license conditions and reproducible seed for an image generated with Playground v2.

Rewrite [dense slide] into a clear headline and three supporting facts.

Convert [existing document] into a presentation outline while retaining source citations.

Compare two slide layouts for [quarterly metrics] on visual hierarchy and accuracy.

Format [brand presentation] with consistent colors, title levels and chart labels.

Create a speaker-notes draft from [approved briefing] without adding unsupported figures.

Prepare a product comparison slide using [verified feature matrix] and cited sources.

Audit [generated deck] for invented customer quotes and stale pricing claims.

Build a short executive summary of [long team report] for a five-minute presentation.

Review [Plus AI slide export] for editable elements, image rights and accessibility.

Clean [authorized podcast recording] to reduce room noise without damaging voices.

Review [auto transcript] against the original audio for technical names and numbers.

Create an episode outline with intro, interview topics and closing CTA from [approved notes].

Choose a cut of [interview answer] that preserves the speaker's meaning and context.

Prepare a 30-second audiogram from [licensed episode] with accurate captions.

Compare two loudness-normalized mixes for [podcast segment] on clarity and clipping.

Draft show notes with verified links, guest details and exact timestamps.

Create a quality-control checklist for [recorded remote call] covering dropouts and synchronization.

Check consent, recording permissions and export settings before publishing [episode].

Create a custom bot focused on [technical documentation Q&A] with a clear scope and uncertainty instruction.

Compare model outputs on [short multilingual support reply] for factual consistency and appropriate tone.

Run the same [coding test case] through [two models] and score resulting code with unit tests.

Prepare a reusable Poe prompt for extracting validated [JSON fields] from [sample text].

Check whether a model’s answer about [recent software change] includes verifiable release-note sources.

Design an original image prompt for [fictional poster] and compare supported generation models for output control.

Review a custom bot conversation about [private files] for accidental leakage of personal data.

Create a model-comparison sheet for [long document summary] that measures omitted qualifications and unsupported citations.

Plan a cost-conscious Poe multi-model experiment on [evaluation set] that tracks actual credit use and prevents unnecessary retries.

Photo-scan [owned sculpture] with even lighting and sufficient overlap.

Compare [photogrammetry] and [LiDAR] meshes for detail.

Check room dimensions with physical measurements before relying on the scan.

Remove floating and duplicate geometry from [captured model].

Plan a simple walkthrough of [authorized interior capture].

Export [scan] with checked scale and orientation.

Inspect [point cloud] for gaps around reflective objects.

Share [model] only with authorized collaborators.

Review [3D capture] for private details and permitted use.

Use PolyAI to investigate why [campaign] conversion rate changed between [period A] and [period B], separating observed data from possible explanations.

Import [Google Sheets marketing report] into Polymer, check date and currency formats, and flag duplicate rows before building any charts.

Create a Polymer dashboard for [regional sales dataset] showing sales by region, product category and month, with filters that use consistent time periods.

Ask Polymer's AI-generated Boards to suggest three useful questions about [inventory dataset], then reject any visualization that lacks a valid business interpretation.

Build an interactive Polymer view of [customer-support metrics] with case volume, resolution time and satisfaction, preserving missing values visibly.

Compare [two acquisition channels] in Polymer using cost, attributed orders and conversion rates; explain denominator choices and sample-size limits.

Prepare a shareable Polymer performance board for [stakeholders], including clear metric definitions, appropriate filters and a restricted-access check.

Audit an automatically generated Polymer chart that shows [unexpected spike] by tracing source rows, grouping, missing dates and aggregation settings.

Design a Polymer reporting workflow for [monthly CSV exports] that keeps schema consistent and includes a data-freshness indicator on every dashboard.

Add a monthly trend visual for [verified revenue measure] and explain which model date field determines the reporting period.

Summarize the visible [quarterly performance report] with notable changes, units, and filter context, without asserting unproven causes.

Compare [two customer segments] on [documented repeat-purchase measure] with clearly stated denominators.

Add a chart of [inventory quantity] against [reorder threshold] from existing model fields and flag missing measures.

Explain [DAX measure] in plain language and identify filter-context assumptions before modifying it.

Suggest an additional visual for [operations dashboard] based on available semantic-model fields, then verify the selection.

Change [existing chart type] to a more suitable visual for [category comparison] without implying unsupported custom styling.

Inspect [Copilot-generated report page] for ambiguous field names, incorrect aggregations, and duplicated metrics.

Prepare an executive summary of [approved report page] that distinguishes observed results from recommendations and preserves row-level security.

Turn [verified blog summary] into a five-card social carousel with a clear takeaway on each card.

Draft a 20-second product reel script with a scene plan and only approved feature claims.

Adapt [existing social caption] for Instagram and LinkedIn while retaining source attribution.

Build a seven-day posting calendar for [brand] using owned images and confirmed launch dates.

Compare two creative directions for [audience] on readability, originality and brand fit.

Create a consistent branded carousel from [product FAQ] without promising unsupported outcomes.

Review scheduled Predis.ai posts for duplicate copy, broken links and inconsistent time zones.

Summarize [campaign analytics] by reach, clicks and engagement with the actual reporting period.

Check AI-generated media for altered logos, fabricated testimonials and permitted usage before publishing.

Turn [approved research notes] into a slide-by-slide narrative with evidence references.

Build a comparison deck for [three software products] using a confirmed feature matrix.

Redesign [crowded presentation slide] to highlight its main result without losing important caveats.

Draft a short investor-style overview of [approved business model] without inventing traction figures.

Apply [brand palette and typography] consistently across title, data and conclusion slides.

Generate a timeline slide from [project milestones] with correct dates and dependencies.

Convert [verified numerical table] to a chart with appropriate units and zero-baseline checks.

Compare two slide designs for [complex process] on reading order, contrast and detail.

Audit [AI-produced slide deck] for invented claims, inaccurate charts and copyright-sensitive imagery.

Create two Flow Music variations of [original chorus concept] with contrasting tempos and compare the melody, arrangement and vocal intelligibility.

Ask Flow Music's Producer studio assistant to develop [verse-and-chorus structure] for an original track while retaining the specified lyrical perspective.

Remix [music recording I own or have permission to use] in Flow Music with [new instrumentation], checking rights and keeping a reference export.

Prepare a Flow Music sound-effects or instrument-bed concept for [game scene], specifying mood, length and clear transitions before creating assets.

Use Flow Music's stem-splitting or remix options on [authorized source track] and inspect separation artifacts, phase issues and retained vocals.

Storyboard a Flow Music AI music video for [my original song] with consistent character descriptions, shot continuity and clearly licensed reference material.

Develop a Flow Music track suitable for [creator video] with [energy curve, instruments and no vocals], and review synchronization against the picture.

Organize a Flow Music project into [intro, verse, build and outro] and request revisions to the weakest section without regenerating approved parts unnecessarily.

Review a Flow Music-generated song for awkward lyrics, unclear pronunciation, copyright concerns, inconsistent loudness and export readiness before publishing.

Generate two lighting treatments for [authorized facade design].

Turn [approved product drawing] into a visual concept.

Compare sketch-to-image outputs for fidelity to dimensions.

Refine [concept art] without changing approved object geometry.

Test two material palettes for [furniture prototype].

Prepare a background-free version of [owned product render].

Check [render] for invented doors and impossible shadows.

Create a presentation crop from [selected visual].

Document source rights and non-build-ready design assumptions.

Connect a Python validation step before the language-model node in [test flow].

Compare two prompt versions using the same [evaluation dataset].

Run a batch evaluation of [document classifier] and report per-case failures.

Trace a failed flow execution to identify the responsible node and input.

Add explicit timeouts and error paths to [external API call] in the flow.

Build an evaluation rubric for [grounded answer quality] with reference evidence.

Review [flow DAG] for circular dependencies and unnecessary model calls.

Prepare a reproducible flow test using [saved sample inputs] and recorded expected outputs.

Document version, datasets and evaluation metrics for [promptflow release candidate].

Write Promptfoo assertions for [customer FAQ assistant] that check required facts, forbidden claims and answer format.

Run a Promptfoo test suite for [RAG chatbot] and inspect incorrect answers against the expected source-grounded responses.

Compare Promptfoo results for [two prompt variants] across quality, latency and documented token costs.

Use Promptfoo test variables to evaluate [same instruction] on [five representative user personas] without sensitive personal data.

Set up a controlled Promptfoo red-team evaluation against [owned staging AI application] with approved scope and rate limits.

Inspect Promptfoo red-team findings for [prompt injection defense] and verify apparent vulnerabilities before escalating.

Build a Promptfoo regression suite for [changed system prompt] to detect previously passing cases that now fail.

Export Promptfoo evaluation results for [release candidate] and summarize failed assertions by severity and reproducibility.

Plan a Promptfoo CI quality gate for [LLM feature] with threshold, review owner and an exception process for flaky graders.

Review [academic draft] for readability without changing references.

Identify repetitive expressions in [chapter] and recommend alternatives.

Compare two edits of [dialogue] for clarity and consistent character voice.

Analyze [novel introduction] for sentence-length variation and pacing.

Apply [house style rules] to [business article] with consistent terminology.

Evaluate [editing suggestions] against the original to preserve figures.

Review overused adverbs in [manuscript] without flattening style.

Simplify jargon in [customer guide] while retaining technical accuracy.

Build a revision checklist from [ProWritingAid style reports].

Explore [recurring dream symbol] in Psyche Dream using Jungian, Freudian and archetypal perspectives as possibilities rather than proven meanings.

Compare two saved Psyche Dream entries involving [theme] and identify emotional patterns without claiming a medical diagnosis.

Use Psyche Dream's reflection questions on [dream entry] to write three gentle journal prompts about recent experiences.

Create a weekly Psyche Dream review of [seven entries] showing recurring settings, mood tags and uncertainties in interpretation.

Summarize an unsettling dream in Psyche Dream in neutral language, avoiding deterministic predictions or claims that it signals future events.

Use Psyche Dream to examine how [sleep disruption] coincides with [dream mood] in my journal, clearly noting that correlation is not causation.

Compare Freudian and Jungian interpretations of [dream narrative] and list what each framework assumes but cannot verify.

Prepare a private Psyche Dream journaling routine for [morning reflection], including minimal personal information and an optional mood check.

Turn a Psyche Dream interpretation of [symbolic image] into an open-ended self-reflection exercise while explicitly avoiding clinical or therapeutic advice.

Compare two PXZ video models on [same authorized reference image] and document consistency and artifacts.

Create an original poster image for [fictional campaign] using PXZ with clear subject and layout constraints.

Use PXZ video-to-video styling on [owned footage] while preserving the original action and pacing.

Test a short PXZ prompt variation for [cinematic product shot] and compare visual focus across outputs.

Prepare [reference image] with a clean composition before adding motion in PXZ.

Review two PXZ video drafts for flicker, warped hands and drifting faces before selecting a final take.

Adapt [approved visual brief] to square and vertical content without cropping key text or faces.

Verify that a selected PXZ model supports [requested effect] rather than relying on platform-wide marketing claims.

Audit PXZ output for source asset rights, deceptive edits, model limitations and commercial-use terms.

Create a PydanticAI result schema for [use case] and show how invalid model output should be retried or rejected.

Design a PydanticAI agent that can switch between [model A] and [model B] without changing business logic.

Use PydanticAI dependency injection to provide an agent with [database/API/service] access while keeping the agent testable.

Create a test suite for a PydanticAI agent covering deterministic dependencies, mocked model responses, and output validation.

Add Logfire tracing to a PydanticAI workflow for [task] and identify the spans and metadata that would be useful for debugging.

Design a human-approval step in a PydanticAI agent before it performs [sensitive action].

Create a durable PydanticAI workflow for [multi-step process] that can recover safely after a failed step.

Use PydanticAI to turn this unstructured input into a validated object matching this schema: [input/schema].

Refactor this Python agent design into a typed PydanticAI structure with clear dependencies, tools, result models, and error handling: [design].

Define a torch.nn.Module for [simple classification task] and print its input, hidden-layer and output tensor shapes.

Write a PyTorch training loop for [sample model] with an optimizer, loss function and separate validation split.

Use torch.autograd to explain the gradients of [small differentiable expression] and verify them numerically.

Move [PyTorch model and input batch] to an available CUDA, MPS or CPU device without mixing tensor devices.

Compare PyTorch training curves for [learning rate A] and [learning rate B] using identical seeds and datasets.

Implement early stopping for [PyTorch experiment] using validation loss while keeping test data untouched.

Save [trained PyTorch model] using state_dict and demonstrate a fresh load into an identical model architecture.

Profile a PyTorch batch of [specified size] to identify data-loading and model execution bottlenecks.

Audit a PyTorch experiment for reproducibility, train-test leakage, untrusted checkpoint loading and fair metric reporting.

Upload [small authorized document dataset] as Qdrant points with vectors, stable IDs and source metadata payloads.

Run a Qdrant similarity query for [sample embedding] and inspect relevance scores alongside source payloads.

Add a Qdrant payload filter for [document type] and [approved publication date range] without post-filtering results.

Create a Qdrant payload index for [frequently filtered tenant field] and explain its effect on filtered search.

Test a Qdrant query using dense vectors versus a named sparse vector on [same sample corpus], recording precision trade-offs.

Plan an isolation scheme for [multi-tenant application] using indexed tenant payload fields and strict query filters.

Benchmark Qdrant filtered search on [staging collection] for recall and latency against an exact-search baseline.

Design a Qdrant backup and restore validation plan for [non-sensitive collection] including payload and vector consistency.

Audit a Qdrant deployment for exposed HTTP endpoints, authorization, sensitive payloads, index choices and resource limits.

Use Qiqqa's full-text search to locate every paper discussing [research concept], including related terms and a checklist for false positives.

Annotate [technical paper] in Qiqqa with key findings, limitations and questions, preserving page references for later citation.

Create a Qiqqa reading queue for [literature review] ordered by relevance and methodological strength, not just publication date.

Detect likely duplicate papers in [Qiqqa PDF library] by comparing titles, DOIs and versions before removing any record.

Export verified Qiqqa bibliography entries from [selected papers] for use in [Word or BibTeX workflow], checking citation metadata first.

Organize a Qiqqa local library on [topic] with tags for methods, evidence quality and research questions rather than duplicative folders.

Compare findings across [three annotated Qiqqa papers] on [claim], separating contradictory results from differences in study design.

Plan an approved Qiqqa library backup for [Windows research setup] using local or intranet storage, since the open-source release no longer offers the former hosted web-cloud synchronization.

Prepare a research synthesis from [Qiqqa highlighted documents] with sourced claims, methodological caveats and an evidence-gap table.

Use Qodo's codebase context to examine how [changed function] affects callers across [related services] before approving the change.

Configure a Qodo code-review rule for [authentication middleware] that checks authorization boundaries and cites the policy it enforces.

Investigate a Qodo review finding about [error handling] by comparing the proposed fix with existing tests and similar code patterns.

Run Qodo's pre-PR review on [staged changes] and separate critical bugs from speculative style recommendations before opening a pull request.

Use Qodo to review AI-generated [database migration] for data loss, backward compatibility and rollback requirements, keeping deployment approval with engineers.

Inspect Qodo code-review coverage for [repository] and identify modules where rules, test evidence or ownership are missing.

Create a Qodo governance report for [engineering team] covering recurrent violations, resolution evidence and rules that need refinement.

Apply a Qodo review-and-fix loop to [bug fix] with an agent, requiring regression tests and a clean diff before accepting the result.

Compare two Qodo review results for [same PR revision] and explain which findings are independently supported by code evidence rather than confidence scores.

Check [monthly expense report] for uncategorized entries, duplicates, and missing receipts before reconciliation.

Prepare an invoice draft for [approved customer work] using agreed line items, currency, and due date.

Compare [cash-in and cash-out trends] by month using reconciled records and show any missing periods.

Review [AI-suggested accounting category] against the chart of accounts before accepting the change.

Build a list of [overdue invoices] with accurate customer balances and human-approved follow-up actions.

Check [receipt scan results] for incorrect VAT amounts, missing supplier details, and duplicate entries.

Create a month-end bookkeeping checklist with bank matching, invoice reconciliation, and unresolved exceptions.

Compare [expense categories] against prior periods and distinguish anomalies from confirmed accounting errors.

Prepare questions for [professional accountant] about uncertain tax treatments rather than relying on an AI answer alone.

Compare the formal and simpler paraphrasing results of [policy sentence] for altered obligations.

Use QuillBot Grammar Checker on [customer-facing announcement] without changing dates or pricing.

Summarize [long educational passage] into the essential concepts, then verify the output against the original text.

Generate a citation for [journal article metadata] and verify the DOI, year and author order.

Check [draft manuscript] for awkward repeated phrasing without introducing uncited source ideas.

Translate [technical note] to [target language], preserving units, negations and product terminology.

Rewrite [overly wordy email] as three concise paragraphs with a clear, factual request.

Compare [source paragraph] with [paraphrased paragraph] for too-close wording and any loss of meaning.

Run an editorial pass on [completed assignment] for grammar, citation consistency and possible plagiarism concerns.

Test a Qwen code model on [Python parsing bug] with failing tests, passing tests and invalid API-call counts.

Ask a vision-capable Qwen model to describe [licensed screenshot] and check that extracted labels are genuinely visible.

Evaluate [Chinese-to-English technical translation] for omitted units, names and negation errors.

Solve [mathematics word problem] with a Qwen model and independently check the numeric result.

Create a controlled benchmark for [classification prompts] that fixes dataset, generation settings and scoring rules.

Inspect [model-generated SQL] against [actual table schema] for invented column names and unsafe writes.

Plan inference deployment for [open-weight Qwen checkpoint] including required hardware and license verification.

Compare [reasoning-capable Qwen variants] on [held-out logic set] using outcome correctness rather than style.

Prepare a safety review for [Qwen API or local model] covering data retention, endpoint access and benchmark reproducibility.

Use Radiant Photo 2 Face Light on [consenting portrait subject] to improve facial illumination without washing out surrounding highlights.

Apply the Radiant Photo 2 color-grading controls to [owned sunset photo], testing a restrained film-inspired treatment while preserving skin tones.

Adjust the automatic exposure and color correction in Radiant Photo 2 for [backlit travel photo] and inspect shadow noise.

Compare [three owned images from the same event] after Radiant Photo 2 automatic enhancements to identify inconsistent white balance.

Edit [high-resolution owned landscape] in Radiant Photo 2 using a nondestructive workflow and record the settings for later adjustment.

Prepare a print-ready Radiant Photo 2 export for [approved exhibition photo] using the supported 16-bit workflow where applicable.

Process [authorized group of similar event photographs] in Radiant Photo 2 and check that automatic corrections suit each scene.

Use Radiant Photo 2 as a standalone editor or compatible photo-editor plugin for [one authorized test image] and compare results.

Audit [Radiant Photo 2 enhanced portrait] for unnatural facial edits, clipped highlights, color shifts and export quality before delivery.

Create a spend report for [department] comparing [current month] with [previous month], showing actual amounts and the accounting period.

Find duplicate or unusual [merchant charges] in [approved transaction export], citing source IDs for finance review.

Draft an approval workflow for [vendor purchase above threshold] with an explicit budget owner and exception path.

Prepare a month-end checklist for [uncategorized card transactions] before syncing verified records to the accounting system.

Analyze [employee reimbursements] for missing documentation without treating anomalies as proof of fraud.

Compare [AI service token costs] by connected provider and model, clearly separating usage and invoice amounts.

Generate a vendor spend summary from [authorized bills] with renewal dates that are explicitly present in the records.

Check [card policy proposal] for spending limits, merchant restrictions, exception handling, and assigned approvers.

Audit [Ramp-generated savings suggestion] against historical charges and supplier terms before estimating any potential savings.

Configure a Rank Math focus-keyword checklist for [approved WordPress guide], avoiding keyword stuffing and unsupported promises.

Review Rank Math's title and meta description preview for [WordPress test post] and rewrite it accurately within a natural snippet length.

Inspect Rank Math's XML sitemap settings on [authorized WordPress site] and identify unintended exclusions without exposing private pages.

Audit Rank Math canonical URL settings for [owned page with parameters] and confirm the chosen canonical resolves successfully.

Check Rank Math's supported structured-data settings for [eligible article] and use only schema properties actually present on the page.

Create a Rank Math SEO checklist for [category archive] covering headings, contextual links, pagination and indexability.

Review Rank Math's redirect module for [verified old URL] and test a one-hop 301 to the exact new destination without chains.

Compare Rank Math's on-page recommendations against [Google Search Console evidence] before deciding which content edits are worthwhile.

Audit [Rank Math WordPress setup] for noindex mistakes, thin pages, incorrect schema, duplicate titles and broken canonical/redirect links.

Create a step-by-step machine learning pipeline in Altair AI Studio for predicting [target].

Explain which preprocessing operators I should use in Altair AI Studio for this dataset: [details].

Compare suitable model families in Altair AI Studio for [problem] and explain the trade-offs.

Turn this analytical objective into a visual Altair AI Studio workflow: [objective].

Create a visual preprocessing pipeline for [customer dataset] that handles missing categories and captures each transformation.

Design cross-validation for [imbalanced classification problem], including leakage checks and minority-class metrics.

Compare [decision tree and gradient boosting models] on the same split with interpretability and calibration trade-offs.

Prepare an end-to-end regression experiment in Altair AI Studio for [sales forecast], including a simple baseline.

Inspect [visual workflow] for disconnected operators, datatype mismatches and untracked dataset revisions.

Create a Spanish dub of [approved product demonstration] in Rask.ai and verify the names of products.

Use Rask.ai speaker detection on [authorized interview] and check each speaker assignment.

Compare Rask.ai dubbing variants of [training clip] for pacing and clear pronunciation.

Review translated transcript text in Rask.ai before rendering [owned educational video].

Generate captions for [authorized explainer video] in Rask.ai and correct punctuation and names.

Review Rask.ai lip-sync on [consenting talking-head video] for mouth and audio alignment.

Prepare Rask.ai voice localization for [approved narrator] and document consent and usage permissions.

Plan a human-reviewed Rask.ai API workflow to localize [licensed video collection].

Audit Rask.ai localized [approved video] for translation accuracy, voice rights, timing and subtitle quality.

Suggest a readable presentation for this code snippet aimed at [audience]: [code]

Choose a visual hierarchy for sharing this code example in documentation: [code]

Prepare this code snippet for a concise social post while preserving readability: [code]

Review this code-image brief for clarity, spacing and presentation: [brief]

Format [TypeScript snippet] with syntax highlighting optimized for dark-background documentation and readable at mobile width.

Prepare an image of [Python example] with consistent padding, monospace typography and a neutral background for [tutorial].

Create side-by-side code image briefs showing [unsafe pattern] and [corrected pattern] with the differences visually obvious.

Export [code sample] for [presentation slide] with adequate contrast and line wrapping, preserving indentation.

Review [code image] for clipped lines, incorrect highlighting, illegible comments and syntax that changed during copying.

Wrap [permitted small ML model] in a Ray Serve deployment and test request validation, response shape and exception handling.

Compose preprocessing and inference stages using Ray Serve DeploymentHandles for [synthetic sample pipeline] and compare results to direct inference.

Configure Ray Serve resource limits for [staging deployment] and confirm CPU/GPU requests match the actual workload.

Create a Ray Serve autoscaling test plan for [controlled synthetic traffic], recording replica counts, latency and queue behavior.

Test Ray Serve graceful handling of a failing model request in [nonproduction service] without exposing confidential inputs.

Add FastAPI ingress to [Ray Serve test app] where supported and validate route names, payload types and status codes.

Write a minimal Ray Serve deployment configuration for [staging app], then verify that local and configured versions behave consistently.

Measure Ray Serve model-serving throughput on [approved benchmark input] using the same model, hardware and concurrency constraints.

Audit [Ray Serve deployment] for publicly exposed endpoints, insecure artifacts, secret leakage, missing limits and misleading performance benchmarks.

Import [search results], deduplicate references and reconcile counts against the original search export.

Define title-and-abstract inclusion and exclusion criteria for [population, intervention and study type].

Screen [ambiguous abstracts], documenting insufficient information rather than guessing eligibility.

Plan blinded independent screening for [two reviewers] and a controlled conflict-adjudication stage.

Organize full-text eligibility checks for [included abstracts], preserving exclusion reasons and source pages.

Create a structured extraction template for [trials] covering sample, intervention, comparator and outcome time.

Review risk-of-bias assessments for [included studies] and locate evidence behind conflicting judgments.

Reconcile PRISMA counts across imported, duplicate, excluded and included records with the review history.

Export [included studies and decisions] with reviewer audit trail and citations for downstream synthesis.

Extract action items from [meeting transcript] and preserve confirmed owners and deadlines.

Compare [two meeting summaries] for disagreements about the decision reached.

Prepare a CRM handoff from [authorized sales discussion] without recording sensitive personal details.

Find unresolved questions in [project meeting] and group them by responsible team.

Review the generated transcript for wrong speaker attribution and technical terms.

Draft a follow-up email using only decisions confirmed in [recorded meeting].

Build a weekly meeting digest from [approved session notes] and highlight recurring blockers.

Audit [AI meeting insight] for unsupported sentiment claims and missing discussion context.

Check participant consent and access permissions before sharing [meeting report].

Import [owned PDF] into Readwise Reader and highlight passages relevant to [research topic].

Subscribe to [approved RSS source] in Reader and distinguish new Feed items from saved Library entries.

Use Reader Ghostreader to summarize [saved article] and verify the summary against the original.

Ask Ghostreader to explain [technical concept] in the context of the selected text passage.

Use Global Ghostreader in Readwise Reader to locate past research notes on [topic] with source citations.

Build a Reader filtered view for [project articles] and separate unread items from archived references.

Use Reader text-to-speech to review [saved document] and mark sections needing closer reading.

Annotate [approved research PDF] in Reader and verify highlights sync to the Readwise library.

Audit [Reader research folder] for duplicate saves, incomplete AI summaries and source attribution.

Protect [two personal habits] on [weekday calendar] without overlapping appointments or travel time.

Plan flexible time for [three project tasks] according to due date, importance and estimated effort.

Compare [calendar before and after smart scheduling] for overbooking and lost meeting buffers.

Add preparation and recovery buffers to [customer meetings] while preserving booked start times.

Create team availability rules that avoid interrupting [defined no-meeting hours].

Review [overdue scheduled tasks] and decide which should move versus require renegotiated deadlines.

Plan synchronization between [calendar and task manager] with safeguards for duplicate events.

Check [habit schedule] against real-world work and family commitments rather than forcing every block.

Produce a weekly Reclaim scheduling review from [actual completion data] to adjust realistic task estimates.

Create an original SVG-style brand mascot for [small business] using a clear silhouette and restrained detail.

Design three vector illustrations for [software onboarding] with one coherent design language.

Explore typography and illustration layouts for [promotional poster] while reserving exact headline text for final editing.

Use style control to create a consistent icon family across [navigation, billing and support] concepts.

Remove [background] from [licensed brand asset] while preserving transparent edges and original logo geometry.

Prepare an illustration variant of [real product photograph] without introducing non-existent product features.

Compare vector and raster exports for [website icon] on sharpness, color fidelity and file size.

Create a repeating decorative graphic pattern for [packaging concept] without trademarked source elements.

Audit [Recraft-generated vector assets] for editable paths, embedded text correctness and suitability for production.

Adjust Recut's silence sensitivity for [interview footage] to preserve natural breathing pauses.

Use Recut to create a rough cut of [authorized tutorial video] while checking that no essential speech is removed.

Compare two Recut silence thresholds on [same recording] for pacing and comprehensibility.

Synchronize [licensed multi-camera interview] in Recut and review silence cuts across its audio tracks.

Export a Recut cut list as XML for [Adobe Premiere Pro project] and inspect the resulting timeline.

Prepare a Recut rough-cut export for [DaVinci Resolve edit] and check that audio stays aligned.

Use Recut's preview to manually protect [deliberate dramatic pause] before exporting the edit.

Compare [Recut-edited podcast] against the original for clipped sentences and awkward joins.

Audit Recut's output for missing speech, abrupt transitions, editor compatibility and source recording rights.

Use Refact's IDE chat to trace [function call] across [modules] and explain the data flow with specific repository references.

Request a context-aware Refact code completion for [function skeleton] that follows this project's error handling, typing and naming conventions.

Have Refact refactor [module] into smaller functions while retaining public interfaces; compare tests and diff before accepting the change.

Use Refact to generate unit tests for [component] covering null inputs, concurrency, invalid permissions and boundary values.

Configure a Refact.ai deployment plan for [restricted enterprise codebase], comparing on-premises operation with permitted cloud models and credential boundaries.

Ask Refact to diagnose performance in [slow query function] with a reproducible benchmark and measurements rather than unverified optimizations.

Review a Refact-generated change to [authentication middleware] for privilege escalation, sensitive-data logging and backward compatibility before merging.

Connect Refact to [approved repository tool] for a read-only code audit, stating which external systems must remain untouched without human approval.

Use Refact.ai Agent to prepare a release summary for [task] listing changed files, tests executed, manual checks and rollback steps.

Link [research finding] to [earlier hypothesis] using a backlink.

Find [project constraint] in saved notes and verify source wording.

Summarize [authorized notes] without inventing next actions.

Prepare a weekly review of incomplete tasks and priorities.

Create a reusable template for [team meeting] notes.

Connect [reading excerpts] with their source citations.

Compare two dated notes to identify changing requirements.

Check AI summaries for omissions and unsupported connections.

Draft a project brief from linked notes and open questions.

Draft an introduction using only [approved account facts].

Create discovery questions from [documented prospect needs].

Compare two message openings for clarity and factual accuracy.

Review imported company fields for missing or outdated values.

Define human approval before campaign activation.

Prepare follow-up wording for [actual prospect question].

Check generated claims against current product documentation.

Summarize campaign response metrics over a stated date range.

Audit messages for recipient accuracy, exclusions and opt-outs.

Create a knowledge-search tool using [authorized help articles] and cite the returned passages.

Set human approval before [agent] can update any customer record.

Create a second agent to audit [draft answer] for unsupported claims.

Test [customer request] with a missing identifier and confirm the agent asks for clarification.

Connect [read-only data tool] to a workflow and validate every input parameter.

Build an evaluation set for [agent] with successful, ambiguous and unsafe requests.

Review [agent execution log] to identify repeated loops or irrelevant tool calls.

Compare [two agent configurations] for response accuracy and execution cost.

Prepare a rollback and access-permission checklist before deploying [agent workflow].

Turn [verified product brief] into a landing-page wireframe with one primary call to action.

Compare [two sitemap structures] for discoverability of pricing and support pages.

Generate a services page wireframe with [approved sections] and clear heading hierarchy.

Map [customer personas] to navigation labels and identify missing user tasks.

Review [Relume AI wireframe] for generic text, repeated sections and unclear CTAs.

Prepare a Figma handoff from [approved wireframe] and verify text and image placeholders.

Outline the Webflow implementation of [design] with responsive sections and component reuse.

Plan a mobile navigation variant for [site structure] with keyboard accessibility in mind.

Audit [generated sitemap] for orphan pages, duplicate intent and unsupported marketing claims.

Test background removal on [person with curly hair] for missing strands and obvious halo artifacts.

Prepare [20 ecommerce item photos] for consistent white-background listings while maintaining natural shadows.

Replace a removed background with [approved brand color] while preserving product outline and scale.

Compare a light-on-light object cutout against its source for areas accidentally erased.

Use the remove.bg API to process [authorized photo batch] with per-file errors, rate limits and retained originals.

Prepare a high-resolution cutout for [large print] and check that the exported dimensions meet the requirement.

Test a tricky object boundary in [transparent glassware photo] and flag regions needing manual retouching.

Create a workflow that inserts [transparent product cutouts] into a listing template without stretching them.

Audit [background removal results] for lost product parts, color changes, broken transparency and permission to use the photos.

Build a prototype for [internal task tracker] from the approved plan, separating frontend, server, and persistence requirements.

Create a validated [contact form] that stores submissions with appropriate authorization and useful error messages.

Implement [dashboard filter] for the existing app and test empty, loading, and invalid-input states.

Inspect [Replit Agent-generated code] for hardcoded API keys, broad database permissions, and missing input validation.

Ask Agent to diagnose [failing build] from actual logs and propose the smallest change that fixes it.

Plan an integration with [authorized read-only API] using environment secrets and documented request limits.

Create regression tests for [new feature] that cover normal use, malformed input, and unauthorized access.

Review the diff for [Agent-generated update] and list database or configuration changes requiring owner approval.

Prepare a deployment checklist for [Replit app] covering environment variables, secrets, health checks, and rollback.

Explain [failing Replit deployment log] and propose one testable fix instead of changing unrelated files.

Generate unit tests for [existing JavaScript function] covering empty, malformed and boundary inputs.

Build a simple API route for [demo application] with environment-managed secrets and response validation.

Refactor [database access code] while keeping the current public interface and adding regression tests.

Compare [AI-generated UI] with [approved mockup] and identify mismatched controls, labels and behavior.

Plan a staged rollout of [small website] from Replit with configuration and rollback verification.

Investigate [slow page request] using timing, query count and runtime logs rather than speculative tuning.

Review an agent-written git diff for [feature request] to find unsafe dependencies and unrelated file changes.

Create a reproducible handoff for [Replit project] with setup commands, environment variable names and passing tests.

Upload [anonymized survey results in CSV/XLSX] into Research Studio, examine the overall sentiment summary, and identify claims that need checking against the original responses.

Use Research Studio's Persona widget on [approved user interviews] to identify distinct participant needs; verify each persona insight against quotations in the source material.

Analyze [interview notes] with Research Studio's Jobs to Be Done widget and organize users' goals, motivations and unmet needs before prioritizing design changes.

Use Research Studio's Statements widget to classify sentiment in [consented feedback], then manually review ambiguous or mixed comments before reporting trends.

Map the stages of [customer onboarding journey] with Research Studio's User Journey widget, noting pain points, expectations and where the input interviews are incomplete.

Turn findings from [usability interviews] into user stories using Research Studio's User Stories widget; include actor, goal, value and source-evidence notes.

Use Research Studio's Questions Analysis widget to review [discussion guide or survey questions] and identify leading, duplicated or poorly targeted questions for the next study.

Ask Research Studio's context-locked AI chat what [research question] reveals about [user segment], request a concise evidence table, and verify every answer against uploaded files.

Prepare a Research Studio insights presentation for [product team] from [approved research], organize summary, personas and key opportunities, and review the output before sharing or exporting.

Follow the citation network of [foundational study] to locate related work.

Compare the papers recommended from [two seed sets] and identify shared themes.

Identify earlier studies cited by [paper] and separate original research from reviews.

Map [researcher's publication network] using available author links and affiliations.

Build an evidence shortlist from [saved collection] and record why each paper was included.

Check [suggested paper] for retraction, publication date and appropriate study population.

Share [curated collection] with collaborators and specify inclusion criteria.

Export [reference list] to a citation manager and verify metadata and duplicates.

Audit [recommendation list] for topic drift and papers not relevant to the stated question.

Compare two voice styles for [training narration] at equal pace.

Plan [voice-cloning project] with documented speaker consent.

Test pronunciation of [brand terms] in generated narration.

Convert [authorized speech clip] to another approved voice.

Evaluate pauses and emotion in [audio dialogue].

Prepare an API integration checklist for [speech generation].

Check generated audio for glitches and unexpected words.

Compare [voice samples] for intelligibility and accent fit.

Audit usage rights and consent before releasing [synthetic audio].

Test [licensed actor voice] on a short approved sample.

Compare source and converted delivery for preserved emotion.

Prepare a voice-matching brief with required speaking style.

Check phoneme accuracy in [multilingual dialogue] where supported.

Review [converted line] for synchronization and audio artifacts.

Create a quality review of [character dubbing] with timestamped notes.

Compare [two authorized takes] for tone consistency.

Document processing and studio handoff for [audio project].

Verify talent authorization and contractual rights before publication.

Build an internal case-management app using @[resource]. Include search and filters, an assignment queue, status transitions, notes, an audit-friendly detail view, loading/empty/error states, and validation before writes.

Create a customer-support workspace using @[tickets resource] and @[customer resource]. Show the queue, customer context and conversation history, and add only the actions the connected resources safely support.

Create a Retool Workflow that starts from [schedule or webhook], reads from @[resource], validates and transforms the incoming data, performs [business action], records failures clearly, and returns a useful run summary.

Design a Retool Agent for [business process]. Give it the minimum tools required from [functions/workflows/MCP resources], define when each tool should be used, require confirmation before [sensitive action], and propose evaluation cases for success and failure paths.

Build a data-analysis app over @[resource] where users can filter [dimensions], inspect source rows, view [charts/KPIs], and ask natural-language questions without exposing credentials or bypassing Retool resource permissions.

Use @[external MCP resource] in this app so users can [task]. Add the necessary function calls, show tool progress and failures in the UI, and ensure published users can invoke only MCP tools they are authorized to use.

Plan the safest Retool implementation for [app or automation]: identify the resources, pages or workflow blocks, permission boundaries, validation rules, failure states, and test cases first; then build the smallest production-ready version and summarize what still needs human review.

Build a Retool approval console for [purchase requests] with permission-aware queues and explicit confirmation for each change.

Diagnose [failed scheduled data sync] using workflow logs, identifying the failing block and safe replay conditions.

Query [read-only SQL source] and reconcile returned row totals.

Transform [authorized API response] into documented fields.

Schedule [daily reconciliation] with time zone and owner.

Add bounded retries without duplicating completed writes.

Route [urgent alert] using explicit conditions.

Handle missing values safely in a JavaScript transform.

Debug [failed execution] using the first error-producing block.

Require human approval before updating production records.

Write a deployment plan with monitoring and rollback.

Check the Rev AI transcription job status before retrieving [approved audio transcript].

Export a completed Rev AI transcript of [interview audio] as plain text and check proper nouns against the recording.

Review Rev AI JSON transcript word timestamps for [approved meeting audio] and correct timing errors.

Inspect Rev AI speaker labels for [authorized two-person interview] and compare with the original voices.

Create a custom vocabulary list for [product names and acronyms] before a Rev AI transcription test.

Use Rev AI's streaming speech recognition in a controlled test for [live demonstration] and compare partial versus final text.

Plan a Rev AI webhook for [asynchronous transcription completion] without exposing access tokens or customer audio.

Create captions from [approved Rev AI transcription] and verify punctuation and accessibility timing.

Audit a Rev AI transcription workflow for recording consent, transcript accuracy, retention and secure API credentials.

Draft a Birch AI automation rule for [ad campaign] using [cost-per-acquisition threshold] over [evaluation period]; review the saved draft before publishing.

Design a Birch spend-protection rule that pauses [ad sets] after [approved threshold]; check entity filters, frequency limits and rollback.

Create a controlled Birch scaling-rule draft for [campaign] using [conversion metric]; verify maximum budget, attribution window and human approval.

Audit the Birch execution logs for [rule name], report matched entities, actions and errors, and identify possible conflicts with other rules.

Prepare a Birch Stage creative-testing plan for [ad campaign] using approved assets, tracking parameters and a human review before bulk launch.

Compare [Meta and TikTok ad campaigns] in Birch reports/Explorer for [date window]; note differing attribution and incomplete data.

Configure Birch Slack notifications for [spend alert or automation error] and test recipient access without triggering live campaign actions.

Review [Birch rule set] for overlapping pause/resume actions, risky thresholds, duplicate account targets and missing failure notifications.

Create a Birch onboarding checklist for [agency/client] covering supported ad accounts, spend-based subscription plan, workspace roles, draft QA and recovery.

Check microphones, camera, and recording permissions before [interview].

Create interview questions from [approved guest brief] without inventing details.

Inspect recorded video and audio for clipping, dropouts, and sync problems.

Verify the transcript of [episode] against names, dates, and technical terms.

Create three candidate Magic Clips while preserving speaker context.

Prepare accurate captions for a vertical excerpt of [interview].

Draft show notes with source links and verified chapter times.

Review the final edit for missing dialogue or misleading cuts.

Prepare an export checklist for rights, aspect ratio, and audio level.

Create a Riverside recording setup for a [podcast/webinar/interview] that prioritizes clean audio and 4K video where available.

Use Riverside's transcription to turn this recorded conversation into a clean transcript with speaker labels and key timestamps.

Create social clips from this Riverside recording using Magic Clips, prioritizing moments about [topic] for [platform].

Use Riverside to generate concise show notes from this episode, including summary, key topics, and calls to action.

Plan a live stream in Riverside to [platforms], including roles, run-of-show, guest checks, and fallback steps.

Use Riverside's AI noise removal on this recording and define what should be checked manually before publishing.

Turn this Riverside transcript into a content-repurposing plan for short clips, a blog post, a newsletter, and social posts.

Create a producer checklist for remotely controlling a Riverside session with [number] guests.

Use Riverside to record a multilingual interview and produce a workflow for transcription, review, and translated follow-up content.

Upload [approved customer contract] to Robin AI and identify termination, renewal and indemnity clauses with exact document references.

Compare Robin AI's suggested redlines for [NDA] against the original language and mark which require legal counsel approval.

Use Robin AI's Word Add-In to check defined terms in [draft agreement], then review every flagged inconsistency manually.

Ask Robin AI to explain [liability clause] in an authorized contract and verify the explanation against the actual wording.

Draft an alternative [confidentiality clause] in Robin AI's Word Add-In using [approved company position], subject to lawyer review.

Use Robin AI's document library search to locate [service agreements with a specified renewal condition] within the authorized access group.

Research [legal issue in specified jurisdiction] with Robin AI and verify all cited legal authorities for date and applicability.

Prepare a Robin AI table of [contract obligations and notice dates] from authorized documents, linking every entry to a source clause.

Audit [Robin AI legal review workflow] for document privilege, sharing permissions, playbook scope, incorrect citations and final human legal sign-off.

Build a Robocorp Python task to read [synthetic CSV file] and validate missing fields without accessing production records.

Use a conda.yaml file with RCC to pin dependencies for [approved Robocorp worker] and test reproducible environment setup.

Run [sample Robocorp robot] locally and inspect task output and exception handling before deploying anywhere.

Create a Robocorp Control Room process for [non-sensitive scheduled report] with an authorized worker and review schedule.

Use Robocorp work items to pass [synthetic invoice payload] from a producer task to a consumer task safely.

Design a Robocorp Control Room credential-handling plan for [approved integration], avoiding secrets in scripts or log messages.

Diagnose a failed Robocorp worker run for [test automation] using available Control Room execution logs and RCC environment checks.

Add controlled retries and idempotency keys to [Robocorp API integration] to prevent duplicate updates after network failures.

Audit a Robocorp automation for least-privilege credentials, worker permissions, task replay safety, PII minimization and rollback.

Compare public-company trading multiples for [approved peer set] in Rogo and check underlying dates, currencies and source data.

Prepare a Rogo briefing on [target industry] using authorized market materials, distinguishing sourced facts from assumptions.

Identify precedent transactions relevant to [defined sector] in Rogo and verify deal dates, values and comparability.

Review [authorized financial model] in Rogo for missing assumptions and inconsistent definitions without changing the model.

Use Rogo to outline a diligence question list for [potential acquisition] based on approved documents and open information gaps.

Create a Rogo synthesis of [approved earnings materials] with cited revenue drivers, risks and management commentary.

Compare [two internal deal notes] in Rogo and identify conflicting claims that require analyst verification.

Design a Rogo research workflow for [new financing opportunity] with source permissions, analyst approval and change tracking.

Audit [Rogo financial research deliverable] for unsupported projections, stale data, improper document access and investment-decision sign-off.

Upload [authorized performance video] to Rokoko Create's Vision 3 workflow and inspect the AI motion solve for foot sliding and missing limb poses.

Use Rokoko Studio to clean a Vision motion capture of [turning action], smoothing jitter without removing the intentional pause.

Retarget a Vision capture from [performer] onto [licensed humanoid character] in Rokoko Studio, checking skeleton orientation and contact points.

Export a cleaned Rokoko Vision performance as FBX for [Blender project] and verify scale, frame timing and animation continuity on import.

Compare video-to-motion and text-to-motion in Rokoko Create for [basic action], evaluating where each method requires manual editing.

Prepare two contrasting recordings for Rokoko Vision—[front angle] and [oblique angle]—and compare occlusion and tracking quality.

Build an animation handoff from Rokoko Create to [Unity or Unreal scene], documenting rig mapping, FBX or BVH export and license requirements.

Review a Rokoko Studio motion loop from [running clip] for foot contact, hip movement, repeat seams and unintended ground penetration.

Design a Rokoko Vision capture checklist for [indie animation team] covering consent, full-body framing, stable lighting, processing limits and QC.

Compare minimalist and traditional furnishings for [same living room].

Apply a warmer color palette to [authorized room photograph].

Visualize an affordable workspace setup using [existing office layout].

Keep windows and door positions fixed when restyling [source room].

Generate three interior directions for [approved room image].

Review outputs for impossible walls, distorted furniture, or bad shadows.

Prepare a before/after concept labelled as AI visualization.

Compare proposed furniture placement with actual dimensions.

List changes requiring manual designer or contractor verification.

Convert a meeting note to tasks with named owners.

Prioritize [weekly backlog] by realistic deadlines.

Reserve focus time for [high-priority deliverable].

Review conflicts across [connected calendars].

Link [task] to its related notes.

Compare planned and actual time for [project].

Reschedule unfinished tasks without losing due dates.

Create a daily review of completed and postponed work.

Check connected calendar and note permissions.

Image-to-video: animate the uploaded portrait with a subtle camera push-in, natural blinking and gentle cloth movement. Preserve identity, clothing and background geometry.

Create a five-second product reveal of [product] rotating on a clean pedestal; locked camera, soft moving highlight, realistic contact shadow and no lettering.

Workflow: Remove the background from [clip] and composite the subject into [scene]. Check edge quality, perspective, color temperature and contact shadows frame by frame.

Storyboard three connected shots for [brand]: environment, close-up [product detail], clean hero ending. Maintain subject identity, consistent lighting and explicit camera moves.

Animate [owned still image] into a subtle six-second shot with moving light and natural depth, avoiding warped objects.

Inpaint [unwanted sign] from [authorized footage] while preserving consistent background texture across frames.

Design a motion-tracking composite for [moving package] with correct perspective and no alteration to printed labels.

Compare [two video generation variations] for continuity in subject identity, limb movement and camera direction.

Create a short visual-effects cleanup checklist for [AI-generated clip] covering flicker, shape drift and rights to source material.

Use [authorized portrait image] to generate subtle subject blinking and a fixed camera, maintaining the original composition.

Make [owned landscape image] into a ten-second shot with slow cloud movement and gentle forward camera motion.

Compare two image-to-video motion prompts for [same source image], changing only camera movement to evaluate stability.

Create an establishing shot of [fictional town square] from a high-quality reference still with a slow panoramic move.

Generate a cinematic [mechanical object] clip with one continuous action and a clear start and end pose.

Develop three sequential clip briefs for [original scene], each focused on a single action rather than many transformations.

Test [image prompt] for a Gen-4 still using subject, composition, lighting, and color, favoring positive descriptive phrasing.

Review [generated five-second clip] for subject drift, flicker, altered branding, and artifacts before selecting a take.

Prepare an export and editing handoff for [approved Gen-4 footage] covering clip duration, framing, rights, and continuity.

Write a Rushchat original character concept for [adult fantasy ranger] with a concise backstory, distinctive voice and one unresolved conflict.

Start a Rushchat roleplay in [haunted mansion] with three investigable clues and let the player decide where to search first.

Continue a Rushchat character conversation using [past scene facts] and test whether it remembers previously established names and choices.

Request a Rushchat in-conversation image of [fictional landscape] that matches the story's weather, mood and location descriptions.

Test Rushchat voice messages with a [fictional storyteller] by asking for a short narration with clear pauses and consistent characterization.

Create a Rushchat rival-to-ally dialogue between two consenting adult fictional characters where trust develops through believable decisions.

Run a Rushchat interactive mystery in [small town] with an explicit rule that clues cannot change after the player discovers them.

Compare two Rushchat community personas in the [horror] genre for opening specificity, speaking style and narrative coherence.

Review a Rushchat character scenario [draft] for inconsistent character ages, unclear boundaries, repeated filler and missing plot stakes.

Check sample rate and noise levels in [authorized training clips].

Prepare a dataset split for [approved voice model].

Compare two pitch extraction options on [licensed dialogue].

Evaluate conversion quality on [unseen speech sample].

Review converted audio for metallic artifacts and dropped syllables.

Document GPU, software, and model version for reproduction.

Prepare a real-time conversion test with permission checks.

Compare original and converted prosody without claiming identity.

Verify speaker consent and usage rights before distributing output.

Create five distinct short social captions from [verified feature list] without repeating the same opening.

Write a product description for [SKU] using only the supplied material, dimensions and use cases.

Rewrite [generic blog opening] into a useful answer to [specific reader question].

Compare friendly and formal variants of [customer reply] while keeping delivery dates unchanged.

Create a multilingual landing-page headline in [target language] and flag idioms needing native review.

Plan a short series of [industry tip posts] with one practical example per post.

Improve [sales email draft] by removing pressure, invented urgency and unsupported testimonials.

Prepare a style guide for [company voice] with examples of preferred and forbidden expressions.

Check [AI-generated article] for repeated paragraphs, wrong product details and claims lacking sources.

Prepare action instructions for [authenticated order lookup] using required inputs, read permissions, and missing-record handling.

Create a human approval requirement before [Agentforce agent] updates an opportunity or customer record.

Test [customer request] for ambiguous intent and confirm the agent asks for clarification rather than guessing.

Design a knowledge-grounded answer for [billing policy question] that cites the authorized Salesforce source.

Review [Agentforce action definition] for excessive permissions, sensitive field exposure, and unintended side effects.

Build an evaluation set for [new Agentforce subagent] including valid, invalid, and out-of-scope requests.

Investigate [incorrect agent response] using recorded action calls, instructions, and source evidence.

Compare [two subagent instruction variants] for correct routing and unnecessary action invocation.

Prepare a release checklist for [Agentforce workflow] covering sandbox tests, assigned roles, human review, and rollback.

Compare conversion rates across [lead-score ranges] with consistent cohorts and a clearly defined reporting period.

Prioritize [open opportunities] using Einstein Opportunity Scores together with verified deal stages and deadlines.

Inspect the factors behind [opportunity score] and distinguish model indications from confirmed buyer intent.

Draft an Einstein-assisted sales email to [authorized contact] based only on documented CRM notes and the approved offer.

Review [AI-generated follow-up email] for outdated pricing, invented customer challenges, and inaccurate personal details.

Compare [pipeline forecast] against observed closed-won results and document any model limitations.

Create an administrative checklist for enabling [Einstein scoring feature], including eligibility, field quality, and permission sets.

Review [captured sales activities] for mismatched contacts or private data before allowing CRM updates.

Audit [Einstein-generated account insight] against the underlying CRM records and mark uncertain conclusions for human review.

Draft a first-touch email about [confirmed product benefit] based only on [authorized account research].

Prepare call questions for [scheduled customer conversation] using the actual opportunity stage and prior notes.

Summarize [consented call transcript] with key objections, agreed actions, and evidence-linked follow-up details.

Review [Conversation Intelligence insights] for missed questions and unverified interpretations of buyer intent.

Identify [stalled opportunities] with no recent activity and propose human-reviewed next actions.

Compare [two cadences] using consistent sent, replied, and meeting-held metrics over the same date range.

Create a coaching checklist from [recorded sales call] focused on discovery, listening, and factual accuracy.

Audit [CRM synchronization] for mismatched owners, repeated activities, and contact identity errors.

Review [AI-generated Salesloft follow-up] for confidentiality, incorrect pricing, and recipient-specific assumptions.

Train SaneBox by moving [important contact's message] from SaneLater to Inbox, then check how similar mail is classified.

Move [unwanted recurring sender] to SaneBlackHole in SaneBox and review the effect before automatic disposal.

Organize [non-urgent newsletters] with SaneNews while keeping priority customer correspondence in Inbox.

Use SaneBox SaneNoReplies to find [outbound messages awaiting a response] and prioritize genuine follow-ups.

Create a SaneBox reminder for [important sent message] if no reply arrives within [chosen business-day window].

Snooze [non-urgent message] in SaneBox until [defined workday] and verify that the message returns on schedule.

Set up SaneBox training for [monthly billing messages] using a custom folder, and verify newly classified examples.

Review SaneBox Digest for [past week's low-priority messages] before archiving or deleting any email.

Audit SaneBox's account permissions, sensitive sender handling, training rules, mail access and recovery options before enabling broad filters.

Summarize [verified supplier details] without invented terms.

Check status of [approved procurement request].

Explain a [finance report] with its period and currency.

Draft a job description from [approved role criteria].

Find guidance for [documented SAP workflow step].

Identify missing fields in [service request].

Compare [inventory reports] using confirmed measures.

Check permissions before using restricted records.

Verify generated summaries against actual system data.

Test Sapling autocomplete on [non-sensitive partial support message] and verify that suggested wording does not invent actions taken.

Create a reusable Sapling snippet for [approved customer support procedure] with clearly marked variable fields.

Apply Sapling rephrase tools to [owned customer email] in a more empathetic tone while preserving factual claims.

Review Sapling writing corrections in [CRM ticket] for accuracy, company terminology and an appropriate professional tone.

Compare Sapling autocomplete suggestions on [two similar customer cases] and reject irrelevant or misleading completions.

Use the documented Sapling API to check grammar on [synthetic support text] without exposing API keys in browser code.

Test a Sapling style-guide rule for [approved product name] and inspect whether it flags disallowed alternatives.

Measure Sapling corrections across [small approved support dataset] for false positives, missing errors and human acceptance.

Audit a Sapling integration for privacy, consent, support-agent approvals, credential security and hallucinated commitments.

Plan a human-in-the-loop labeling workflow for [camera images], specifying machine prelabels, expert review, escalation of ambiguous cases and final acceptance checks.

Build a Scale AI evaluation set for [LLM support assistant] that measures factual grounding, refusal behavior, instruction following and consistency across languages.

Design a preference-data collection task for [two model outputs], using explicit ranking criteria and checks for annotator bias and low-quality comparisons.

Prepare a red-team test suite for [enterprise chatbot] targeting prompt injection, unauthorized data access, misleading citations and unsafe tool actions.

Draft a Scale data-curation plan to prioritize [model failure categories] instead of labeling more examples from already well-covered cases.

Specify a 3D sensor-fusion annotation job for [LiDAR plus camera captures] that records calibration version, object categories and difficult occlusions.

Reconcile label-quality metrics for [dataset batch], separating individual annotation errors from dataset-level coverage gaps and reviewer disagreements.

Design a batch handoff from [existing ML pipeline] into Scale's annotation workflow and back, preserving stable IDs and labeling provenance.

Create an evaluation report from [model experiment] that tracks benchmark changes after relabeling, with uncertainty ranges and a rollback criterion.

Create an SEO content brief for [buyer query] with verified sources, distinct subquestions and reader outcomes.

Compare [existing article] with [current search results] for missing information without copying competitor phrasing.

Draft a factual introduction to [technical topic] that answers the query before discussing background.

Prepare an on-page optimization plan for [category page] while preserving its intended transactional focus.

Review [AI-generated SEO article] for fabricated statistics, generic filler and mismatched search intent.

Design an internal linking plan between [hub, comparison and product pages] using descriptive anchor text.

Build a content-refresh schedule for [older guide] prioritizing changed product capabilities and stale links.

Compare [two title/meta candidates] for specificity and promise fulfillment rather than estimated clickbait appeal.

Create an editorial quality checklist for [Scalenut-assisted content batch] including sources, uniqueness and measurable QA.

Train a custom art style only on [licensed references].

Maintain a consistent character silhouette across [asset variations].

Compare two image-to-image refinements of [owned concept sketch].

Create a game background with [specified color and lighting].

Refine [generated character] without changing approved costume elements.

Check output sprites for inconsistent details and shape drift.

Prepare an asset sheet showing [four approved variants].

Record prompts, model version, and accepted output for reproduction.

Audit [game asset] for licensing and export resolution.

Use ScholarAI's research search to compare [three findings] across peer-reviewed papers, clearly separating direct evidence from speculative interpretations.

Import [authorized Zotero collection] into the ScholarAI-powered Jenni research workspace and verify citation keys, PDF attachments and source metadata.

Ask Jenni, using ScholarAI-powered paper search, to draft an outline on [topic] with each claim tied to a verified paper rather than invented references.

Compare the methods and limitations of [two uploaded research PDFs] using source-linked notes and accurate page citations.

Find contradictory studies about [scientific claim] with ScholarAI, recording differences in sample, intervention and outcome measures.

Create a citation-backed literature gap analysis for [research topic] and list unanswered questions instead of implying absence of research without checking.

Prepare a ScholarAI API integration outline for [authorized research application] that retrieves paper metadata and enforces citation provenance and rate limits.

Review AI-generated in-text citations in Jenni from [draft paragraph] against the actual ScholarAI-linked source documents for unsupported statements.

Build a reproducible evidence brief from [paper collection], including search terms, inclusion dates, main findings, unresolved disagreements and human-review items.

Extract sample size, study design and limitations from [research PDF] for manual verification.

Compare summaries of [two intervention studies] without treating different outcomes as equivalent.

Build an annotated reference list from [selected source documents] with accurate publication metadata.

Identify unfamiliar scientific terms in [paper] and add definitions supported by its context.

Create a concise literature overview from [five source papers], noting contradictory findings.

Check [generated paper summary] against the abstract and results for omitted caveats.

Review extracted references from [PDF] for missing DOIs, names and duplicate entries.

Prepare a ten-question study quiz from [provided course reading] with source-linked answers.

Audit [Scholarcy flashcards] for unsupported causal claims and inaccurate numerical results.

Configure Dot in a SchoolAI Space to guide learners through [math concept] using hints rather than giving the answer.

Design a SchoolAI exit-ticket Space where students explain [lesson concept] and identify what they still need to practice.

Remix an existing SchoolAI Space for [curriculum standard] after checking its instructions against local teaching requirements.

Invite [approved class] to a SchoolAI Space by code or supported classroom integration following school privacy rules.

Review SchoolAI Mission Control during [class practice] and identify learners who may need teacher intervention.

Build a SchoolAI role-play Space for [history topic] with clear fictional framing and fact-checking checkpoints.

Create differentiated questions in a SchoolAI Space for [reading passage] with three levels of support and one goal.

Review [student work] in an approved SchoolAI Space and create coaching prompts without sharing another student's data.

Audit SchoolAI Space instructions for student privacy, teacher oversight, bias, age suitability and unsupported claims.

Use R2R's REST API to ingest [versioned technical documents], record document IDs and preserve provenance for later updates.

Create a citation-grounded R2R retrieval-augmented answer for [product manual question], refusing to invent a response if the relevant text is absent.

Set up R2R hybrid search for [internal knowledge base] and evaluate how fusion ranking handles acronyms, product names and exact error codes.

Design a SciPhi R2R knowledge-graph experiment for [technical support corpus], checking extracted entities and relationships against source documents.

Configure collection-level permissions in R2R for [two departments] and test that cross-department document retrieval is appropriately blocked.

Compare R2R deep-research output on [complex product question] with a straightforward RAG request, checking evidence, latency and unsupported inferences.

Prepare an R2R ingestion QA workflow for [multimodal document set] with format-specific parsing checks and a failure report for unreadable files.

Test an R2R retrieval endpoint with [ambiguous policy question] and inspect returned chunks, reranking behavior and citation completeness.

Document an R2R production-readiness checklist for [application] covering API authentication, backups, observability, versioning and retrieval regression tests.

Extract methods and limitations from [research PDF] with citations.

Compare [study A] and [study B] on population and outcomes.

Find papers addressing [specific research question].

Build a summary table of verified findings from [five papers].

Ask for the definition of [technical term] in the paper's context.

Identify which claims in [literature summary] lack citations.

Create research questions from gaps in [current article set].

Review generated references for incorrect titles and authors.

Audit the paper explanation against the source before quoting it.

Compare citation contexts for [paper A] and [paper B] rather than relying on raw citation counts.

Identify papers discussing limitations of [study] and record the stated methodological concern.

Prepare a bibliography of [research topic] with a clear reason each article was included.

Use Smart Citations for [frequently cited review] to identify how later authors interpret its findings.

Search for [method or outcome] across research articles and separate primary studies from commentary.

Create a study-screening checklist from [selected papers] with years, populations and designs.

Review [AI research answer] against underlying references and flag claims with no direct support.

Find newer studies that test [earlier reported result] and summarize how their methods differ.

Audit [citation-based summary] for publication bias, withdrawn papers and overgeneralized conclusions.

Compare two SeaArt checkpoints on [the same approved fictional character brief], holding seed, sampling and dimensions constant.

Apply a SeaArt LoRA to [original character scene] at two strengths and evaluate unwanted style drift.

Use SeaArt image-to-image on [owned sketch] to explore three finished styles while protecting key layout features.

Guide [owned pose reference] with SeaArt ControlNet and check whether hand and body proportions remain plausible.

Recreate [original logo-free background] in SeaArt using ControlNet edge guidance and compare constraint strength.

Use SeaArt's inpainting tool to repair [artifact in owned picture] without changing nearby identifiable details.

Compare SeaArt Prompt Magic enabled and disabled for [same approved prompt] to track visual changes and added elements.

Create an image-generation workflow in SeaArt for [approved product mockup] and verify source image rights and export resolution.

Audit [SeaArt output] for training/source permissions, unintended copyrighted marks, sensitive content, model license and misleading realism.

Use Seek AI's Semantic Parsing Agent to generate SQL for [customer retention question] and inspect table joins, date filters and aggregation logic.

Compare a Seek AI natural-language query result with [analyst-written SQL] on an identical warehouse snapshot to identify differences.

Build a Seek AI Insights Catalog entry for [verified business KPI] with a plain-language definition, query provenance and owner.

Create a Seek AI dashboard question set for [online retailer] covering average order value, returns and conversion rates using consistent denominators.

Evaluate a Seek Native App deployment within [authorized Snowflake account] for data access, permissions and human review of generated SQL.

Use Seek AI's Explanation Agent to summarize [sales anomaly] but separate actual data patterns from hypotheses requiring investigation.

Test Seek AI's embedded analyst on [ambiguous pricing question] and ensure it asks for currency, date range and customer segment where needed.

Prepare a Seek AI query-evaluation suite for [finance warehouse] with known-answer examples, invalid join cases and confidential-table restrictions.

Audit Seek AI analytics results for [business report] by verifying generated SQL, source freshness, record filters and the approval history.

Compare candidate skills to [verified role competencies].

Identify missing evidence for [required certification] in a profile.

Create an outreach draft with truthful job and location details.

Review a talent market report for sample and geographic limitations.

Prepare a shortlist using consistent, job-relevant criteria.

Check candidate data access and applicable privacy permissions.

Identify potential duplicates in [authorized candidate pool].

Review sourcing criteria for unfair or irrelevant exclusions.

Prepare an accountable human review checklist before contacting candidates.

Define typed function inputs and outputs for [business tool].

Use automatic function calling with explicit authorization limits.

Design a Python kernel workflow for [source-grounded questions].

Prepare a test for [invalid plugin parameters] and error handling.

Compare connector choices for [approved model backend].

Trace a failed tool invocation to its arguments and result.

Limit access to [confidential documents] by authorized role.

Create regression tests for [kernel orchestration workflow].

Document language, dependency, and deployment constraints for [SDK app].

Compare citation networks of [two foundational studies] without equating citations with quality.

Use available paper summaries to shortlist relevant sources, then confirm claims in their full texts.

Locate [researcher's recent publications] and distinguish coauthors with similar names.

Create a reading list for [topic] ordered by relevance, methodology and publication date.

Identify recent papers citing [landmark article] and flag conflicting findings.

Review [paper metadata] for retraction notices, duplicates and missing full-text access.

Prepare an evidence table for [five studies] with populations, outcome measures and limitations.

Track new results for [saved research topic] and assess whether they change earlier conclusions.

Audit [AI-generated literature summary] for invented citations and unsupported generalizations.

Extract task owners from [recorded discussion] without guessing.

Compare [two meeting notes] for contradictory action dates.

Review transcript accuracy for speakers and technical terms.

Build a follow-up message using confirmed meeting decisions.

Group unresolved questions by owning team.

Create a weekly digest from authorized meeting recordings.

Mark sensitive items requiring restricted access.

Audit an AI meeting summary for invented commitments.

Prepare a task checklist from the verified meeting transcript.

Compare [target keyword] with five related phrases by difficulty, volume and SERP characteristics.

Audit [landing page] for title relevance, missing headers and unsupported optimization suggestions.

Build a topic cluster around [verified business question] without duplicating existing pages.

Review competitor [organic landing pages] to find coverage gaps, not merely keyword counts.

Prepare a technical SEO checklist for [Shopify collection] using observed crawl evidence.

Create an SEO content brief for [product comparison query] with differentiating decision criteria.

Prioritize [ten existing URLs] based on search visibility, CTR and editorial importance.

Evaluate [AI-generated article outline] for keyword stuffing, questionable facts and search-intent mismatch.

Define a 28-day follow-up for [revised page] separating indexing lag from content performance.

Create an SEO brief from [verified category question].

Group [keyword list] into non-overlapping topic clusters.

Compare competing articles for missing factual subtopics.

Draft an FAQ using [approved vendor evidence].

Improve [thin software guide] with practical decision criteria.

Check [AI-generated article] for unsupported pricing claims.

Map internal links between [relevant existing pages].

Remove unnatural keyword repetition from [draft].

Define post-update measurement using GSC impressions and CTR.

Create a handoff briefing for [escalated incident] showing impact, attempted fixes, unresolved questions, and the assigned team.

Compare the Now Assist summary of [incident] with original task activity and correct missing timelines or technical details.

Draft a knowledge article from [confirmed resolved ticket] with symptoms, reproducible checks, verified fix, and scope limitations.

Search [approved knowledge base] for evidence relevant to [user issue] and cite the source article before proposing next steps.

Generate resolution notes for [completed incident] using only documented actions and the actual closure reason.

Identify missing information in [service request] that the human agent should obtain before using automation.

Review [Now Assist-generated code suggestion] against the instance's scoped application rules and security policy before execution.

Prepare a virtual-agent question flow for [standard IT request] with clear eligibility checks and human escalation.

Audit [generated ServiceNow response] for unauthorized data, unsupported workarounds, and inaccurate assignment recommendations.

Compare [HubSpot list-wide send time] with Seventh Sense per-recipient scheduling on the same approved segment.

Configure a Seventh Sense/HubSpot test for [newsletter series] with control cohort, success metric and suppression rules.

Inspect Seventh Sense engagement insights for [inactive audience cohort] and design a frequency-reduction experiment.

Review email engagement differences by inbox provider in Seventh Sense for [campaign] without confusing delivery with inbox placement.

Use Seventh Sense analytics to identify [over-messaged subscribers] and reduce avoidable contact frequency.

Plan Seventh Sense send-time optimization for [Marketo smart-list campaign] using supported integration and permissions.

Compare [two consented segments] in Seventh Sense for response timing, actual actions and sustained engagement rather than opens alone.

Set up a Seventh Sense experiment for [lifecycle sequence] that avoids sending at inappropriate local hours.

Audit a Seventh Sense workflow for opt-outs, email frequency, HubSpot or Marketo synchronization, causal measurement and privacy.

Draft a reply to [customer request] using only verified account context.

Search [mailbox] for messages about [project deadline] and show source links.

Prepare a short follow-up from [meeting invitation thread] with confirmed action owner.

Organize [inbox messages] by urgency without archiving or deleting anything.

Compare [two email threads] for conflicting commitments and dates.

Rewrite [draft email] for clarity while preserving the sender's intended meaning.

Create a reminder plan for [unanswered priority messages] using specified due dates.

Review [AI-drafted email] for hallucinated commitments and recipient errors.

Audit [shared email summary] for confidential details before sending it externally.

Create a Sierra AI agent flow for [verified order-status inquiry] that requires suitable customer authentication before revealing details.

Configure Sierra's brand tone for [approved business] and test how the agent responds to confusing customer requests.

Design a Sierra multichannel support journey across [web chat and SMS] with consistent account verification and consent.

Draft Sierra agent safeguards for [refund request] including limits, policy citations and mandatory human approval for exceptions.

Test Sierra's answer quality on [twenty historical anonymized support questions] with expected factual references.

Plan an agent handoff in Sierra when [customer expresses dissatisfaction or unresolved billing issue], preserving the case history.

Review Sierra Ghostwriter change suggestions for [updated support SOP] and validate them in staging before applying them.

Measure a Sierra pilot on [approved service queue] using verified successful resolutions, escalation outcomes and customer satisfaction.

Audit [Sierra autonomous support agent] for channel consent, hallucinated policy, sensitive-data access, abuse prevention and rollback.

Summarize this Silkwave Voice meeting [recording] into decisions, unresolved questions and action items without inventing owners or due dates.

Use Silkwave Video on [YouTube research video URL] to obtain a searchable transcript and find the segments discussing [topic].

Ask Silkwave Video to summarize [tutorial video] while preserving exact timestamps for steps that need manual verification.

Compare two approved AI models inside Silkwave Chat for [coding question], using the same input and evaluating accuracy, source use and response length.

Configure Silkwave Chat with [my own authorized API key] and a local Ollama model, keeping keys out of shared notes and deciding when offline processing is preferable.

Use Silkwave Clarity during [noisy Mac audio playback] to improve voice intelligibility, then compare processed and unprocessed audio for artifacts.

Prepare a Silkwave Voice transcription test for [two-language interview], recording language coverage, speaker-label errors and time alignment.

Create a Silkwave Video review of [lecture recording on YouTube], extracting definitions and questions while checking them against the original audio.

Design a privacy-conscious Silkwave workflow for [confidential meeting], distinguishing on-device transcription from any cloud model used for summaries.

Convert [long blog summary] into a short social caption series with accurate quotations and varied openings.

Create a 15-second video storyboard for [feature announcement] with real product screenshots and readable subtitles.

Prepare reusable social templates for [campaign] with consistent fonts and locked brand mark placement.

Remove the background from [owned product photo] while preserving its authentic labels and proportions.

Write a simple weekly social scheduling plan using [approved content pillars] and real publication dates.

Generate an original background illustration for [educational carousel] with enough space for final typography.

Coordinate [design and copy review] in a shared workspace with clear feedback and approval ownership.

Compare [three marketing asset variants] for mobile readability, factual accuracy and branding.

Audit [Simplified export batch] for file format, copyright, accessible contrast and correctly linked destinations.

Assign [content planning task] to the appropriate Sintra helper and provide verified audience and brand context.

Ask a Sintra helper to draft [social post] using approved product facts and a defined tone.

Create a repeatable Sintra research brief for [competitor category] and require sources for every factual finding.

Compare two Sintra helper drafts for [marketing task] and identify repetition, inaccurate claims and missing detail.

Prepare a sales follow-up draft in Sintra based on [verified inquiry] without sending it automatically.

Review Sintra helper integrations for [connected workspace] and limit access to necessary accounts.

Plan a Sintra weekly content workflow with owner review before scheduling or publication.

Check whether Brain AI context used by [two helpers] stays consistent when business information changes.

Audit a Sintra workflow for customer-data minimization, invented metrics, unapproved messages and costly automated actions.

Create three variations of this sketch with [mood] lighting and a [style] visual direction.

Use this imported photo as the starting point and reinterpret it as [style] while preserving [important element].

Transform this rough product sketch into a clean concept image for [audience/use case].

Generate a [style] background from this sketch using [palette] and [mood].

Keep the subject from my sketch but change the environment to [setting] and the time of day to [time].

Create a social-media-ready illustration from this sketch with clear focal hierarchy and space for [text/logo].

Turn this character sketch into a refined [genre] concept while preserving the pose and key identifying details.

Generate three color and lighting treatments from [original character sketch], preserving its costume and silhouette.

Review [generated sketch variations] for stray lines, inconsistent proportions and export artifacts.

Use Skyvern's browser automation to read [authorized order portal] and export a synthetic test order summary without editing production data.

Create a multi-step Skyvern workflow for [approved invoice-download process] and document what should happen when a portal layout changes.

Build a reusable Skyvern workflow with parameters for [permitted search term and target date range] and test it on a staging website.

Run an authorized Skyvern form-fill test on [sandbox application] and stop before submitting any irreversible data.