Best AI prompts.

Workflow: Translate [reference layout] into an original WordPress page structure without copying protected text or logos; define nav, hero, service cards and mobile breakpoints.

Workflow: Use Elementor-based editor to assemble [service] landing page with approved benefits and contact form; check submission confirmation, responsive spacing and keyboard focus.

Workflow: Benchmark [page] before and after one PageSpeed Booster setting change. Record LCP/CLS/FCP and label field vs lab measurements correctly.

Workflow: Before migrating [WordPress site], export backup, inventory plugins and redirects; validate staging content, navigation and forms before switching DNS.

Create a local-business homepage from [verified service facts], including geography, proof points and an accessible inquiry form.

Define a staging migration test for [existing WordPress pages] that checks internal links, canonicals, redirects and media assets.

Audit [Elementor page] for heavy image downloads, layout shifts and unnecessary above-the-fold animation.

Create a content handoff for [WordPress redesign] that preserves approved URL slugs and accurate schema eligibility.

Test a contact-form conversion path from [mobile landing page], including validation, successful delivery and an accessible confirmation.

Interview [founder] about [launch], then turn verified answers into a distinctive first-person LinkedIn post.

Review a [company profile] draft for unsupported claims, wrong voice and missing context before publishing.

Interview [founder] about [specific hard-earned lesson], requesting a concrete example and verifiable outcome.

Turn [approved research article] into a six-panel LinkedIn carousel with one sourced finding per panel.

Rewrite [draft LinkedIn post] to open with a reader problem rather than an unsubstantiated personal achievement.

Create a personal-profile post and a company-page post from [announcement] while keeping their voices distinct.

Prepare an interview outline to surface original examples about [customer problem] without leading the speaker.

Compare three carousel hooks for factual specificity and value to [professional audience].

Audit [scheduled LinkedIn content] for fabricated statistics, attribution gaps and unsupported business results.

Turn [video passage] into a 9:16 clip using face tracking and captions; verify crop and transcript accuracy.

Compare two caption styles for [short video] for legibility, timing and brand consistency.

Find three highlight candidates in [authorized long interview] based on complete and accurate context.

Create vertical short-video cuts from [webinar footage] with clean starts, endings and captions.

Review [automatically selected clips] for misleading edits and omitted qualifying statements.

Design brand styling for [clip series] with subtitle safe zones and consistent identity.

Prepare a repurposing workflow from [one-hour podcast] into topical shorts with approval gates.

Compare [two short clip selections] for clarity, self-contained meaning and pacing.

Export [approved short video] in vertical format and verify subtitles, audio and visible speaker framing.

Workflow: Generate a base [fantasy character] from [text brief], review mesh density and UV textures, and compare FBX and GLB output in the destination viewer.

Workflow: Create three facial or costume variants of [avatar] while preserving skeleton proportions; check materials, poly budget and animation compatibility.

Create an original [fantasy explorer] avatar from [authorized concept art], keeping costume proportions consistent.

Inspect [auto-rigged character] for shoulder and knee deformation during a basic animation test.

Compare FBX and GLB exports of [avatar] for material fidelity, scale and skeleton compatibility.

Design a text-to-texture brief for [fictional robot avatar] with consistent surface details.

Prepare a VRChat optimization pass for [avatar mesh] balancing polygon count and expression quality.

Create three costume variants for [character] without changing the underlying rig and joint positions.

Build an avatar export checklist covering textures, ownership rights and viewer-specific validation.

Workflow: Turn [product sketch/specification] into a textured mesh; check UV seams, PBR maps and missing surfaces, then list manual fixes.

Make three dimensionally consistent variations of [game asset], comparing texture quality, polygon count and suitability for reuse.

Generate a hard-surface 3D asset brief for [industrial storage crate] with target dimensions and visual style.

Compare [two text-to-3D mesh outputs] on topology, silhouette fidelity and UV layout.

Prepare PBR material guidance for [game-ready metal prop] with roughness and normal-map checks.

Create a batch specification for [20 furniture variants] with naming, scale and file format requirements.

Inspect [generated GLB] for incorrect normals, intersections and overly dense geometry.

Design a low-poly optimization pass for [background props] while preserving important silhouette features.

Prepare a delivery QA sheet for [3D marketplace assets] covering UVs, textures, licensing and orientation.

Use my [journal entries] to notice recurring situations that increase rumination; show patterns as possibilities, and suggest questions I can discuss with a professional if needed.

Guide a short journaling check-in: what is within my control today, what I can postpone, and one small action that supports my routine. Avoid clinical claims.

Summarize [voice journal entry] into main concerns, triggering situations and questions worth reflecting on.

Identify unhelpful all-or-nothing statements in [personal notes] and suggest alternative balanced interpretations.

Create a short reflection routine for [stressful workday] without interpreting it as a diagnosis.

Compare [mood journal entries] for recurring situations and acknowledge gaps in the recorded data.

Help me separate what I can control from what I cannot in [current challenge].

Turn [repeated anxious thought] into questions about evidence, alternative explanations and next steps.

Create a weekly journaling review that highlights progress and uncertainty without clinical claims.

Compare account-stage movement for [ABM cohort] between [two periods]; explain how changes to the account universe affect the interpretation.

Workflow: Coordinate a targeted [industry] outreach play across marketing and sales using confirmed account interests; define owners, suppression rules and success measures.

Prioritize [B2B target accounts] using verified fit and observed research-intent signals, marking confidence levels.

Compare [account engagement] across two periods while controlling for changes in tracked account coverage.

Plan a coordinated sales and marketing outreach for [industry segment] with explicit channel suppression rules.

Build an ABM audience segment from [documented company attributes] without using sensitive inferred traits.

Create a sales briefing on [target account] separating public company facts from predictive intent scores.

Review [pipeline influence report] for attribution limitations and duplicate opportunity assignments.

Define success measures for [pilot account-based campaign] that distinguish meetings booked from attributed revenue.

Model two pricing goals for [retail assortment]—revenue and gross profit—under [inventory constraints]; document trade-offs and margins at risk.

Workflow: Test recommended prices on a limited [store/SKU] cohort, holding out comparable items and monitoring profit, conversion and returns before expansion.

Analyze elasticity for [SKU category] using historic prices, promotions and availability controls.

Compare profit and revenue optimization goals for [assortment] under current inventory limits.

Prepare a markdown scenario for [seasonal goods] with minimum margin and stock clearance constraints.

Review [retailer data feed] for VAT, currency, duplicate SKU and promotional-price inconsistencies.

Build a pilot test around [price recommendation] with matched control products and success criteria.

Investigate [forecast demand spike] by accounting for promotions, stockouts and calendar effects.

Create an approval report for [proposed price updates] showing expected trade-offs and required checks.

Workflow: Define a persistent environment for [data application] with inputs, model selection, audit logs and a rollback path for failed runs.

Compare [two AI model configurations] on [evaluation cases], measuring correctness, cost and failed edge cases rather than relying on fluency alone.

Design a restricted AI research agent to answer [enterprise policy questions] from approved sources.

Create a model comparison for [internal classification task] using documented test records and error rates.

Plan a persistent data-analysis workspace with versioned inputs, environment controls and recovery checkpoints.

Develop a read-only API assistant for [authorized business metrics] with source-linked answers.

Test [agent workflow] when external tools return inconsistent or empty data.

Draft governance requirements for deploying [enterprise chatbot] with data-access and audit boundaries.

Analyze [completed agent run] for unsupported conclusions, excessive cost and missing human sign-off.

Design a photographer checklist for [event]: upload procedure, consent records, access rules, false-match review and retention/deletion process.

Workflow: Verify that [test guest] receives only their consented photos; investigate non-matches and mistaken deliveries before public launch.

Plan opt-in event photo matching for [wedding guests] with consent clearly explained before collection.

Define a secure upload workflow for [photographer image batch] with naming, access and retention controls.

Draft an accurate WhatsApp delivery message for [consenting attendee] explaining access and deletion requests.

Review [face-match results] for false positives and require manual checks before sensitive delivery.

Build a process for guests to withdraw consent and request removal of [event images].

Test [event photo upload] on duplicate filenames, incomplete transfers and unmatched participants.

Prepare an organizer's post-event checklist for photo access, delivery failures and retention closure.

Stream [multimodal sample] into a training pipeline, measure batch decoding errors, throughput and reproducibility using a fixed split.

Compare dataset versions [A] and [B] for relabels, removed samples and duplicates; report possible evaluation leakage.

Design a tensor dataset for [autonomous driving video] that stores frames, labels and temporal metadata.

Stream [large image dataset] into [PyTorch training job] and validate deterministic train/validation splits.

Create dataset versioning rules for [relabeling project] with reproducible revisions and audit trails.

Plan multimodal ingestion of [text-image pairs] with format validation and source permissions.

Benchmark [dataset streaming pipeline] for throughput, GPU starvation and cache effects.

Investigate [broken training run] by comparing dataset version, schema and missing assets.

Document a safe export and retention workflow for [sensitive computer-vision collection].

Workflow: Call [authorized API] with mapped inputs and retry only idempotent failures; log status code without exposing secrets.

Inspect failed runs from [workflow] to isolate the first broken step, then replay one synthetic record and verify downstream state.

Build a webhook-to-spreadsheet flow for [lead form] that validates required fields and unique IDs.

Create a scheduled sync from [approved API] to [internal table] with incremental updates and failure logging.

Add a branching rule to [invoice workflow] when tax ID or purchase-order number is missing.

Test an HTTP step against [rate limiting and timeout errors] with bounded retries.

Prepare a Docker self-hosting checklist for [team workflows] including secrets and backups.

Review [execution logs] to find duplicate notifications triggered by repeated incoming events.

Insert human approval before [automation] sends outbound emails or modifies CRM records.

Workflow: Map [top five support intents] to authenticated account actions, validating identity before exposing or changing customer data.

Evaluate [multilingual bot] with ambiguous and adversarial questions; log unsupported answers, failed handoffs and resolution outcomes.

Design an authenticated order-status bot flow that uses [approved customer records] and cited policy.

Build a human escalation step for [refund complaint] when the request exceeds the permitted policy.

Test customer-service responses to [multilingual billing questions] for consistent meaning and respectful tone.

Create knowledge-base coverage for [shipping exceptions] with version dates and approved commitments.

Investigate [unresolved chatbot sessions] for missing intents and inadequate human handoff.

Define safe account-update actions for [support assistant] requiring verified identity and explicit consent.

Review [customer conversation logs] for sensitive data leakage and misleading certainty before launch.

From [dataset], define a report comparing [monthly metric] by segment; check NULLs, deduplication and currency before visualization.

Workflow: Generate a SQL query for [business question] against the provided schema, explain joins and run a limited read-only validation.

Generate read-only SQL for [monthly revenue] using the supplied schema and explicit date filters.

Reconcile [CRM export] against [billing database] using approved account identifiers and exception reporting.

Design a KPI dashboard for [operations team] with currency, time zone and refresh definitions.

Profile [raw transaction table] for NULL values, duplicate entries and inconsistent categories.

Compare [two reporting periods] and separate genuine metric shifts from changes to the source data.

Review [AI-generated query] for row multiplication, wrong join keys and exposed sensitive fields.

Draft an executive report from [verified dataset] with chart descriptions and unresolved data caveats.

Check [mechanical design] against [part revision history] and list unresolved dimensional or supplier constraints for engineer sign-off.

Workflow: Consolidate duplicate BOM entries for [project] while preserving approved manufacturer part numbers and linked CAD revisions.

Reconcile [released CAD assembly] with [supplier BOM] and flag mismatched revision codes.

Compare the dimensions of [replacement fastener] with the originally specified engineering part.

Find duplicate part numbers across [subassemblies] without merging legitimately different revisions.

Trace [component substitution] through Onshape or Fusion assembly references and released drawings.

Review [engineering change] for affected interfaces, procurement dependencies and sign-off owners.

Create a structured discrepancy report for [gasket revision mismatch] with source links and urgency.

Prepare a purchasing handoff from [validated BOM] that preserves manufacturer IDs and quantities.

Workflow: Generate variants for [campaign] with controlled creative changes; compare predicted creative scores only as hypotheses for live tests.

Plan a creative A/B test holding audience and budget constant while varying [headline or visual]; define success metric and stop criteria.

Create three static ad concepts for [verified product] each focusing on a distinct genuine benefit.

Use [approved brand kit] to produce mobile banner variants with accurate pricing and logo treatments.

Plan a vertical video ad for [product landing page] with approved footage and a single conversion action.

Compare predicted creative rankings with [observed campaign data], treating model scores as hypotheses.

Generate a creative test matrix varying one element at a time across [audience segment].

Audit [bulk-generated visuals] for fake testimonials, wrong packaging and unsupported promotional percentages.

Prepare export and approval checks for [Meta and Google assets], including size and policy compliance.

Workflow: Use background removal on [product photograph], refine edges and place the cutout on a consistent branded template.

Create three text-to-template layouts for [promotion], each with distinct information hierarchy and mobile-safe type; verify all output text manually.

Design a square social graphic for [approved workshop] with verified date, location and call to action.

Generate an original illustration background for [seasonal campaign] leaving room for final typography.

Remove background from [owned product photo] and inspect fine edges around translucent packaging.

Create branded [newsletter header] alternatives following the approved color palette and logo rules.

Adapt [approved promotional graphic] to landscape and story formats without cropping legal text.

Plan a short animated announcement from [approved event copy] with accessible timing and captions.

Review [AI-generated template] for invented slogans, unreadable small text and altered brand marks.

Generative Fill workflow: select the empty area beside [subject] in the uploaded photograph; add [specific object] at matching perspective, scale and light direction. Preserve the person, existing logo and background geometry.

Create seamless repeating [motif] artwork for a [fabric/paper] pattern, restrained palette [three colors], flat vector-like shapes, even spacing, no gradients or text.

Apply Generative Recolor to the selected illustration using [primary, secondary, accent] brand colors. Keep original paths, silhouette and relative contrast intact; compare three palette variants.

Use the provided [style reference] to generate a [campaign] illustration with the same broad color mood and texture but original objects and composition. Keep clear space for overlaid design copy.

Use Generative Expand on [owned landscape image] to extend it to 16:9 while preserving the horizon and natural texture.

Generate a modern editorial illustration of [renewable energy concept] in [approved palette] with original shapes and no lettering.

Apply Generative Fill to replace [unwanted packaging prop] on [product photo], maintaining contact shadows and label accuracy.

Create three typographic texture concepts using [short approved word] and [material aesthetic], checking legibility at small sizes.

Prepare a layered design asset brief for [campaign banner] with a cutout subject, empty headline space and consistent lighting.

Prepare remote interview tracks from [two speakers], checking clipped words, inconsistent loudness and remaining background noise before publishing.

Workflow: Test speech enhancement on [noisy sample], rate intelligibility and artifacts against the raw recording, and retain the original master.

Enhance [recorded lecture] to improve speech intelligibility while retaining natural voice timbre.

Compare [before and after audio] for robotic artifacts, clipped syllables and false noise suppression.

Create a remote interview recording checklist for [two guests] with levels and microphone positioning.

Prepare an editing plan for [long podcast recording] using source-preserving transcript review.

Test [noisy audio sample] with enhancement and document where processing degrades intelligibility.

Deliver [edited episode] in [requested format] with loudness, sample-rate and channel checks.

Audit [batch of enhanced recordings] for consistent level, missing segments and residual background noise.

Use object masking on [subject in clip] and inspect motion edges across frames; refine areas that drift or obscure nearby objects.

Workflow: Build a captions-and-color pass for [interview], checking transcript accuracy, contrast, audio loudness and [platform] export settings.

Assemble a 45-second rough cut from [consented interview] preserving the speaker's full meaning.

Use object masking on [moving subject] and inspect tracking through occlusions and rapid camera movement.

Prepare a generative sound-effect brief for [original fictional scene] with timing and dynamic range constraints.

Plan multicamera switching for [three-person discussion] with reaction shots and synchronized audio.

Compare [AI-generated cut] with [original recording] for misleading omissions and broken continuity.

Create a caption correction pass for [technical tutorial] including timestamps and proper nouns.

Export a campaign video in [9:16 and 16:9] with checked audio loudness and protected title-safe areas.

Identify which Adobe AI capability best fits this marketing objective: [objective].

Design an Adobe workflow that uses AI to automate [repetitive task].

Use Adobe AI to improve this content-production workflow while preserving brand requirements: [workflow].

Explain which Adobe product provides the AI capability needed for [task] and what plan dependencies may apply.

Map [marketing analytics goal] to the relevant Adobe product's current AI capability, noting licenses that require verification.

Outline AI-assisted asset tagging for [approved photo library] with manual correction of misclassified content.

Analyze [marketing conversion report] for data quality and segment differences before recommending personalization.

Design an Adobe creative review process that uses generative tools but preserves brand assets and approval stages.

Compare [Adobe AI feature descriptions] across products to prevent attributing a capability to the wrong application.

Workflow: Review [campaign performance] for falling conversion rate; separate tracking errors from true creative fatigue before changes.

Design a controlled optimization test for [audience or message], documenting baseline CPA, measurement window and rollback thresholds.

Outline campaign objectives for [verified software offer] with geography, audience and budget constraints.

Generate three ad creative angles from [approved feature sheet] without invented customer outcomes.

Compare [campaign segments] using spend, attributed leads and tracking completeness before recommendations.

Design an audience experiment for [professional buyers] that avoids sensitive or unsupported inferred traits.

Create an ad approval process for [new creative batch] checking landing-page claims and brand assets.

Analyze [week-over-week performance] for seasonal effects, budget shifts and measurement errors.

Document safe automation limits for [campaign optimization] before any bid or budget changes.

Draft ad creative for [verified offer] across Google and Meta using platform-specific length and policy constraints.

Audit [campaign results] for spend, conversion tracking and wasted queries before suggesting budget edits.

Analyze [Google Ads search terms] for [product] and identify irrelevant queries before drafting negatives.

Draft Google and Meta ad variations for [verified offer] using platform copy constraints and matching landing-page claims.

Compare [two campaign reporting periods] with consistent currency, conversion settings and attribution windows.

Plan a read-only MCP audit across [connected ad accounts] that inventories spend and campaign status without edits.

Identify keyword opportunities for [market] while separating forecast estimates from measured query data.

Outline a campaign experiment testing [creative angle] while holding audience, bid strategy and budget constant.

Write an explicit approval checklist before an ad agent changes bids, publishes ads or pauses campaigns.

Review automated campaign opportunities against [brand rules] and [spend cap], proposing one measurable reversible experiment.

Build a weekly dashboard with cost, conversions, CPA and clearly marked tracking gaps; avoid mixing currencies.

Audit [Google and Microsoft Ads campaigns] for wasted search terms and conflicting negative keywords.

Compare paid campaigns across [two platforms] using consistent conversion metrics and attribution windows.

Create a rule-based budget alert for [campaign portfolio] without automatically increasing spending.

Evaluate suggested bid changes for [high-cost keywords] using actual conversion value and uncertainty.

Plan a monthly paid-media dashboard with spend, qualified leads and platform-specific reporting gaps.

Review [Meta advertising creative] for expired offers, unsupported performance claims and wrong landing pages.

Prepare an optimization approval queue ranked by expected business impact and rollback requirements.

Workflow: Connect [authorized MCP data source] to a retrieval agent; limit accessible fields and test responses when source data is absent.

Review a multi-agent run for [task] by tracing delegated steps, duplicate tool calls and incorrect conclusions before revising prompts.

Define manager and researcher agents for [competitor audit] with clear tool boundaries and final review.

Connect [approved internal manuals] to a RAG agent and test citations against the source passages.

Prepare an MCP access profile for [read-only helpdesk lookup] that denies sensitive customer fields.

Test a sequential agent workflow on [missing input] and ensure it terminates without guessing.

Build a triggered automation for [new policy document] that routes the summary for human approval.

Compare manager-worker orchestration with a single-agent approach for [document processing].

Inspect [multi-agent trace] for repeated tool calls, invalid delegation and unsupported answers.

Extract sample size, method and limitations from [papers]. Leave missing fields blank and link every entry to its source.

Find contradictory claims across [document collection], with supporting citations and questions for follow-up research.

Compare [three uploaded academic papers] on methodology, sample and findings using linked citations.

Extract a structured evidence table from [study PDFs] with effect estimates and limitations.

Query [research document library] for [specific intervention] and identify papers without matching evidence.

Audit [AI research answer] against quoted sources for distorted conclusions or missing caveats.

Prepare an annotated bibliography from [approved papers] with year, design and key unanswered questions.

Cross-reference [two conflicting literature summaries] to identify where the actual studies differ.

Create a reproducible research memo with citations and an explicit list of documents not reviewed.

Apply a consistent edit profile to [wedding gallery], inspect skin tones and exposure under mixed lighting, and avoid over-retouching.

Workflow: Prepare [client gallery] from culled and edited images, checking exports, sharing permissions and selection before delivery.

Cull [wedding photo batch] by sharpness and duplicates while preserving important emotional expressions.

Compare [AI-selected portraits] with the photographer's shortlist to find valuable missed frames.

Apply a consistent edit profile across [indoor and outdoor event] without flattening skin tones.

Review [AI facial retouch] at full resolution for artifacts and altered identity details.

Prepare a client gallery with [approved favorites], export sizes, permissions and download options.

Check [mixed-lighting photos] for inconsistent white balance before batch export.

Build a final workflow audit covering culling, editing, retouching and client delivery.

Workflow: Break [market scan] into evidence gathering, comparison and summary tasks, requiring a citation and date for each factual claim.

Inspect an agent run that loops on [task], identify repeated ineffective actions and revise stopping criteria without granting extra permissions.

Set a bounded research objective for [competitor scan] with approved public sources and a ten-step limit.

Break [market research goal] into evidence collection, comparison and cited summary tasks.

Design failure handling for [browser agent] when a site is inaccessible, ambiguous or returns stale data.

Review [agent execution trace] to find repeated ineffective searches and define an explicit stop condition.

Create an agent persona for [product analyst] that separates observations from hypotheses and requests approvals.

Compare [two AgentGPT runs] using source quality, task completion and unnecessary tool actions.

Write a safety checklist for [experimental autonomous workflow], prohibiting purchases, outbound messages and unapproved edits.

Compare agent versions [A and B] across [evaluation set], measuring task success, token cost and tool errors under the same settings.

Workflow: Create alerts for [agent production service] when error rate or spend exceeds [threshold], excluding known test traffic.

Trace [failed support agent run] to the first unexpected tool response and correlate it with token usage and session timeline.

Compare [agent version A] with [agent version B] on identical evaluation tasks, recording completion, latency and cost.

Identify circular handoffs in [multi-agent trace] and propose bounded termination criteria.

Build alerts for [production AI agent] that distinguish tool errors, timeouts and model-format failures.

Replay [failed agent session] after a prompt revision to verify the original defect is resolved.

Audit [function-calling logs] for unauthorized action attempts and missing human approval gates.

Create a release scorecard for [agent workflow] with groundedness, tool success and cost thresholds.

Workflow: Simulate a conversation among [three agent roles] using synthetic inputs; audit which agent may call tools or access protected data.

Compare [agent workflow] outcomes before and after a behavior change; test loops, unsupported assertions and missing terminal states.

Design intake, research and reviewer agents for [service request], with explicit role boundaries.

Build a drag-and-drop flow for [support ticket triage] that pauses when required inputs are missing.

Test [multi-agent conversation] on contradictory source documents and evaluate escalation.

Plan API deployment for [agent team] with message validation and bounded retries.

Audit [agent behavior profiles] for inappropriate tool permissions and unsupported outputs.

Report handoffs and failures in [multi-agent session] with reference to actual logs.

Compare single-agent and multi-agent solutions for [document labeling] on cost and accuracy.

Workflow: Capture [three technical articles] through the browser extension, assign tags and verify the summary against original sections.

Create a sourced brief on [topic] with method, key findings and limitations; mark every claim not supported by supplied documents.

Summarize [three technical PDFs] and link conclusions to source passages.

Compare [article and video transcript] on [research claim] and flag disagreements.

Capture [public research webpage] into notes with source date and title.

Create a methods-focused brief from [paper collection] with study limits.

Review [research summary] for missing citations and distorted quotations.

Build a reading plan organized by background, methods and critical evidence.

Inventory [captured research sources] for duplicates and unresolved questions.

Using Keywords Explorer and Site Explorer, compare [topic clusters] by demand, ranking difficulty and current ranking pages without inventing traffic.

Build a link-reclamation queue from [lost backlinks] and linked broken URLs; verify referring pages and prioritize relevant legitimate outreach.

Analyze [site] in Site Explorer for pages earning links and distinguish traffic estimates from actual analytics.

Use Keywords Explorer to group [topic queries] by intent, difficulty and existing landing pages.

Prepare a technical audit of [website] focused on canonical conflicts, redirects, 404s and blocked crawl paths.

Find [high-impression queries] without matching content and build a focused editorial brief.

Investigate lost referring domains to [key product page] and separate broken URLs from deleted source articles.

Compare [three competing sites] for followed backlink quality and realistic outreach gaps.

Develop a rank-tracking report for [priority keywords] using stable location, device and date assumptions.

Workflow: Compare [CV] against [role requirements], identify truthful keyword gaps and produce an ATS-readable revision for approval.

Practice an interview for [role] using [job ad and real experience]; ask one question at a time and critique evidence and clarity.

Rewrite [CV experience bullets] for [job description] while using only actual achievements and skills.

Draft a cover letter for [verified opening] emphasizing relevant experience without invented qualifications.

Compare [resume] with [ATS job requirements] and distinguish essential gaps from optional keywords.

Create a job application tracker for [open positions] with deadlines and follow-up status.

Practice an interview for [role] with role-specific questions and feedback on my answer structure.

Prepare a networking message to [recruiter] referencing only verifiable job details and shared context.

Audit [automated application draft] for wrong employer, stale vacancy, salary assertions and duplicate submissions.

Prepare [pet photo] for a vertical dance clip by extending the cropped limbs, then inspect generated motion artifacts.

Compare two dance presets for [consented portrait] with consistent framing and no unexpected identity changes.

Animate [consented baby portrait] into a short cheerful dance with gentle motion and natural proportions.

Prepare [portrait photo] for image-to-video by widening framing and protecting the subject's facial features.

Create a six-second vertical dancing clip with [playful arm movement] while avoiding impossible joint bending.

Compare [two dance presets] on identity consistency, motion quality and background stability.

Review [generated dance video] for distorted hands, changed facial features and flickering clothing.

Plan a family-only sharing version of [baby dance animation] that avoids public location or identity details.

Prepare export settings for [short vertical video] with correct aspect ratio, audio and no clipped limbs.

Create a terminology glossary for [fiction or technical book] from [sample chapters]; review ambiguous phrases before full translation.

Workflow: QA a translated [book file] for missing paragraphs, broken formatting, numbering and inconsistent terminology against the original.

Translate [EPUB novel] into [target language] while preserving chapter titles, paragraph structure and dialogue punctuation.

Create a glossary for [fantasy book] covering fictional places, invented terms and character names.

Check [translated nonfiction chapter] for numeric discrepancies, missing citations and altered author intent.

Compare a scanned [PDF translation] to the source pages for OCR omissions, footnotes and layout problems.

Adapt idioms in [literary passage] for [target locale], keeping tone and original meaning.

Prepare a publisher QA checklist for [DOCX manuscript translation] covering headings, italics and embedded figures.

Review [AI-translated book sample] with a native editor, prioritizing dialogue voice and terminology consistency.

Create a flowchart for [approval process] showing decisions, owners and exception paths; use only the steps in [source SOP].

Turn [conversion funnel data] into a chart with counts and rates by stage, annotating unequal reporting windows and incomplete tracking.

Make a waterfall chart of [monthly revenue changes] that reconciles to net growth.

Create a heatmap of [support tickets by hour and weekday], distinguishing zero from missing observations.

Plot [unit price versus sales quantity] and label outliers without implying causation.

Turn [architecture notes] into a component diagram with named interfaces and data flows.

Build a funnel visualization for [lead stages] with counts, rates and aligned reporting windows.

Compare line and bar representations of [traffic and orders] while avoiding misleading scales.

Audit [generated dashboard] for correct sums, axis labels, units and accessible color contrast.

Compare three [outfit] variations on the same model, controlling lighting and background for fair assessment.

Create a synthetic fashion product mockup for [garment] with realistic folds and clearly stated simulated appearance.

Preview [jacket reference] on [consented full-body photo] while preserving the face, hands and background.

Place [approved shirt design] onto [model photograph] without altering seams or brand marks.

Compare [three outfit colorways] under identical pose and lighting, labeling results simulated.

Create a side-by-side try-on for [formal outfit] checking sleeve lengths, overlaps and folds.

Prepare an input-photo checklist for [fashion try-on batch] addressing framing and occluded limbs.

Inspect [generated fashion model] for unrealistic proportions and fabricated garment features.

Review [virtual wardrobe outputs] for permission to use likenesses and accurate garment color.

Compare [original and rewritten paragraphs] for factual equivalence, source fidelity and reading level; flag unsupported additions.

Workflow: Assess readability of [multilingual announcement] for [language], verify terminology with a fluent reviewer and avoid claiming detector-proof text.

Rewrite [formal customer email] to sound conversational while preserving every date, amount and promise.

Adjust [AI-assisted article paragraph] for natural rhythm without changing facts or citations.

Compare [before and after passage] for dropped negations, inflated claims and lost technical precision.

Polish [translated product copy] in [target language] while preserving measurements and regulated terms.

Prepare an API integration test for [batch text edits] with rate limits, error logging and rollback copies.

Build an editorial checklist for [humanized academic writing] that maintains author attribution and integrity.

Create three tone alternatives for [brand announcement] with identical factual content and a consistent CTA.

Produce a search-intent outline for [keyword cluster] with distinct headings, reader questions and sources to substantiate each section.

Review generated article [draft] for dead links, unsupported statistics and duplicate sections; prepare an evidence-backed corrections list.

Outline a long-form article for [buyer question] with primary sources and original examples.

Plan a headline-to-article workflow for [technical topic], flagging unsupported statistics for review.

Compare [two generated drafts] for repeated passages, intent mismatch and unsupported comparisons.

Rewrite [generic introduction] into a direct answer based on supplied facts.

Run a citation-checking pass on [bulk generated articles] covering links, dates and product names.

Prepare human editorial gates from [generated content] through [CMS draft] to publication.

Check whether each link in [draft article] supports its specific factual claim.

Refactor [module] to separate parsing from I/O without changing its public interface. Before editing, identify callers and tests; after editing, run unit and integration checks and summarize the diff.

Add regression coverage for [bug reproduction] in the existing test framework. First write a failing test, then implement a minimal fix and show before/after test output.

Review the last commit for unintended changes to [API contract]. Identify breaking cases and draft a corrective patch; keep unrelated formatting and dependencies unchanged.

Document this command-line module: [file]. Explain supported flags, example invocations, exit codes and edge cases using only behavior verified in source and tests.

Add [new command-line option] to [repository] after inspecting argument parsing; update help text and error tests.

Prepare a safe database schema refactor with [migration files], test fixtures and a rollback step before making edits.

Use Aider's Git integration to isolate [bug fix] in a focused commit and review the resulting diff for unrelated changes.

Investigate [failing CI job] by comparing local test outputs, dependency versions and build environment assumptions.

Write an implementation plan for [API pagination feature], including rate-limit behavior, cursors and idempotent retries.

Track changes to [guidance measure] between investor events and separate updated numbers from changes in tone.

Create an event alert for [company list] and [phrase], then review false positives against original disclosures.

Summarize [earnings call transcript] into management guidance, analyst questions and documented risks.

Set alerts for [company investor event] and distinguish rescheduled events from new announcements.

Compare [two quarterly earnings calls] for changed language around margin expectations, citing timestamps.

Investigate [reported sentiment shift] using actual speaker statements rather than the score alone.

Translate [multilingual financial event transcript] while preserving figures and company names.

Prepare a monitoring brief from [public executive presentations] noting source dates and missing disclosures.

Create a follow-up analyst reading list linking [event transcript] with relevant filings and guidance.

Storyboard [product video] as three shots with clear camera motion and approved messaging.

Convert [owned PDF] into an editable summary and verify tables, page order and missing text.

Create a text-to-image concept for [fictional packaging] with matte textures and [brand palette].

Storyboard a six-second [approved product reveal] with three shots and unchanged product details.

Develop an instrumental audio brief for [tutorial intro] specifying energy, length and instrumentation.

Compare AI chat answers to [supplied policy question], keeping only source-supported statements.

Review a [scanned brochure] for scrambled tables and missing headings before generating a summary.

Prepare a QR code for [verified event page] and test scanning at its intended print dimensions.

Build QC criteria for [image, video and audio campaign outputs] covering rights and content accuracy.

Summarize each [interview record] into problem, evidence, desired outcome and follow-up, without fabricating customer intent.

Test an AI extraction field on ten varied [submission records], check misclassifications and define a human review gate.

Classify [customer feedback records] by topic and urgency, using a reviewed sample to measure misclassification.

Summarize [weekly project updates] without inventing task owners, while linking back to the originating record.

Draft an AI-generated lead research field using only [approved CRM columns] and label missing evidence.

Translate [product records] to [target language] while preserving SKU, dimensions and protected brand names.

Build a linked action-item table from [meeting notes] with explicit due dates only when provided.

Combine a formula-based [stock threshold] with an AI-written explanation for the inventory team.

Evaluate [AI-generated field outputs] against a manually labeled batch before enabling bulk processing.

Check [draft paragraph] against [source excerpts], identifying paraphrases that misrepresent findings or lack attribution.

Create a literature comparison table for [topic] containing methods, sample sizes, key findings and limitations with source references.

Develop a thesis statement and three competing interpretations of [academic question] grounded in [assigned papers].

Audit [draft essay] so every factual claim links to a cited passage or is marked unsupported.

Compare [two research methods] from [supplied studies], noting differing populations and confounders.

Rewrite [dense literature review] for clarity while retaining technical meaning and attribution.

Validate bibliography entries for [manuscript] against DOI, year and author metadata.

Draft a counterargument for [academic thesis] using contrary evidence rather than a strawman.

Check [paraphrased paragraph] against its source for unmarked quotations and changed meaning.

Workflow: Export [generated score] as MIDI, edit phrase timing and note velocities in [DAW], then compare rendered audio against the intended cue.

Create variations on [original MIDI motif] using contrasting orchestration while maintaining a recognizable melodic structure.

Compose an original orchestral cue for [quiet departure scene] with strings and a restrained minor-key ending.

Generate a percussion-light fantasy-game loop for [exploration screen] with seamless repetition.

Develop a thirty-second suspense theme for [fictional mystery trailer] with dynamic contrast and no vocals.

Export [original score] as MIDI and revise note velocities and orchestration in [DAW].

Arrange [owned piano motif] for chamber ensemble while retaining its recognizable theme.

Review [audio export] for clipping, dead notes, unbalanced instrument levels and abrupt transitions.

Prepare a cue sheet for [game soundtrack] with timing, delivery formats and licensing review.

Time-block [three priorities] around [fixed meetings], allowing preparation, travel and realistic break buffers.

Review overdue tasks by contractual deadline vs optional work, then reschedule only confirmed commitments.

Time-block [three deliverables] around existing appointments while preserving buffers and actual deadlines.

Convert [unprocessed task inbox] into priorities with estimated durations and suitable calendar slots.

Reconcile tasks imported from [two connected apps], flagging duplicates without discarding context.

Schedule preparation for [meeting across timezones] and confirm the local start and prework duration.

Restructure an overloaded [daily calendar] by deferring low-priority tasks and protecting essential work.

Design a keyboard-first capture and triage routine for [incoming project tasks].

Compare [planned versus completed time blocks] and update the next week's estimates from observed effort.

Forecast [weekly leads] with a holdout period; report absolute errors alongside a simple seasonal baseline.

Compare channel-level [cost per lead] changes over equal periods, showing outliers and attribution limitations.

Train a no-code prediction for [lead conversion] using a time-based validation set and a simple benchmark.

Query [approved marketing table] in natural language, then verify totals and groupings against source rows.

Clean [CRM export] to detect duplicate customers, missing categories and target leakage before training.

Build a forecast for [monthly demand] with seasonal variables and report error on held-out months.

Create a business dashboard for [model scores] that includes confidence, date and source freshness.

Compare alternative classifiers for [customer churn] using recall, calibration and cost of false positives.

Monitor [prediction pipeline] for changed source columns, missing data and declining accuracy.

Workflow: Lip-sync [authorized voice recording] to [avatar footage], checking timing at consonants and avoiding identity misrepresentation.

Generate a [product explanation] scene with a replacement background, verifying silhouette edges and disclosure of synthetic media.

Create a clearly disclosed synthetic presenter from [consented likeness] using an approved product script.

Translate and dub [authorized training video] into [target language] with names and technical terms reviewed.

Check lip synchronization of [avatar recording] at fast speech, sentence endings and visible consonants.

Replace [presenter video background] with a neutral studio while keeping hair and shoulder boundaries natural.

Plan a face-swap demonstration using only [consenting actors] and documented distribution permissions.

Compare [two avatar render settings] for expression stability, identity consistency and lighting.

Audit [generated promotional video] for altered product details, fictional testimonials and appropriate AI disclosure.

Define guardrails for autonomous budget allocation across [campaign portfolio], including maximum change, approvals and rollback.

Review an optimization recommendation for [campaign] by comparing attribution assumptions, CPA and a controlled measurement plan.

Map [marketing campaigns] across channels with matched spend and conversion definitions.

Set maximum automatic budget changes for [campaign portfolio] before requiring human approval.

Compare [audience segments] on measured acquisition cost with sample-size limitations.

Plan an A/B test for [seasonal promotion] varying one message while holding audience constant.

Investigate [cross-channel reporting discrepancy] through event tracking and attribution settings.

Create an alert for [spending spikes] and flag the relevant campaign without automatically pausing ads.

Summarize [marketing experiment] with observed outcomes, open assumptions and next review criteria.

Compare server-rendered content for [AI crawler user agent] with the normal page, verifying substantive parity and no deceptive cloaking.

Plan technical SEO rollout for [CMS pages] with pre/post source checks, indexability tests and documented rollback.

Audit [Shopify URL family] for duplicate canonicals, robots directives and indexed parameters.

Compare rendered content from [JavaScript-heavy page] for visitors and crawlers without hiding material sections.

Inspect [XML sitemap] for redirects, noncanonical entries and invalid URLs before proposing edits.

Plan staged technical SEO deployment on [CMS templates] with rollback and regression checks.

Review [AI crawler access settings] for unintended blocking and inconsistent user-agent handling.

Compare pre- and post-change crawl reports for [site], accounting for search-engine processing delays.

Prioritize [technical SEO findings] by confirmed impact on crawlability and indexation.

Set monitoring alerts for [competitors] and [product segment], reviewing materiality and irrelevant mentions.

Prepare an industry briefing separating official disclosed metrics, management assertions and unknown risks.

Search [earnings transcripts and filings] for claims about [supply-chain cost] with source and date context.

Compare [competitor statements] about [market segment] across public reports without implying market share.

Create an alert for new disclosures mentioning [risk category] and separate material changes from repetition.

Summarize [management commentary] with cited quotations and distinguish guidance from historical results.

Build a research brief from [analyst reports] showing consensus, disagreement and underlying assumptions.

Investigate [financial statement discrepancy] by reconciling reporting periods and accounting definitions.

Review [AI-generated market intelligence] for stale sources, missing filings and unsupported predictions.

Workflow: Create original synthetic voice lines for [game character] from [approved script], avoiding imitation of real individuals.

Compare speech conversion settings on [test audio] for artifacts, clipping and pronunciation before exporting the final track.

Transform [licensed character dialogue] into a distinct authorized game voice while retaining timing and emotional intent.

Create a pronunciation glossary for [multilingual audiobook excerpt] before voice conversion.

Compare [three voice morph settings] on the same speech clip for intelligibility and artifacts.

Review [converted interview audio] for dropped words, speaker confusion and unnatural pauses.

Plan a speech-to-speech batch for [approved localization script] with naming and version controls.

Clean [raw narration] before voice conversion, retaining the untouched master and recording processing settings.

Design a voice-cloning permission checklist covering speaker consent, permitted channels and deletion.

Join [customer and orders] by verified IDs; quantify unmatched rows and one-to-many duplication before reporting totals.

Build a geospatial analysis of [locations and service zones], checking projections, missing coordinates and boundary overlaps.

Join [ERP invoice export] with [supplier master] in a visual workflow and report unmatched supplier keys.

Prepare [sales transaction dataset] by standardizing date formats, currencies and missing categories.

Create an AutoML benchmark for [churn classification] using a leakage-safe split and balanced evaluation metrics.

Design a geospatial workflow for [store catchment areas] using documented coordinate systems and distances.

Compare an Alteryx Designer workflow with [equivalent SQL transformation] for correctness and maintainability.

Audit [workflow output] for duplicate joins, dropped rows and untracked manual exceptions.

Build a reproducible reporting flow from [warehouse query] to [monthly operations dashboard].

Define an action group for [authorized inventory lookup] with input schema, validation, authentication and human approval before write actions.

Evaluate [agent workflow] on unanswered questions and tool failures; log traceable citations, guardrail decisions and safe handoffs.

Outline a classic Bedrock agent for [internal FAQ] using Knowledge Bases and strictly read-only retrieval.

Design an action group for [order lookup API] that authenticates users before returning order details.

Create an agent test set for [multi-step service request] with ambiguous inputs and expected fallback behavior.

Review [agent trace] to locate failed tool calls, mistaken assumptions and missing grounded sources.

Plan guardrails for [customer service agent] to block sensitive disclosures and unauthorized refunds.

Compare a legacy Bedrock Agents workflow with [new AWS architecture] and list migration assumptions for review.

Prepare a controlled deployment checklist for [classic Bedrock agent] with permissions, logging and rollback.

Explain the root cause of [CloudFormation deployment error] from [template and logs], then propose the smallest validated change.

Generate unit tests for [Python module] in the existing repository framework, including malformed input and AWS service failures.

Investigate [AWS IAM AccessDenied error] against supplied resource policy and CloudWatch logs before recommending permissions.

Generate unit tests for [Lambda handler] covering malformed events, duplicate S3 notifications and retries.

Explain [CloudFormation or CDK stack] using actual resource dependencies and access boundaries.

Review [Terraform change] for destructive replacements, secret handling and environment drift.

Propose an incremental modernization of [legacy Java service] with compatibility and integration tests.

Debug [DynamoDB conditional write failure] using the actual schema, key shape and request parameters.

Draft an AWS incident report from [deployment and runtime logs], separating evidence from hypotheses.

Create intent tests for [account requests], including ambiguous statements and out-of-scope scenarios; review incorrect routing.

Adapt a support workflow across [chat and voice] while preserving ticket IDs and escalation context.

Design an authenticated conversational journey for [insurance policy inquiry] with human escalation rules.

Map [complex billing question] into intents and slots, including ambiguous replies and missing identity evidence.

Connect [approved CRM lookup] to a support flow while restricting customer fields and logging access.

Write a multilingual fallback conversation for [unsupported service request] with a clear transfer to an agent.

Assess [conversation transcript] for misrecognized entities, repeated prompts and unresolved issues.

Plan an enterprise workflow that opens [service ticket] only after policy validation and user confirmation.

Define acceptance tests for [Amelia deployment] covering session context, latency, sensitive data and escalation.

Implement [small feature] using existing conventions, document impacted files and run regression checks before requesting review.

Compare two approaches to [API refactor] based on verified source, security boundaries and maintenance trade-offs.

Inspect [repository issue] in Amp and propose a minimal patch with a regression test before changing code.

Plan a cloud coding task for [API endpoint] with bounded scope and explicit acceptance criteria.

Compare solutions from [available models] on a failing test without changing production state.

Review [agent generated git diff] for unrelated file changes, unsafe commands and exposed secrets.

Coordinate a collaborative workspace handoff for [refactor], recording decisions, files and test evidence.

Create a migration strategy from [legacy SDK] with compatibility checks and rollback steps.

Evaluate whether [remote execution task] needs human approval for filesystem, network or deployment actions.

Compare 7-day retention by [acquisition cohort], keeping date windows and cohort definitions consistent.

Map paths before abandonment of [feature], highlighting loops, low-frequency events and potentially incomplete tracking.

Build a funnel from [signup] to [first key action], documenting event definitions and exclusions.

Analyze [new-user cohort retention] by acquisition source while accounting for users with incomplete observation windows.

Find high-abandonment paths in [onboarding journey] and separate correlation from evidence of causality.

Create an experiment measurement plan for [new onboarding screen] with primary and guardrail metrics.

Audit [event instrumentation] for double firing, missing identity merges and conflicting property formats.

Compare [feature adoption rates] across platforms using consistent user populations and date windows.

Design a product-growth dashboard that joins [activation and retention metrics] with plain-language definitions.

Compare competing definitions of [industry term] from two primary authorities and explain when each applies.

Investigate [regulatory update] in [jurisdiction], distinguishing official effective dates from commentary.

Find a sourced answer to [research question] and distinguish original reporting from repeated summaries.

Compare [two web sources] on [product specification], highlighting any missing date or conflicting figure.

Prepare a concise reading list for [topic] with source URLs, publication dates and one limitation per source.

Verify [claim] against an official document before using it in a customer presentation.

Use visual search results to identify [product category] while confirming names from linked source pages.

Create an ad-free research brief on [industry trend] with evidence and clearly marked unanswered questions.

Review [AI search answer] for citation gaps, stale information and unsupported certainty.

Plan a looping [five-second] motion sequence with consistent start/end frames and controlled motion strength.

Workflow: Test [motion module] with [reference frame and ControlNet guidance], checking flicker, temporal coherence and drift.

Animate [original character illustration] into a six-second shot with controlled movement and stable costume details.

Compare [motion module A] and [motion module B] using a fixed source image and seed for flicker and temporal consistency.

Use ControlNet pose guidance with [licensed drawing] to preserve action across generated frames.

Create a seamless [wind-blown grass] loop and check visual continuity between first and last frames.

Adjust motion scale for [walking figure] and evaluate limb drift, jitter and background warping.

Build a reproducible workflow listing checkpoint, motion module, sampler and context window for [video experiment].

Diagnose [unstable generated clip] by isolating frame count, model compatibility and conditioning inputs.

Build a slideshow for [event] from [ordered photos], keeping consistent aspect ratio and leaving each title on screen long enough to read.

Resize [finished video] for vertical stories and square feeds; verify text-safe margins, logo placement and audio rights.

Build a forty-second testimonial montage from [consented quotes and footage] without changing the speaker's meaning.

Create a photo tribute for [family event] with an opening title, five image groups and a gentle final frame.

Plan animated text overlays for [event promo] so date, venue and action stay legible on mobile.

Compare [two video templates] for a [B2B explainer] on pacing, caption capacity and branding.

Review music and stock-video usage rights before publishing [commercial social clip].

Construct a feature-led video from [ordered product photos] with precise crops and no invented specifications.

Inspect [exported square video] for stretched media, clipped subtitles, audio levels and incorrect contact details.

Trace an unexpected [transaction rate] change against deployment events and correlated service metrics; avoid assuming causality.

Audit alert history for noisy false positives and missed spikes, proposing reversible threshold changes.

Investigate a sudden [cloud spend anomaly] by grouping costs by account, service and resource tags.

Compare [checkout failure rate] with infrastructure metrics during the same alert window.

Plan anomaly thresholds for [business KPI] that account for weekday seasonality and known campaigns.

Create a root-cause checklist for [unexpected data-volume spike] using upstream system changes.

Design a notification workflow for [critical metric alert] with severity, owner and escalation limits.

Evaluate [Anodot anomaly report] for false positives due to missing feeds or delayed data.

Prepare a post-incident summary from [correlated service metrics] with observed evidence and remaining hypotheses.

Design a human-approved UI workflow for [repetitive form entry] with clear stop conditions, screenshots and no final submission without confirmation.

Investigate a failed computer-use action from [screenshots and log], identify the ambiguous screen element and propose a safer retry condition.

Plan a screenshot-driven task on [staging dashboard], identifying the correct filter before any interaction.

Test safe text entry into [sandbox form] and stop before irreversible submission.

Analyze [before and after screenshots] to determine whether the requested setting changed.

Create a browser recovery path for unexpected modals, session expiry or human verification.

Design a read-only navigation task across [two authorized apps] with explicit limits on copied personal data.

Evaluate a computer-use trace for accidental clicks, repetitive actions and incomplete confirmation.

Specify approval gates for [UI workflow] before deleting records, sending messages or changing payment details.

Benchmark Ray processing throughput on [sample size], recording scaling cost, failures and reproducibility.

Diagnose [Ray worker failure logs], separating object store pressure, autoscaling behavior and application exceptions.

Submit a managed Ray job for [distributed batch inference] with resource requirements and checkpoint paths.

Plan autoscaling for [variable serving workload] using measured concurrency and latency targets.

Debug [Ray cluster job failure] using worker logs, package versions and memory pressure evidence.

Compare cost and throughput of [two cluster configurations] under identical benchmark datasets.

Design an access-controlled workspace for [data science team] with least-privilege roles.

Prepare a rollout plan for [Ray Serve model endpoint] with health checks, canary and rollback.

Audit [distributed training run] for object store exhaustion, straggler workers and restart behavior.

Design a restricted internal agent for [FAQ process] with explicit tool access, instructions and escalation when source material is missing.

Compare responses with and without [uploaded policy] using a fixed evaluation set, tracking citation correctness and answer completeness.

Build a local knowledge workspace from [approved PDF manuals] with source citations and document-version tracking.

Design an offline document question-answering evaluation on [reference questions] with abstention when sources are missing.

Connect [allowed model provider] to a private workspace and test retrieval without exposing unrelated files.

Prepare a RAG ingestion checklist for [meeting documents] covering duplication, permissions and chunk boundaries.

Define an agent task for [read-only report lookup] with approved tool access and no external writes.

Investigate [hallucinated answer] by checking retrieved document excerpts and prompt instructions.

Review [workspace sharing settings] for sensitive documents, stale embeddings and information leakage.

Prepare [field notes] for offline use and test how edits and conflicts synchronize after reconnection.

Turn [unstructured project notes] into linked objects and properties without losing the original text.

Structure [research project] using connected objects for people, sources, decisions and next actions.

Build a local-first knowledge collection from [offline lecture notes] with meaningful relations and tags.

Design a template for [weekly project review] that links dated notes, tasks and supporting files.

Audit [object graph] for duplicate entities and broken backlinks before reorganizing.

Plan a secure team sharing workflow for [private project] with explicit permissions and device sync checks.

Create an information architecture for [reading library] using object types, collections and status properties.

Test [offline note-taking scenario] and specify what to verify after encrypted peer synchronization.

Adapt [approved product message] for landing page, email and paid search while maintaining consistent claims and brand tone.

Workflow: Use performance predictions to shortlist ad variants, then confirm effectiveness with a live A/B test and equal audiences.

Draft three on-brand paid-search ad variations for [verified product benefit] with policy-compliant claims.

Compare predicted performance signals for [headline candidates] without treating scores as guaranteed results.

Create a consistent brand-voice guide from [approved campaign examples] and prohibited phrases.

Rewrite [landing page hero] for [buyer segment] with a clear benefit and one call to action.

Generate email subject-line variants for [newsletter] with an explicit A/B-test hypothesis.

Audit [generated marketing copy] for unsupported percentages, aggressive scarcity and trademark misuse.

Summarize [copy experiment] using observed traffic and conversions with sample-size caveats.

Draft a three-message outreach sequence for [persona] using only documented company signals, not invented personalization.

Compare campaign performance by persona after excluding bounces, unsubscribes and incomplete records.

Create a prospect segment for [industry and role] using explicitly verified company and title filters.

Draft a personalized outbound email from [approved prospect research] without inventing company events.

Build a multi-step engagement sequence for [opted-in leads] with reply handling and suppression rules.

Review [Apollo contact enrichment] for outdated roles, duplicate records and uncertainty in email status.

Plan CRM synchronization for [sales accounts] that prevents duplicate opportunities and unauthorized overwrites.

Prepare a lead-scoring experiment based on [qualified outcomes] rather than unverified intent assumptions.

Audit [prospecting campaign results] for deliverability, unsubscribe requests and real booked meetings.

Audit [audio transcript labels] for missing speech, diarization mistakes and annotator agreement.

Design a multilingual intent labeling rubric and measure reviewer disagreement on shared samples.

Define annotation guidance for [street-scene video] with object labels, occlusion examples and reviewer acceptance rules.

Plan an audio transcription dataset for [multiple accents] with sampling criteria and consent requirements.

Measure agreement between [two groups of annotators] on the same named-entity labeling set.

Create an escalation queue for [uncertain sentiment labels] including ambiguous cases and adjudicator notes.

Prepare a training-data delivery checklist for [image dataset] with schema, versioning and missing-file checks.

Evaluate [human feedback ratings] for model answers by category and bias before use in tuning.

Document data provenance and permissions for [global annotation project] with retention and withdrawal procedures.

Summarize [meeting transcript or note] into decisions and next actions, assigning owners only when explicitly named.

Workflow: Use available writing assistance to proofread [document] for clarity while keeping private content within approved device/account settings.

Rewrite [draft iPhone email] more concisely while preserving names, dates and intended tone.

Summarize [approved notes] into decisions and follow-ups without inventing task owners.

Prepare a short message reply to [meeting invitation] using only provided scheduling facts.

Generate an original image concept for [family greeting card] without third-party trademarked characters.

Create a checklist to review what [personal information] is shared when using AI-assisted features on a supported device.

Compare [two written versions] for clarity while retaining the exact legal or financial meaning.

Plan a supported-device workflow to organize [personal notes] while respecting app permissions and privacy settings.

Create an authenticated form for [internal request] with field validation and human approval before any backend write.

Review an Appsmith query for unsafe interpolation and excessive database privileges; propose a parameterized alternative.

Create an internal dashboard for [support tickets] using approved SQL data and role-scoped views.

Build a table-edit workflow for [inventory records] with validation and audit logs before updates.

Generate parameterized SQL for [sales aggregation] from the supplied database schema.

Design an Appsmith form that calls [approved API] with clear loading and error handling.

Audit [JavaScript query logic] for exposed secrets, injection risks and unintended writes.

Compare [dashboard UI alternatives] for usability and safe handling of missing data.

Prepare deployment QA for [internal operations tool] including permissions, rollback and database constraints.

Design an automation for [customer inquiry] to create a support record without duplicates; test notification and opt-out behavior.

Review [mobile app prototype] for offline assumptions, tap targets and platform-specific notification permissions before publishing.

Sketch a no-code booking app for [service business] with request validation and human confirmation.

Build a simple membership app structure for [community] with account roles and a clear privacy notice.

Design a mobile form to collect [event registrations] and show success or error states.

Plan push notifications for [opted-in customers] with frequency controls and unsubscribe handling.

Compare app navigation layouts for [local directory] with accessibility and small-screen usability in mind.

Define automation steps between [new submission] and [approved backend] while preventing duplicate records.

Prepare a prelaunch checklist for [no-code app] covering permissions, broken links and data retention.

Review [long article] in Reader mode and capture structured notes tied to the original URL.

Compare privacy and tab cleanup behavior during [research session], noting current browser settings.

Use Browse for Me on [product question] and verify key facts against the linked source pages.

Compare two mobile search summaries for [topic], noting missing publication dates and contradictory sources.

Prepare a short travel-research brief from [public pages] and separate confirmed opening hours from estimates.

Review [automatically archived tabs] to identify relevant research sources before discarding context.

Use reader mode to extract the main arguments from [long article] without losing referenced qualifications.

Assess privacy settings for [Arc Search browsing session], including tracker blocking and permissions.

Test [voice-based query] with ambiguous location names and verify the intended result before acting.

Measure agreement on 100 overlapping [text labels], adjudicate disagreements and improve ambiguous guidelines.

Run token-level entity labeling for [entity types] with explicit span boundaries and tricky punctuation examples.

Create an LLM preference dataset from [candidate answers] with explicit reviewer criteria and source references.

Design token-level annotation rules for [medical terms] including overlapping spans and ambiguous boundaries.

Compare [model-generated classifications] with expert labels and prioritize high-disagreement cases.

Build an active-learning queue for [new feedback batch] using uncertainty scores and human verification.

Prepare an Argilla-to-Hugging Face dataset handoff with field mapping, license and version controls.

Set up a quality-control process for [three annotators] using a shared calibration set and adjudication.

Audit [feedback records] for stale instructions, duplicate tasks and personally identifying information.

Investigate an error increase after [deployment] using traces, feature distribution and representative failed cases.

Set alert thresholds for [critical metric], specifying false-positive tolerances and human escalation steps.

Create an LLM observability plan for [RAG app] tracking answer groundedness and retrieval evidence.

Investigate [model prediction drift] against feature distribution, label delay and recent deployments.

Design evaluation datasets for [search assistant] with representative queries and known failure examples.

Compare [two model versions] using the same monitoring windows and segment-specific error rates.

Trace [unexpected agent response] to its retrieved documents, tool calls and recorded model inputs.

Build an alert protocol for [production inference service] with action thresholds and false-alert handling.

Prepare an ML monitoring incident memo separating observed metrics, possible causes and tests needed.

Workflow: Animate a [product launch] scene with three keyframe beats while keeping supplied logo and packaging dimensions intact.

Prepare four coordinated marketing mockups for [campaign] using approved assets and checking typography/crop across formats.

Build a product packaging mockup for [approved label design] with accurate dimensions and material finish.

Create a storefront hero image using [owned product artwork] on realistic mockup assets.

Prepare a short animated product reveal with [camera movement], timing and consistent brand placement.

Compare mockup lighting options for [glass bottle] to keep reflections and text legible.

Build a repeatable social creative template for [product collection] with interchangeable artwork.

Inspect [mockup scene] for stretched labels, incorrect perspective and missing shadows.

Export [approved design assets] for website and social use with correct sizing and source-file organization.

Create three landscape directions for [fictional setting] with contrasting color moods, then select consistent features for a series.

Workflow: Develop an original character variation set, compare artifacts and avoid implying resemblance to a real person.

Blend [authorized landscape images] into a novel environment concept with consistent lighting and depth.

Iterate an original character portrait using [face-shape and style traits] while tracking visual changes.

Create three stylistic variations for [fantasy creature] without imitating a named real person's likeness.

Explore different color and composition directions for [storybook scene] with consistent focal elements.

Compare [two generated image lineages] to identify which visual traits remain stable after blending.

Prepare a visual moodboard from [licensed source images] with clear reuse permissions.

Review [generated portraits] for facial artifacts, accidental resemblance and inconsistent anatomy.

Design distinct outlines for [three search intents] so generated articles answer different reader needs instead of duplicating paragraphs.

Audit a generated long-form article for repetition, stale pricing and unsupported claims before scheduling CMS publication.

Generate an outline for [informational search intent] anchored to verified sources and reader questions.

Plan an article on [industry concept] with definitions, worked examples and explicit evidence requirements.

Prepare a batch-content QA process for [topic cluster] to catch duplicate wording and thin sections.

Review [AI-produced blog draft] for inaccurate data, invented references and stale product information.

Rewrite [generic article introduction] into a direct answer supported by the supplied source material.

Develop an editorial approval checklist for [bulk generated articles] before any automatic publication.

Compare [two related post drafts] for intent collisions and recommend consolidation where appropriate.

Workflow: Inpaint [selected background object] in [owned image] while keeping the remaining subject and composition unchanged.

Compare [checkpoint/LoRA settings] on a fixed visual brief, evaluating anatomy, visual consistency and rendering artifacts.

Run a local text-to-image setup for [original woodland scene] with a reproducible model and random seed.

Plan an img2img pass on [owned sketch] using a denoising range that preserves its basic silhouette.

Create an inpainting workflow to modify [object in approved illustration] without damaging nearby textures.

Assess [model checkpoint] compatibility with [desktop hardware] before starting a large render batch.

Generate three style explorations for [original sci-fi landscape] with consistent aspect ratio.

Troubleshoot [local model load issue] by checking file placement, memory use and model format.

Review [saved ArtroomAI assets] for file naming, seed documentation and unintended copyright-sensitive resemblance.

Extract actionable tasks from [meeting notes], preserving explicit assignees and dates and flagging ambiguities.

Draft a weekly status from live project records, separating completed work, unresolved risks and proposed next steps.

Create tasks from [project kickoff notes], retaining only explicit assignees and deadlines.

Generate a weekly status update from [project board] separating completed work, blocked items and risks.

Identify tasks in [launch project] missing owners or dependencies without inferring the responsible person.

Draft a smart summary of [milestone] from comments, highlighting unresolved decisions and source links.

Suggest a workflow automation for [approval process] with clear triggers, exception states and human confirmation.

Compare [two sprint statuses] and explain shifts using logged task changes, not speculation.

Review an AI-generated project report for outdated statuses and commitments not reflected in Asana.

Review interview scheduling for [candidate group] to avoid panel conflicts and inconsistent candidate communication.

Compare recruiting funnel movement by stage for [period], accounting for hires still in progress.

Design a recruiting pipeline for [engineering role] with consistent screening stages and approval requirements.

Create an interview scheduling plan for [candidate panel] that accounts for timezone and interviewer availability.

Analyze [candidate funnel report] by stage with selection rates and missing-data caveats.

Draft an outreach message to [sourced candidate] based only on verified relevant experience.

Review [applicant records] for duplicate profiles, conflicting statuses and missing consent.

Build a skills-based evaluation rubric for [role] that avoids irrelevant proxy measures.

Prepare a hiring-manager weekly update showing active interviews, blockers and next required decisions.

Write unit tests for [module] that cover ordinary, empty and malformed inputs without changing its public API.

Explain [SQL query] and propose a parameterized refactor while preserving its result shape and preventing unsafe interpolation.

Write unit tests for [TypeScript function] including edge cases, exceptions and null inputs.

Refactor [legacy helper] for readability without changing its public interface or returned values.

Generate a parameterized SQL query for [report requirement] using supplied schema and safe filtering.

Explain [unfamiliar code module] from provided source, noting dependencies and side effects.

Review [API handler] for incorrect input validation, authorization gaps and unhandled errors.

Draft documentation for [existing function] including parameters, examples and known limitations.

Compare [two implementation approaches] for performance and maintainability before editing files.

Compare conflicting conclusions across [two uploaded reports], identifying their supporting text and unknowns.

Create a study guide from [lecture slides] with cited key concepts and five review questions.

Query [uploaded financial PDF] for revenue figures, preserving table units and page references.

Compare [two research documents] on methodology and evidence, citing passages from each.

Turn [course handout PDF] into a study guide with a source-grounded practice quiz.

Extract termination obligations from [contract PDF] and flag missing exhibits and ambiguous clauses.

Summarize [presentation slides] while preserving diagram captions and caveats.

Check [multi-document answer] for statements not supported by its cited sources.

Prepare a citation-ready issue matrix from [uploaded agreements] with exact document and page references.

Workflow: Process [customer-call recordings] into transcripts and concise topic summaries; redact sensitive identifiers before storage.

Evaluate speech recognition on [labeled sample] using word error rate, noisy audio segments and latency; compare with a fixed baseline.

Transcribe [consented support call] and include timecoded sections for manual accuracy checks.

Prepare speaker diarization for [panel interview], flagging uncertain speaker switches.

Extract action items from [meeting transcript] with evidence timestamps and only confirmed owners.

Design a streaming speech-to-text workflow for [voice interface] with latency and retry expectations.

Test transcription on [noisy audio sample] and measure errors in proper names and technical terms.

Plan redaction of [sensitive identifiers] in audio transcripts before storage or downstream analytics.

Build a benchmark for [speech models] using held-out recordings and word-error metrics.

Generate an image series of [supplied product] on coordinated backgrounds using the approved model reference and consistent perspective.

Workflow: Inpaint [authorized campaign image] to replace [object], preserving brand colors, shadows and source subject identity.

Plan a custom image-model training dataset for [owned product] with diverse lighting and consistent identity.

Generate image variants of [authorized fashion item] for [campaign backgrounds] without changing its design details.

Use a fine-tuned concept model to create [three studio scenes] with coherent proportions and brand styling.

Inpaint [unwanted background element] in [licensed photo] while preserving the subject and realistic shadows.

Compare [two fine-tuned model versions] on representative prompts for consistency and overfitting artifacts.

Prepare an API generation workflow for [approved marketing assets] with reproducible settings and output QA.

Audit [generated model outputs] for memorized training images, distorted logos and consent or rights problems.

Clean [podcast episode] for background noise and reverb while checking that consonants and room ambience remain natural.

Prepare a multi-track audio mix from [host and guest files], align timing and inspect clipping, breaths and exported format.

Normalize [podcast episode] to [delivery loudness target] without introducing clipping or audible pumping.

Clean [remote interview] with background noise and variable microphone levels while retaining natural voices.

Balance [two-speaker recording] so quieter passages remain intelligible without excessive compression.

Compare noise-reduction settings on [speech sample] to avoid metallic artifacts and lost consonants.

Set up an audio-processing workflow for [weekly podcast] with consistent metadata and export formats.

Review [transcription from cleaned audio] for incorrectly recognized names and missing technical words.

Create a before-and-after QC checklist for [processed recording] covering loudness, reverb and silence.

Create a jump-cut version of [talking-head segment], then review speech continuity and awkward visual transitions before export.

Workflow: Apply silence detection to [Premiere Pro sequence] with different thresholds and compare editing quality against the original.

Remove dead air from [approved interview recording] while preserving breathing room around major transitions.

Generate captions for [multilingual podcast clip] and flag proper names needing human correction.

Apply automatic zooms to [talking-head tutorial] without clipping important visual details.

Select B-roll insertion points for [product walkthrough] while preserving accurate speaker context.

Review [AutoCut silence thresholds] to prevent removal of quiet but meaningful dialogue.

Prepare a sequence QC checklist for [Premiere or Resolve project] covering subtitles and audio sync.

Compare [automatic edit] with [source footage] to catch missing statements or misleading cuts.

Convert [actor footage] into character animation, then inspect foot sliding, joint placement and retargeting accuracy.

Composite an animated character into [scene] with matching light direction, color and clean-plate background; check temporal consistency.

Convert [authorized live-action stunt footage] into character motion, assessing foot contact and body pose accuracy.

Replace [performer in licensed footage] with [original CG character] while preserving camera motion and occlusion.

Review automatic camera tracking in [moving shot] for drift before adding a digital character.

Prepare a clean plate of [film scene] and inspect areas exposed by removing the original performer.

Match lighting and shadows of [CG asset] to [dusk outdoor scene] with frame-by-frame consistency.

Export [character animation and camera data] into [3D pipeline] and check scale, rig and frame rate.

Create a VFX quality checklist for [Flow Studio composite] including tracking, lighting, roto and usage rights.

Run a synthetic [customer support] simulation between two agents and a human supervisor, logging handoffs and unanswered questions.

Workflow: Test code-execution agents in a sandbox on [sample task], restrict file/network access and compare output against fixed tests.

Design a three-agent discussion for [code review] assigning developer, tester and security reviewer responsibilities.

Create a bounded group-chat workflow for [incident triage] with shared context and explicit escalation criteria.

Test [AutoGen agents] on conflicting sources and require citations before accepting a synthesized answer.

Plan a safe sandbox for [agent-generated Python execution] with resource limits and no production credentials.

Compare sequential and collaborative multi-agent designs for [data analysis task] on cost and failure handling.

Build a human-approval checkpoint before [agent team] can apply any file or API changes.

Document traces from [agent interaction] to identify circular conversations and unsupported tool conclusions.

Workflow: Review an autonomous agent's tool permissions for [task], ensuring no external purchases or writes without approval.

Diagnose repeated actions in [agent trace] and rewrite success/stopping conditions to avoid uncontrolled loops.

Define a research-agent objective for [competitive landscape] with a fixed scope, source whitelist and review checkpoints.

Break down [long project objective] into verifiable subtasks with explicit stopping conditions and human approvals.

Test an experimental agent on [mock document folder] without allowing external writes or irreversible actions.

Design a memory-retention policy for [agent project] so outdated observations do not become verified facts.

Compare two agent task plans for [market research] on dependency ordering, tool risks and measurable outputs.

Investigate [repeated agent-loop failure] by tracing tool responses, task prioritization and termination logic.

Prepare an evaluation checklist for [autonomous task run] that distinguishes claimed completion from verified results.

Workflow: Automate a repetitive [authorized form] entry using test data, validation checkpoints and no final submission without approval.

Debug an Automa flow that fails after [page transition], checking element visibility, wait states and missing data.

Create a visual browser flow that extracts [public event listings] into [local CSV] with page source links.

Design an authorized form-filling workflow for [internal QA website] using mock data and required-field checks.

Test [Automa workflow] under pagination, missing buttons and navigation timeouts without bypassing access controls.

Plan a scheduled workflow that monitors [approved product page] for legitimate content changes.

Use conditional steps to skip incomplete [page records] and log why each was excluded.

Document safe variables and secret handling for [multi-step browser process] before sharing the workflow.

Review [automation execution trace] for repeated actions and propose bounded retry limits.

Compare extracted [invoice] fields against ERP master data; route mismatched supplier IDs and tax amounts to a human review queue.

Design an approval step for [document processing] that preserves source attachments and prevents duplicate ERP updates.

Extract purchase-order data from [incoming document batch] into a structured schema with required field validation.

Route [invoice exception] to a human reviewer when totals, tax IDs or line items fail reconciliation.

Design an Ada workflow for [order confirmation] that cross-checks ERP records before approving downstream steps.

Compare [two supplier order formats] and document extraction ambiguities requiring updated rules.

Build a monitoring report for [document-processing pipeline] with failure categories and verified completion counts.

Test [document automation] on scanned files, duplicate attachments and unexpected file formats.

Prepare a controlled handoff from [validated extracted order] to [ERP import] with traceable source references.

Workflow: Inpaint a selected [object] in an owned photograph, matching adjacent texture and shadows while preserving untouched areas.

Evaluate [ControlNet reference] on [pose illustration], comparing pose fidelity and unwanted changes to clothing or background.

Generate an original [steampunk cityscape] in text-to-image mode with specified seed, sampler and image dimensions.

Use img2img to stylize [owned fantasy drawing] while maintaining recognizable layout and important objects.

Inpaint [damaged area] in [licensed illustration] and inspect boundaries for inconsistent textures.

Plan a ControlNet workflow to keep pose and composition stable across [character design variations].

Compare [two checkpoint models] on identical prompts to assess anatomy, detail consistency and render cost.

Configure a LoRA-assisted concept workflow for [original costume style] with documented strength and compatibility.

Troubleshoot [VRAM or extension error] by checking model settings, batch size and extension dependencies.

Design a controlled RPA bot for [customer onboarding], restricting credentials, idempotency and human approval before account creation.

Review bot execution logs from [process] for failed steps, elapsed time and policy exceptions; propose safe retry conditions.

Design an RPA process for [incoming purchase orders] with document extraction and manual approval for exceptions.

Build a validation workflow for [invoice data] that reconciles totals, currency and supplier IDs before ERP entry.

Define a credential-safe bot for [approved system updates] using role-based access and an auditable execution log.

Investigate [unattended bot failures] by separating input defects, UI changes and connector errors.

Create a human-in-the-loop review queue for [low-confidence extracted fields] with resolution categories.

Plan an automation release for [finance workflow] including rollback, runbook and acceptance tests.

Summarize [process analytics] to identify frequent exceptions without assuming theoretical time savings.

Remove prolonged silence from [interview recording] while retaining expressive pauses; compare the cut to original audio.

Generate short social clips from [long video] with accurate captions, safe crops and a rights check before distribution.

Configure a multicamera podcast edit for [three speakers] with accurate camera assignment and natural reaction cuts.

Remove silence from [recorded interview] while preserving thinking pauses and preventing clipped sentence starts.

Create a concise social clip plan from [approved podcast episode] with accurate context and clear captions.

Compare [automatic multicamera cut] against the conversation to flag mistimed speaker switches.

Prepare sequence settings for [two camera angles and external audio] before automated editing in Premiere Pro.

Review [generated jump cuts] for distracting pacing, broken continuity and speaker overlap.

Write a final export checklist for [edited podcast] covering audio synchronization and cut consistency.

Workflow: Map confirmed meeting decisions to [CRM deal fields], verify contact identity and avoid overwriting unrelated notes.

Compare [sales-call samples] against a documented coaching rubric; cite utterances and identify specific follow-up coaching opportunities.

Summarize [recorded sales discovery call] into verified buyer needs, open questions and agreed next actions.

Create a coaching brief from [sales transcript] with timestamped examples of questioning and objection handling.

Compare [two meeting summaries] against their recordings for invented commitments or missing caveats.

Prepare CRM updates from [customer calls] while distinguishing actual decisions from proposals.

Track recurring topics in [product feedback interviews] with supporting excerpts rather than inferred sentiment.

Build a manager dashboard comparing [deal-related conversation signals] with pipeline stage changes.

Audit [automatic meeting recording] for consent, speaker identification, access permissions and retention.

Set a scheduled monitor for [permitted website metric] and report changes only after checking page structure and extraction errors.

Connect an Axiom extraction to [Google Sheets] using stable IDs, avoiding repeat rows and logging failed exports.

Build a no-code web extractor for [public directory pages] with pagination and source URL capture.

Design a repetitive browser task that copies [approved order statuses] into a spreadsheet without exposing credentials.

Create an error-handling plan for [Axiom bot] when selectors change or a page loads incompletely.

Schedule [authorized price-monitoring workflow] and record when source fields are missing or ambiguous.

Validate [collected tabular data] for duplicate rows, invalid dates and unexpected column shifts.

Document a human approval gate before [web automation] submits forms or changes customer information.

Review [bot execution log] and propose fixes for navigation loops, stale sessions and incomplete exports.

Workflow: Test dynamic prioritization on [five synthetic tasks], inspect dependencies and prevent redundant task creation.

Review a BabyAGI run for stale context or wrong memory retrieval, then propose narrower memory keys and validation.

Prototype a task queue for [five synthetic research jobs] with priority, dependency and termination rules.

Analyze [BabyAGI run log] for duplicate tasks and propose unique task IDs to prevent loops.

Compare the archived original implementation with [new function-based experiment] before recommending integrations.

Design a sandbox test for [agent-generated code] with limited permissions and no production credentials.

Check whether [agent claimed completion] corresponds to actual output files and verified test results.

Investigate stale context retrieval in [toy vector memory] and propose stricter source matching.

Write a research-only safety checklist for [experimental autonomous agent] with cost limits and manual shutdown.

Create a batch of [campaign] creatives through the image API, validating missing variables and ensuring consistent logo treatment.

Design a video render template for [product offer] using approved assets and check output sizing, captions and webhook retries.

Design a reusable banner template with editable [product name], [approved price] and [campaign image] fields.

Create 20 personalized social graphics from [validated spreadsheet] while applying consistent brand safe zones.

Plan an image-generation API integration for [store promotions] with missing-value fallbacks and secure API keys.

Generate variants of [event announcement] for square, landscape and story aspect ratios without cropped dates.

Build a dynamic video-template brief for [product highlights] with fixed logo placement and subtitle checks.

Investigate [failed rendering batch] for broken media URLs, incorrect dimensions and invalid template variables.

Audit [bulk creative output] to identify mismatched product images, altered prices and unreadable text.

Build a browser playbook to extract [meeting notes] and create structured follow-up tasks with explicit owner confirmation.

Review [automation playbook] for unexpected write steps, permissions and brittle selectors before enabling scheduled runs.

Design a browser workflow that captures [authorized prospect-company pages] into [CRM draft table] with source URLs.

Automate [repetitive spreadsheet update] from [approved SaaS source] with duplicate checks and error handling.

Build a playbook to collect [public job listings] and alert only when a relevant posting changes.

Test [browser automation] against missing fields, navigation changes and partial page loads before scheduling.

Map a workflow from [new lead form] to [approved CRM], requiring review before any external outreach.

Audit [Bardeen playbook] for overbroad app permissions, repeated writes and unhandled retries.

Create a daily summary of [approved web research] with timestamps, evidence links and flagged exceptions.

Workflow: Organize [research notes] using a nested tag scheme, maintaining existing backlinks and exporting a sample for review.

Convert [rough meeting note] into a structured Markdown brief with decisions, explicit owners and open questions.

Convert [rough Markdown notes] into a clean outline while retaining code snippets and original meaning.

Create a tag structure for [personal research topics] that avoids redundant nested tags.

Summarize [long meeting note] into decisions and next actions, marking unassigned tasks.

Rewrite [draft essay in Bear] for clarity without changing quoted source passages.

Plan an iCloud sync check for [Bear notebooks] across devices, including offline editing conflicts.

Prepare a Markdown export of [project notes] with embedded images and intact internal references.

Review [writing archive] for duplicate ideas, broken links and notes worth consolidating.

Rewrite [draft memo] for executive clarity while preserving technical terms, numbers and citations.

Create an audio listening brief from [approved text] and proofread names/pronunciation before text-to-speech output.

Summarize [research report] in a concise briefing that separates confirmed findings from unsupported claims.

Compare [two supplied articles] on [topic], preserving source attribution and identifying disagreements.

Rewrite [draft business email] into a polished professional response without changing dates or commitments.

Create an actionable reading plan from [long PDF] organized by key concepts and unanswered questions.

Extract a timeline from [meeting notes], marking missing dates and ambiguous task owners.

Explain [technical paragraph] in plain language while preserving definitions and numerical assumptions.

Prepare a source-grounded outline for [research memo] using only the documents supplied to the desktop assistant.

Workflow: Create three musical variations for [brand video] with the same duration but distinct energy profiles; compare fit against the cut.

Edit generated [cue] to reduce percussion under speech, then inspect ending cadence and license terms before release.

Generate a gentle instrumental bed for [six-minute guided meditation] with a slow tempo and no distracting melodic peaks.

Create a tense, minimal soundtrack for [documentary transition] that gradually builds without overpowering narration.

Compare three mood variants for [product explainer], assessing emotional fit, pacing and sound balance.

Prepare a 30-second cut of [generated background music] with an opening cue and natural ending.

Adjust the instrumentation of [original ambient track] to suit [technology presentation] while keeping the mood consistent.

Review [generated audio] for abrupt loops, clipping and unexpected changes before synchronizing it to video.

Plan the licensing and attribution checks for [commercial video soundtrack] based on the applicable Beatoven terms.

Workflow: Use Smart Slide templates to compare [three options], verify layout after changing text length and image content.

Redesign [existing deck] for a ten-minute presentation, keeping evidence on slides and moving detail into speaker notes.

Turn [approved business update] into a six-slide deck with headline, chart, evidence and a closing ask.

Apply consistent slide layouts to [existing presentation] while preserving brand fonts and approved figures.

Create a comparison slide for [three software options] with user requirements, limitations and sourced facts.

Design an onboarding presentation for [role] with process diagrams and one actionable lesson per slide.

Review [AI-assisted presentation] for tiny labels, unsupported numbers and overloaded content.

Prepare a 10-minute keynote outline from [conference brief] with pacing and transitions.

Export and QA [finished deck] for line breaks, fonts, contrast and chart legibility.

Workflow: Plan a consent-controlled calendar action for [appointment], requiring confirmation of date, timezone and invitees before creation.

Design a custom fictional [avatar] with personality, boundaries and memory preferences, then test whether private facts are repeated unexpectedly.

Create a weekly personal planning conversation around [user-defined goals] and ask before saving new preferences.

Review [previously saved preference summary] for contradictory details and ask the user to correct errors.

Prepare a permission-gated calendar action for [appointment] confirming timezone, title and participants first.

Design an original avatar for [language learning] with user-controlled personality and memory boundaries.

Test proactive check-ins for [opt-in habit], avoiding repeated notifications or assumptions about mood.

Create a privacy review of [assistant memory], separating details needed for reminders from sensitive context.

Draft a reflective dialogue for [stressful day] that asks useful questions without pretending to diagnose.

Build a load-test plan for [BentoML endpoint], measuring p50/p95 latency, error rate and adaptive batching effects.

Workflow: Prepare a containerized release of [model version], verify output consistency against local predictions and define rollback.

Package [trained classifier] as a BentoML service with declared input types and reproducible dependencies.

Define inference request validation for [model endpoint], including malformed payloads and clear errors.

Benchmark [model serving setup] under realistic batch sizes, reporting throughput and tail latency.

Create deployment health checks for [Bento service] with warm-up and failure behavior.

Review [containerized model build] for unnecessary packages and oversized assets.

Compare CPU and GPU serving for [approved model] using measured latency and capacity.

Plan canary rollout of [new model version] with validation and rollback triggers.

Generate focused unit tests for [existing function] using the repository's framework and preserving behavior.

Explain [legacy module] and suggest a minimal refactor with test plan rather than replacing unrelated files.

Generate unit tests for [existing service function] covering null inputs and authorization boundaries.

Explain the control flow of [unfamiliar module] using actual code references and dependencies.

Review [pull request] for injection risks, insecure defaults and missing regressions.

Refactor [repeated utility functions] while preserving exported APIs and test results.

Draft inline documentation for [complex algorithm] explaining inputs, outputs and edge cases.

Investigate [runtime exception] using stack traces and relevant source files before proposing a patch.

Compare [two implementation choices] for performance, clarity and maintenance costs based on the actual code.

Investigate [error trace] and propose a minimal patch supported by inspected source files.

Explain a [complex function] to a teammate, identifying inputs, side effects and likely edge cases without inventing dependencies.

Locate the likely defect causing [failing unit test] by inspecting referenced repository code and dependencies.

Benchmark [two coding models] on the same [parsing bug] using objective passing tests and invalid-import counts.

Generate boundary-case tests for [authentication helper] including expired tokens, absent roles and malformed input.

Explain [unfamiliar module] with its actual inputs, side effects and expected return values.

Plan a targeted refactor of [data-access module] that preserves external APIs and runs regression tests.

Review [generated pull request] for unsafe dependencies, hallucinated methods and unintended file changes.

Evaluate [model routing for developer tasks] using latency, output accuracy and confidentiality requirements.

Create a credential-handling checklist for [RPA process], avoiding hardcoded secrets and defining audit logging.

Analyse [control room run history] for exceptions and recovery time, proposing idempotent retries for safe steps.

Design an RPA workflow for [invoice intake] with human approval on unmatched supplier records.

Document exception paths for [purchase-order matching] including duplicates and incorrect tax fields.

Create a credential-handling checklist for [automated ERP process] using vault-managed access.

Plan a process discovery session for [manual reconciliation task] with measurable steps and failure cases.

Test [digital worker] against missing attachments, timeouts and concurrent file updates.

Design operational monitoring for [unattended automation] with run logs and escalation thresholds.

Prepare a controlled release and rollback plan for [Blue Prism process change].

Create three stylistic variations of [original character], keeping costume and silhouette consistent while varying lighting.

Workflow: Upscale the selected concept and inspect edges, small details and unintended artifacts before print use.

Generate an original fantasy landscape of [floating islands] with dramatic dawn light and no text.

Create a monochrome concept illustration for [fictional detective] with noir contrast and rain.

Explore three distinct aspect ratios for [original botanical artwork] while keeping the subject in frame.

Draft a visual prompt for [minimal geometric logo concept] without copyrighted symbols or lettering.

Create a consistent image series showing [original robot character] from three camera angles.

Review [image outputs] for distorted hands, strange object counts and accidental textual artifacts.

Prepare a high-resolution artwork brief for [poster scene] with foreground depth and restrained color.

Add [feature] to the generated [React app], preserving current routes and writing smoke tests for main interactions.

Diagnose [build failure] using terminal logs and source files; apply the smallest dependency or code fix and re-run checks.

Create a responsive prototype for [task tracker] with mock data, filters and validation states.

Build a simple [expense dashboard] with a transparent data model and no real bank connection.

Review [generated full-stack code] for exposed secrets, broken authorization and missing error handling.

Plan database tables for [booking application] with explicit uniqueness and conflict checks.

Create a test checklist for [app prototype] covering empty states, mobile navigation and form failures.

Refactor [generated component] for maintainability without changing observable behavior.

Prepare a deployment readiness assessment for [Bolt app] including environment variables and rollback.

Summarize [five saved articles] into a source-linked comparison of their main claims, publication dates and unresolved questions.

Workflow: Search bookmarked content for [concept] and assemble a reading collection with evidence notes for each link.

Auto-categorize [saved research links] by subject with explicit rules for ambiguous pages.

Create a reading digest from [saved articles] retaining publisher, author and publication date.

Find [previously bookmarked API documentation] using natural-language search and verify the matching version.

Flag duplicate saved URLs that have different tracking parameters but the same underlying article.

Build a review queue for [dead or redirected bookmarks] before bulk cleanup.

Prepare a source library for [writing project] with topic tags, annotations and useful excerpts.

Evaluate [AI bookmark summaries] for invented details, stale content and missing author attribution.

Workflow: Edit the generated track into intro, middle and outro sections, checking seamless transitions and consistent loudness.

Review the distribution workflow for [song], validating credits, rights and metadata before any publication.

Generate an instrumental music sketch for [upbeat product reveal] with a short introduction and clear hook.

Explore three mood variations of [original background track] without imitating a named living artist.

Structure [AI-generated song] with intro, verse, chorus and outro appropriate to [duration].

Review [created track] for abrupt transitions, clipping and inconsistent musical style.

Prepare a licensing and distribution checklist for [AI-assisted song] before uploading to streaming services.

Adapt [original audio arrangement] to a shorter social-video version with coherent ending.

Compare [two generated track variations] for instrumentation, dynamics and fit with a campaign brief.

Workflow: Build an order-status flow that asks for appropriate verification and uses a read-only API before revealing details.

Test [Botpress conversation] with ambiguous, multilingual and adversarial questions; capture failed tool calls and unsupported answers.

Build a conversational flow for [product troubleshooting] using approved help articles and escalation.

Design a bot knowledge source for [FAQ documents] with citations and stale-content safeguards.

Set up an authenticated tool call for [order lookup] with input validation and least privilege.

Test [Botpress workflow] with ambiguous user intents, missing data and API timeouts.

Create a multilingual support journey for [billing inquiry] that preserves policy meaning.

Analyze [chatbot transcripts] for failed handoffs and repeated unsupported answers.

Prepare a deployment checklist for [website bot] with environment, monitoring and human ownership.

Compare my solution [working] against [correct method], identify my first error and give two similar practice questions.

Build a short study plan for [science topic] with five progressively harder checks and brief explanations of wrong answers.

Explain [algebra problem] with each transformation justified, then give me a similar question to try alone.

Guide me through [physics exercise] using hints first and check my reasoning before showing a full solution.

Compare [two answers to biology homework] against the course text and explain which claims need correction.

Create a practice quiz on [chemical reactions chapter] with answer explanations and common misconceptions.

Turn [uploaded study notes] into key definitions, worked examples and spaced recall questions.

Identify where my [geometry proof] skips a logical step and suggest a smaller intermediate claim.

Prepare a revision schedule for [exam topics] using questions I got wrong and time until the test.

Compare sentiment around [launch] before and after its date; inspect underlying posts rather than relying only on automated sentiment.

Identify recurring customer complaints from [mention feed], group by evidence-backed theme and surface urgent escalation cases.

Track [brand name] mentions for [country and language] and separate customer questions from unrelated name matches.

Create a reputation-monitoring brief using [negative sentiment mentions] with links and human review before public replies.

Compare [campaign mention volume] against a matched baseline period, accounting for spikes from paid promotion.

Find journalists and industry websites discussing [topic] and assess relevance without claiming endorsement.

Set up alerts for [product launch] that prioritize high-reach mentions and filter duplicate syndicated coverage.

Build a weekly social listening report with source URLs, sentiment caveats and the top unanswered questions.

Review [competitor brand mentions] to identify frequently discussed features without inferring private market share.

Workflow: Compare palettes and typography for a [minimalist brand] identity, checking contrast and readability at favicon size.

Prepare a brand kit from selected logo assets for business card and social profile uses; verify spacing and image export quality.

Explore logo concepts for [new studio] using approved business name, sector and design personality.

Generate three restrained color directions for [identity brief] and assess contrast on light and dark backgrounds.

Compare [logo variants] for legibility at favicon size and clear monochrome reproduction.

Plan typography pairing for [brandmark] that communicates [desired brand attributes] without imitating competitors.

Prepare business card layouts from [approved logo and contact details] with safe print margins.

Create social profile asset specifications for [brand] with consistent cropping and background handling.

Review exported [logo kit] for vector quality, licensing rights and missing color variations.

Create a listening dashboard for [campaign] with topics, sentiment shifts and influential discussion threads, checking sample bias.

Workflow: Draft a weekly social publishing plan from [approved campaigns], checking audience fit and brand approvals before scheduling.

Analyze [consumer conversations] about [product category] and cluster recurring needs with quoted public examples.

Compare sentiment by [social channel] using consistent sampling and distinguish automated from human content.

Build an audience insight brief for [campaign] based on observed interests rather than sensitive inferred traits.

Plan a crisis-monitoring dashboard for [brand incident] with source verification and escalation criteria.

Review [social engagement performance] across two campaigns, separating organic reach from paid exposure.

Create a publishing calendar informed by [topic trends] and approved messaging, with human review checkpoints.

Audit [Brandwatch report] for irrelevant keyword matches, duplicate posts and demographic overinterpretation.

Based on the open article [topic], identify three questions whose answers require sources outside this page.

Rewrite [selected paragraph] in plain language for [audience] while preserving factual qualifiers and linked references.

Summarize [current web article] in Brave Leo while preserving direct links to supporting passages.

Explain [complex technical webpage] in simple terms and identify information that needs verification.

Compare claims on [two open tabs] and mark disagreements rather than presenting a single unverified conclusion.

Draft a short reply to [approved forum post] without including private browsing context.

Prepare a browser-based study guide from [public tutorial], noting steps that may depend on software version.

Check a generated answer about [recent regulation] against dated official sources available in the page.

Review browser AI privacy settings and document which information is shared during [requested feature].

Workflow: Set up a welcome automation for [consented subscribers] with segmentation, suppression lists and clearly defined exit conditions.

Review [email campaign] results by delivered, opened and clicked counts, correcting for bot opens before making optimization decisions.

Draft a welcome email for [new subscribers] using verified product benefits and consent-based messaging.

Create two subject-line tests for [newsletter] with a defined hypothesis and no false urgency.

Prepare a behavioral segment for [customers] from permitted events and documented criteria.

Design a sending-time experiment for [email campaign] that accounts for timezone and sample size.

Generate a follow-up sequence for [webinar registrants] with correct dates and opt-out handling.

Review [contact list] for duplicates, unsubscribed recipients and inconsistent consent flags.

Summarize [campaign results] using delivered, opened and clicked counts without claiming causality.

Summarize spending by [department and category] against approved budgets, flagging currency differences and uncategorized amounts.

Workflow: Investigate a suspicious [transaction pattern] using documented policy rules; mark ambiguous entries for human finance review.

Classify [employee expense batch] using approved policy categories and flag receipts with incomplete evidence.

Review [corporate card transactions] for unusual amounts and duplicates before proposing an investigation.

Summarize [department spend] compared with monthly budget, distinguishing committed and settled charges.

Prepare an exception queue for [out-of-policy purchases] that preserves employee explanations and review ownership.

Reconcile [receipt and transaction data] using merchant, currency, date and amount with tolerances.

Create a forecast brief for [upcoming travel costs] from approved booking estimates and historical ranges.

Audit [expense automation rules] for misclassified merchants, unexpected approvals and exposed financial details.

Schedule a daily monitor for [product price], compare against the previous snapshot and alert only on genuine changes.

Workflow: Export [public table data] to [destination] using a webhook; validate missing fields, retries and source usage permissions.

Train a point-and-click robot to extract [public product prices] with product URL and timestamp for each row.

Monitor [authorized availability page] and alert only when the item changes from unavailable to available.

Handle pagination and dynamically loaded cards for [public directory] without capturing private data.

Validate [scraped dataset] for duplicated pages, shifted columns and price/currency mismatches.

Send extracted [public research data] to [approved spreadsheet] with idempotent keys and failure logging.

Review [website monitor failures] to distinguish layout changes, rate limits and inaccessible pages.

Design a recurring extraction schedule for [public source] that honors access rules and avoids unnecessary load.

Configure a monitor of [authorized site data] with scheduled exports, duplicate handling and webhook error logging.

Test [browser automation] against pagination and missing fields using a small sample before increasing the collection scope.

Define an experimental browser task collecting [public event listings] with URLs and a bounded page limit.

Test navigation through [paginated public catalog] and stop when access is restricted or a required field is absent.

Record a read-only sequence of browser actions for locating [published documentation] without submitting forms.

Diagnose a [browser automation loop] by inspecting repeated clicks, redirects and failed element selections.

Plan a change alert for [authorized webpage] with sensible checking frequency and duplicate notification suppression.

Create a manual review rule for [extracted data] whenever records have missing dates or uncertain provenance.

Review [experimental extension permissions] before accessing pages containing credentials or personal information.

Repurpose [blog paragraph] into a concise caption and follow-up question, maintaining factual accuracy and the supplied brand voice.

Review [scheduled post copy] for length, tone and accessibility; provide revised text while preserving dates and URLs.

Create three posts introducing [verified product benefit] with distinct educational, practical and story-based angles.

Repurpose [approved webinar recap] into concise LinkedIn and Instagram captions without new claims.

Revise [social draft] for a calmer professional brand voice while retaining dates and numbers.

Generate a week's posting ideas from [content pillars], excluding topics already published.

Rewrite [long announcement] as a short social update with a clear link and accessible language.

Compare two alternative hooks for [industry advice post] for clarity rather than clickbait.

Review [AI-generated captions] for unverified metrics, poor accessibility and repetitive wording.

Build a landing page from [approved content] using the CMS visual editor, checking desktop and mobile parity.

Review generated [React component] for keyboard operation, validation and state handling before deployment.

Turn [approved Figma layout] into a responsive component draft with clear mobile breakpoints.

Create a landing page component structure for [verified SaaS offer] with reusable sections.

Review [generated React code] for accessibility labels, state behavior and unused dependencies.

Plan a visual editing workflow for [marketing page] that preserves approved design tokens.

Map [existing CMS content] into components while preserving URLs and SEO metadata.

Compare [Figma source] with [generated page] for spacing, typography and interaction mismatches.

Build a regression checklist for [page redesign] before deploying to production.

Connect [form webhook] to [database] through a workflow; handle duplicate events, authentication and failed writes explicitly.

Prototype an AI step that classifies [support messages] into approved categories, then test uncertain cases before deployment.

Create a server-side endpoint that accepts [customer inquiry form] and validates required fields before database writes.

Design a visual workflow for [new order webhook] that handles duplicate events and safe retries.

Connect [approved Supabase tables] to [read-only dashboard API] with role-scoped access.

Test [BuildShip flow] under third-party API timeout, malformed JSON and missing credentials.

Use a generated code node to transform [structured event payload] while recording errors and schema checks.

Plan a Firebase-backed [appointment request] endpoint with consent, authentication and rate limits.

Review [workflow execution log] to identify failed nodes, repeated requests and unverified completion.

Prepare a Shopify blog post for [topic], including factual source links and editorial approval before publication.

Audit [article batch] for overlapping headings, duplicated prose and unsupported statistics.

Build an SEO article outline for [buyer query] using verified sources and unique product examples.

Create a bulk content brief template that requires original evidence and human editorial sign-off.

Review [AI-generated article batch] for duplicated paragraphs, unsupported claims and stale pricing.

Prepare a Shopify blog publishing checklist including categories, internal links and canonical intent.

Rewrite [thin informational draft] with grounded examples and clear answer-first structure.

Compare [two similar posts] for search intent overlap and opportunities to consolidate.

Plan an editorial update workflow for [older posts] with source refresh, fact checks and final approval.

Summarize [interpreted meeting] into decisions, open questions and attributed owners with uncertainty notes.

Compare original and translated [event notes] for names, numbers and meaning shifts before sharing.

Prepare a terminology sheet for interpreting [technical conference] across [two languages], including acronyms.

Test an interpreted [remote meeting] on proper names, figures and units against the source audio.

Design a two-language attendee workflow for [hybrid seminar], covering audio routing and speaker consent.

Review the summary of [board discussion] to separate approved decisions from ideas merely discussed.

Check [translated presentation excerpt] for omitted negations and changed contractual meaning.

Create a review queue for [overlapping speakers] and inaudible passages instead of presenting guesses as fact.

Produce a bilingual follow-up memo from [meeting record], identifying action owners only where named.

Configure a read-only MCP connection for [authorized database] and test denied or missing-data cases.

Divide [multimodal brief] into text, image and audio tasks with clear model selection and output verification.

Compare [two text models] answering the same question from [provided manuals]; score citation fidelity and omissions.

Select models for a [launch brief] requiring a written script, still image and video; specify handoff assets.

Configure an MCP read-only lookup against [approved inventory database], restricting fields and handling missing records.

Evaluate model outputs for [customer FAQ] against policy sources, rejecting fabricated entitlements.

Write an image-generation brief for [original event poster] with composition, palette and aspect ratio.

Build a side-by-side benchmark for [multilingual support task], measuring accuracy, latency and malformed responses.

Audit [multi-model MCP workflow] for data disclosure, duplicate tool calls and unapproved write permissions.

Create a square promotion for [event] with [brand colors] and supplied logo; reserve large readable areas for date, location and CTA; maintain logo proportions.

Magic Edit: select [object] in the supplied photograph and replace it with [object], matching lighting, scale, camera angle and existing shadows.

Create a one-page flyer for [offer] using three supplied benefits, verified price if given and [contact channel]. Use mobile-readable type and clear information hierarchy.

Resize this existing 1080×1350 campaign design for a 9:16 story. Maintain text safe areas, preserve brand identity and inspect important content for cropping.

Create a product feature comparison infographic using [verified data], with accessible contrast and exact units.

Use Magic Write to turn [approved workshop notes] into a short handout with headline, agenda and three takeaways.

Prepare a ten-page branded template for [training guide], preserving typography, icons and a consistent content grid.

Generate an original editorial illustration for [technology article] that avoids invented UI screenshots or trademarked assets.

Review [Canva video draft] for mobile caption legibility, incorrect auto-generated text and export-safe placement.

Use Magic Switch to turn [presentation] into a concise handout preserving source links and key figures.

Use Magic Media to generate a [campaign] backdrop while preserving the supplied product image and brand palette.

Create a social design for [approved event] using the brand palette and readable visual hierarchy.

Generate a presentation structure for [training agenda] with one clear takeaway per slide.

Use Magic Write to draft three caption variants from [verified product description].

Plan a Magic Media visual prompt for [original abstract background] without text or logos.

Adapt [approved campaign art] to multiple formats and check for clipped legal information.

Extend [licensed hero image] to widescreen while preserving subject proportions.

Review [AI-generated marketing assets] for wrong text, invented product details and brand consistency.

Turn [daily notes] into linked action records with status and provenance; do not invent deadlines or owners.

Build a dashboard for [active projects] using object queries and verify that archived work is excluded.

Create person, meeting and project object types for [research collaboration] with useful relations.

Turn [daily notes] into linked project decisions and tasks without inventing commitments.

Use bi-directional links to trace which [reference documents] support [project proposal].

Build a collection view showing [reading items] by status, source and next action.

Review [knowledge graph] for duplicate people, disconnected objects and ambiguous relationships.

Design a note-taking template for [conference talk] with speakers, key claims and follow-up questions.

Prepare an export or backup plan for [knowledge workspace] preserving objects, relationships and attachments.

Design a safe [account support] flow with identity checks and human escalation for restricted actions.

Review unresolved [support searches] for gaps, stale articles and conflicting policies.

Build a support knowledge workflow for [HR policy inquiries] with versioned sources and authentication.

Design an automated response flow for [customer account issue] that escalates sensitive actions.

Create a knowledge article intake process for [new support documentation] with approval gates.

Test [AI support answer] against conflicting documents and require citation-backed responses.

Review [support automation] for least-privilege access to customer and employee information.

Analyze [unresolved ticket categories] to identify repeatable knowledge gaps.

Plan a safe integration between [helpdesk] and [approved internal database] with error handling.

Create subtitles for [interview] and proofread names, timestamps and line lengths.

Remove [background] from [consented clip] and check subject edges and frame-to-frame consistency.

Edit [authorized travel footage] into a 20-second vertical montage with consistent pacing.

Generate captions for [spoken product demo] and correct brand names before publishing.

Remove the background from [owned product clip] and check edges in motion.

Apply subtle keyframe zooms to [interview excerpt] without distracting from the speaker.

Plan a text-to-speech voiceover for [approved tutorial script] with accessible subtitles.

Match the color of [two video shots] while keeping skin tones natural.

Create a final QA checklist for [social export] covering aspect ratio, licensed audio and safe zones.

Design a sales pipeline for [service] with stage exit criteria and next-action reminders.

Audit [stalled opportunities] for missing activities and confirm responsible owners before reassignment.

Create a CRM pipeline for [consulting leads] with clear stages and required qualification fields.

Review [contact records] for duplicates, incorrect company links and missing next actions.

Plan a follow-up task sequence for [sales opportunity] using only agreed dates and ownership.

Draft a CRM account summary from [verified emails and notes], marking uncertain details.

Build a workflow for [new inquiry] that assigns review responsibility and prevents duplicate outreach.

Compare [pipeline segments] by stage age and response activity without inventing conversion outcomes.

Prepare a monthly sales report from [opportunity data] with consistent close-date and value definitions.

Dub [training clip] into [target language] using the approved translation and quality checks.

Review AI eye-contact correction on [video], comparing natural facial movement with the original.

Add accurate animated subtitles to [approved interview clip] while protecting title-safe areas.

Prepare [social video] for localization into [target language] with terminology and dubbing review.

Edit [talking-head clip] into a 30-second summary preserving the speaker's factual meaning.

Compare [two caption styles] for mobile readability, pace and brand consistency.

Plan a video edit using [approved script] with B-roll that does not misrepresent the product.

Review [AI eye-contact adjustment] for unnatural facial artifacts and identity changes.

Export versions of [creator video] for different formats and check caption cropping.

Benchmark streaming speech responses on [test phrases], including first-audio latency and interruptions.

Compare voice tone settings for [customer greeting] while retaining an accessible written transcript.

Design low-latency speech output for [voice assistant] with defined chunking and interruption behavior.

Generate narration from [approved script] and review pronunciation of [brand names] before release.

Evaluate [speech model] under [network constraints] for time to first audio and dropped frames.

Prepare a voice-cloning consent checklist for [authorized speaker] and permitted distribution.

Compare expressive voice settings for [customer-service greeting] while keeping the content unchanged.

Create a streaming audio integration plan using [documented API] with retries and secret handling.

Inspect [generated voice sample] for unnatural pauses, instability and incorrect words.

Investigate rework loops in [procurement workflow] by comparing process variants and quantifying delay per transition.

Establish a baseline for [approval bottleneck], simulate a proposed change and track impact after controlled rollout.

Map [purchase-to-pay process] from event logs and identify the highest-frequency rework loops.

Compare actual [invoice approval paths] to documented process rules, separating exceptions from errors.

Investigate [late-order fulfillment] using case-level timestamps and bottleneck analysis.

Design a process KPI dashboard for [order-to-cash] using consistent start, end and exclusion definitions.

Prepare an automation proposal for [manual reconciliation] with estimated effort clearly marked as a hypothesis.

Review [process-mining model] for missing event IDs, duplicate case keys and timestamp inconsistencies.

Create an approval checklist before [process automation] triggers changes in production systems.

Start a CHAI conversation with [community-created fantasy character] and ask for a cooperative quest that offers choices without deciding my character's actions.

Develop a CHAI roleplay scene set in [fictional city] where the character reveals its motives gradually through dialogue instead of long exposition.

Use CHAI to explore two community characters in the [mystery] genre and compare how consistently each stays in character over five exchanges.

Write a CHAI character introduction that establishes [setting], [relationship to the player] and a clear first decision without relying on generic greetings.

Continue this CHAI detective storyline [previous scene summary] while preserving the confirmed clues and leaving the final solution open to investigation.

Design a CHAI conversational character who teaches [fictional world history] through brief in-world dialogue and admits what they do not know.

Create a CHAI fantasy rival with a believable goal and changing attitude, using respectful dialogue and avoiding abrupt personality shifts.

Set up a CHAI collaborative storytelling session with [two adult fictional roles], alternating perspectives and maintaining a running summary of events.

Review my CHAI character concept [description] for contradictory motivations, repetitive dialogue habits and missing details needed for coherent interactions.

Roleplay a practice conversation with fictional [customer persona] raising realistic objections, then give feedback afterward.

Define guidelines for a [fictional character] with personality, boundaries, unsupported-claim handling and a clear in-character exit.

Design an original fictional tutor character for [language] with a supportive tone and fixed learning boundaries.

Create a role-play conversation with [fictional detective] solving a mystery using only details provided in the scene.

Build a character persona sheet including background, voice, interaction goals and prohibited content.

Practice a job interview with [professional role-play character] that asks one question at a time.

Test consistency of [original character] across ten prompts and identify contradictions in its backstory.

Plan a shared group-chat scenario with [three original characters] and distinct speaking styles.

Review [character chat] for misleading claims about being a real professional or possessing private knowledge.

Write ten evaluation questions against [knowledge-base pages], including out-of-scope cases, and inspect citation accuracy.

Configure lead capture in a website chatbot using explicit consent, minimal fields and tested human handoff.

Create a custom help bot from [approved product documentation] with citation-backed answers and abstention rules.

Configure [website support widget] to route pricing questions to current official pricing sources.

Build a lead capture interaction for [business service] using minimal form fields and clear consent language.

Test [knowledge bot] with questions unsupported by the uploaded files and verify it does not invent answers.

Prepare a version-refresh procedure for [outdated PDF knowledge source] including reindex and spot checks.

Analyze [chatbot conversation report] for unanswered queries, misleading replies and escalation rates.

Review [embedded bot] on mobile for readable text, input focus, accessible controls and privacy disclosure.

Design a website lead capture conversation with minimal fields and explicit consent.

Test the support chatbot using 15 ambiguous cases, measuring unsupported answers and failed escalations.

Design an AI support agent for [order-status questions] with authenticated lookups and human fallback.

Create a no-code bot flow for [return-policy queries] using only approved policy articles.

Test [website chatbot] on conflicting questions and cases requiring an agent takeover.

Draft a proactive support message for [checkout help] without misleading urgency or promises.

Set up knowledge-base review criteria for [support answers] with citations and version dates.

Analyze [bot conversation sample] for unrecognized intents, repeated transfers and unclear responses.

Prepare a release checklist covering widget display, privacy, escalation and failed integrations.

Design an Instagram FAQ automation based on [approved answers], routing billing ambiguities to a live agent.

Connect a chatbot result to [Google Sheets], validate field mapping and opt-out behavior before enabling messages.

Design a WhatsApp appointment inquiry flow for [local service] with verified business hours and human handoff.

Create an Instagram messaging sequence for [product FAQ] that uses only approved product information.

Map a lead qualification conversation for [consented prospects] with a clear opt-out and no repetitive messages.

Connect [approved spreadsheet] to a support workflow and validate incoming contact identifiers before lookup.

Test [Chatfuel bot] with ambiguous phrases and different languages, recording unmatched intents.

Create a recovery path when [customer asks for human assistance] and the bot has insufficient context.

Review [broadcast campaign] for recipient consent, factual offer details and duplicated sending.

Debug this [language] code and failing test: [code/log]. Identify the smallest reproducible cause, show a minimal patch, and write tests for success, edge cases, and regression. Do not assume unshown files.

Analyse the uploaded [CSV/table] for [business question]. Check missing values and inconsistent units first, calculate the key metrics, and return a compact findings table with assumptions and caveats.

Create three original launch-email opening paragraphs for [product], targeting [audience]. Vary the angle (problem, proof, curiosity), keep each under 75 words, and avoid unverified performance claims.

Critique this plan as a skeptical reviewer: [plan]. Identify five risky assumptions, the evidence needed to test them, likely failure modes, and a prioritized low-cost validation plan.

Develop a home exercise plan around [equipment and schedule], explaining sets, repetitions and progression without inventing abilities.

Turn [uploaded meeting minutes] into a decision register with supporting quotations and clearly unidentified owners.

Design a simple program to validate [CSV import] for duplicate IDs, date formats and missing required fields.

Research [two competing SaaS options] against a verification checklist, prioritizing official product sources and costs.

Create a step-by-step usability test for [landing page] with five realistic user tasks and measurable success criteria.

Compare two model explanations of [stack trace] side by side, verifying proposed fixes against test results.

Apply one saved [document review] prompt across supported models; check completeness and source fidelity.

Ask the same [technical question] to two selected chat models and compare accuracy against a supplied source.

Create a prompt-library template for [customer reply editing] with tone, factual constraints and output structure.

Test parallel model responses on [ambiguous request] and identify hallucinated assumptions.

Prepare a side-by-side comparison for [coding task] using passing tests rather than writing style.

Review exported [multi-model conversation history] for personal details before sharing it.

Design a repeatable benchmark of [research summaries] that checks citation validity and timeliness.

Organize frequently used prompts by [writing, coding and research workflow] while avoiding duplicate instructions.

Compare two sections of [contract PDF] for inconsistent dates or obligations, quoting the relevant passages.

Create a study guide from [lecture PDF] with source-linked definitions and five comprehension questions.

Extract assumptions from [uploaded annual report PDF] with precise page references for every figure.

Compare [two research PDFs] on research methods and limitations with linked source passages.

Create a study quiz from [lecture PDF] with answers grounded in its text.

Locate termination clauses within [contract PDF] and flag any referenced but missing appendix.

Summarize [scanned manual PDF] while noting tables and text that may have extraction errors.

Build a financial table from [statement PDF] retaining units, footnotes and reporting periods.

Audit [ChatPDF answer] against the original for fabricated passages and excessive certainty.

Research [recent industry update] using dated sources, distinguishing confirmed events from commentary.

Summarize [uploaded report] into claims, cited evidence, assumptions and follow-up questions for [team].

Research [software comparison topic] using current original sources and flag conflicting vendor claims.

Prepare an FAQ from [approved support document] with each response linked to its source.

Compare [two article drafts] for accuracy, reader intent and redundant paragraphs.

Rewrite [brand announcement] into three social captions maintaining factual consistency.

Create a sourced summary of [industry update] distinguishing publication date from event date.

Plan a multilingual content outline for [buyer persona] without inventing pricing or product guarantees.

Audit [search-augmented answer] for dead citations, unsupported conclusions and omitted caveats.

Start a ChatUp story where a team of adult fictional explorers discovers [ancient ruin], and offer choices without narrating my character's actions.

Generate a ChatUp AI image of [original fantasy character] with [style and lighting], then check that its appearance matches the textual character card.

Use ChatUp's image generator to create three safe costume concepts for [fictional hero], keeping facial features and core accessories consistent.

Create a non-explicit ChatUp AI romance scenario between consenting adults in [fictional setting] with believable conflict and gradual dialogue.

Draft a ChatUp video-generation concept for [fantasy landscape] with a slow camera movement, stable horizon and continuity with a reference frame.

Write a ChatUp mystery companion who reveals [setting-specific clues] only when the player's questions justify it, avoiding an immediate solution.

Request a ChatUp AI character conversation in [target language] that practices simple everyday phrases while remaining in a fictional story context.

Create a ChatUp face-swap experiment using only [my own authorized portrait] and [an image I own], preserving consent and avoiding misleading publication.

Audit a ChatUp roleplay transcript [excerpt] for contradictions, repeated phrasing and abrupt changes in personality, then propose a clearer scene setup.

Compare [won and lost call samples] against an agreed coaching rubric, noting small-sample limitations.

Transfer approved call takeaways to [CRM] only after checking account mapping and explicit commitments.

Review [sales call transcript] and identify actual buyer objections with timestamped supporting excerpts.

Create a coaching scorecard for [discovery call] using observable questions and next-step clarity.

Summarize [deal-related meetings] into confirmed commitments and unresolved buyer questions.

Compare [successful and stalled sales conversations] for recurring themes without assuming causal effects.

Extract [competitor mentions] from recorded calls and validate the context before updating battlecards.

Prepare CRM notes from [customer conversation] with accurate account identity and outcome status.

Audit [conversation intelligence dashboard] for transcription errors, attribution limitations and consent handling.

Build a retrieval test from [labeled questions], inspecting top-k matches against expected source passages.

Delete and reindex changed [document] with stable IDs; verify stale embeddings no longer appear in searches.

Set up a Chroma collection for [internal policy chunks], including stable IDs and source metadata.

Compare semantic retrieval for [support questions] using two chunking strategies and a held-out set.

Build a metadata filter for [approved document category] and verify unrelated sources remain excluded.

Prepare a safe update process for [changed handbook section] that replaces stale embeddings.

Test persistence of [local vector collection] across restarts and recovery from partial ingestion.

Analyze [retrieval misses] by inspecting original text, generated embeddings and distance ranking.

Design a privacy check for [multi-project vector database] that prevents cross-project source disclosure.

Draft a first-pass [agreement type] for a startup using Cimphony. Include the core clauses, assumptions, and a checklist of points to confirm with counsel.

Use Cimphony to review this contract clause for business risks, missing protections, and ambiguous language: [paste clause].

Create an employee onboarding document set for a [team size]-person company with Cimphony, covering the essential HR documents and policy acknowledgements.

Use Cimphony to summarize the legal meaning of this webpage or policy in plain English: [paste text or URL content]. Flag anything that needs professional legal advice.

Build a contract-review checklist in Cimphony for [vendor/customer/employee] agreements, ranked by business impact.

Use Cimphony to compare these two contract versions and identify material changes in obligations, liability, payment, termination, and data handling: [paste versions].

Create a legal-document request list for a startup preparing for [fundraising/due diligence/a new hire/a vendor deal] using Cimphony.

Use Cimphony to turn these business terms into a structured draft agreement outline: [terms]. Highlight missing commercial details before drafting.

Create a recurring legal-operations workflow with Cimphony for contract intake, review, approval, signature, and document tracking for a [company type].

Organize [research project] into sources, quotations, evidence notes and linked tasks.

Generate citations for [manuscript] using [style], then verify source identifiers and formatting.

Import [reference library] and resolve duplicate citations using DOI, title and publication dates.

Organize [research papers] by methods, claims and evidence gaps with linked source notes.

Create a structured reading plan for [thesis question] using verified abstracts and relevance criteria.

Extract quotations from [annotated PDF] while preserving page numbers and author attribution.

Build an outline for [literature review] that groups findings by research question rather than author.

Check [Word manuscript citations] for missing bibliography entries and inconsistent reference metadata.

Prepare a research project handoff with sources, outstanding questions and tasks from [Citavi collection].

Create an original [fantasy scene] with consistent palette, composition and model settings.

Compare [LoRA] output against a fixed seed and base prompt to identify artifacts and style drift.

Find a model suitable for [original landscape illustration] and review license, version and example outputs.

Compare [two image model versions] for visual style, hardware requirements and licensing restrictions.

Draft a reproducible generation setup for [character concept] with model, sampler, seed and dimensions.

Review [LoRA asset] for permitted uses, trigger words and compatibility with the base checkpoint.

Build a collection of [authorized visual references] with attribution and restrictions noted.

Audit [generated image batch] for unstable anatomy, unintended text and inconsistent style.

Prepare a responsible model-sharing checklist for [trained creative asset] covering rights and example provenance.

Reconcile [forecast] against recorded activity and separate measured trends from managerial assumptions.

Brief [revenue team] on deal risks using confirmed customer evidence and unresolved questions.

Analyze [pipeline snapshot] for stalled opportunities using recorded stage changes and activity dates.

Prepare a forecast review for [sales team] distinguishing committed revenue from uncertain deals.

Compare [forecast this week] with [previous forecast] and identify evidence-backed movement drivers.

Flag [deals missing recent activity] for manager review without assuming they will be lost.

Create a weekly revenue meeting brief from [CRM records] with owner-specific follow-up questions.

Audit [deal hygiene] for duplicate opportunities, inconsistent amounts and missing close dates.

Evaluate [pipeline coverage] by segment and note data limitations before recommending action.

Using the files in this Project, produce an evidence-linked decision memo for [stakeholders] comparing [option A] and [option B]. Separate facts, assumptions and open questions; finish with a decision checklist.

Build a self-contained interactive HTML prototype in an Artifact for [workflow]. Include keyboard-accessible controls, realistic empty/error states and sample data; explain which functionality remains simulated.

Review this [language] pull request: [diff and relevant files]. Identify behavior changes, security risks and broken edge cases, then propose the smallest patch and regression tests without inventing repository context.

Summarize this long document [upload] into a traceable brief: claim, cited section, implication and verification needed. Preserve uncertain details and clearly mark anything not contained in the document.

Compare [two implementation designs] using [source files and constraints], identifying integration hazards and how to verify them.

Design a reusable document review prompt that extracts [contract requirements] with precise passage citations and exception handling.

Build a bounded research workflow for [technical question] that separates confirmed source statements from hypotheses.

Explain [failing integration test] using only the provided repository files and propose the smallest testable correction.

Rewrite [sensitive stakeholder message] for clear professional tone while preserving uncertainties and the actual decision needed.

Implement [feature] across only necessary files, checking permissions before destructive commands.

Review [Git diff] for security, edge cases and unintended changes with file-level evidence.

Inspect [repository failing test] and propose a minimal patch consistent with existing conventions.

Create regression tests for [reported bug] before modifying code and show expected failures.

Refactor [module] without changing public interfaces and run scoped test commands.

Explain [build failure logs] by tracing dependency and configuration issues in the actual project.

Audit [proposed command list] for destructive actions and request approval before execution.

Generate documentation for [new API route] based on implemented behavior and examples.

Review [git diff] for security-sensitive changes, unintended file edits and missing rollback options.

Draft Project instructions for [workflow] specifying sources, output structure and anti-hallucination constraints.

Summarize [project files] into decisions, blockers and next steps without inventing missing context.

Organize [project reference PDFs] into a bounded knowledge workspace with clear source and version labels.

Write project instructions for [editorial workflow] that preserve tone, sources and required review gates.

Compare [two documents uploaded to project] and cite passages supporting each difference.

Draft a project handoff from [uploaded notes] distinguishing completed work from pending decisions.

Review [long project conversation] for unresolved questions and conflicting instructions without inventing conclusions.

Create a source-grounded FAQ from [approved project files] and mark questions with insufficient evidence.

Plan a repeatable research session in [Claude Project] with inputs, expected outputs and verification checklist.

Create a Mesh relationship reminder for [former colleague] around [follow-up occasion], with an appropriate opt-out from automated notifications.

Review Mesh contact updates for [professional acquaintance] after a company change, verifying the information before sending an outreach message.

Prepare an authentic reconnecting note to [contact] using Mesh's past interaction notes while avoiding any private information I was not authorized to share.

Ask Mesh to identify mutual connections to [organization] within my permitted team network and distinguish direct relationships from weak connections.

Build a Mesh for Teams shared contact view for [project team] with visibility restrictions on private email subjects and meeting titles.

Review a Mesh event-imported contact list from [conference] to merge true duplicates while preserving relevant conversation history.

Use Mesh relationship intelligence to prioritize [five partner follow-ups] based on actual recent interactions and stated commitments, not made-up affinity scores.

Prepare a Mesh meeting brief for [known contact] summarizing prior authorized interactions, professional updates and two useful discussion questions.

Audit Mesh contact-sharing settings before inviting [new teammate], checking what notes, interaction metadata and connection paths will become visible.

Enrich [company list] with verified product, location and funding facts including source dates.

Create qualification notes for [account] using only confirmed signals and review gaps before CRM sync.

Research [approved target companies] for current product category and source-backed business descriptions.

Enrich [CRM prospect list] with public company websites and verify duplicate names before import.

Extract [company hiring signal] from dated public pages and retain exact supporting URLs.

Compare [prospect account records] for conflicting company sizes, locations and contact details.

Design a source-validation step for [Claygent research column] that flags missing evidence.

Prepare an outreach-research brief for [sales segment] using publicly verifiable company signals only.

Audit [lead enrichment batch] for stale information, personal-data exposure and unsupported assumptions.

Compare data-quality issues across [classes] and assess annotation-guideline weaknesses.

Evaluate model performance after cleaning on an untouched holdout set and report false corrections.

Identify likely mislabels in [image classification dataset] and send high-risk cases to expert review.

Prioritize [training examples] using data-quality scores and documented error categories.

Audit [customer intent labels] for ambiguity, inconsistent definitions and systematically confused classes.

Compare validation metrics before and after correcting [verified label errors] without mixing train/test splits.

Investigate outliers in [structured customer data] before dropping or modifying any records.

Create a reproducible label-audit workflow for [new training batch] with versioned corrections.

Summarize [data quality report] into verified findings, open questions and expected downstream model tests.

Trim long pauses in [interview] without losing deliberate emphasis or speaker transitions.

Check multilingual cleanup of [audio] for accidental removal of accented speech and proper names.

Remove filler words from [podcast recording] while keeping intentional pauses and natural speech rhythm.

Clean mouth clicks in [interview audio] without damaging consonants or changing speaker identity.

Trim unnecessary silence from [remote conversation] while preserving meaningful transitions.

Compare original and cleaned [dialogue] for missing words, cut-off syllables and unnatural pacing.

Prepare a multilingual cleanup pass for [approved narration] and inspect language-specific filler removal.

Process [batch of podcast episodes] with consistent loudness and noise checks after cleanup.

Export [clean audio episode] in [required format] and verify duration, channels and transcription alignment.

Compare two ClearML experiment runs on [same validation set] with consistent metrics and compute conditions.

Register [trained model artifact] in ClearML with its evaluation score, data lineage and revision details.

Use ClearML Dataset to version [authorized training data] and document what changed between versions.

Create a ClearML Pipeline for [training and evaluation workflow] with explicit failure and retry boundaries.

Schedule an experiment through ClearML Agent on [available compute queue] and inspect resource requirements before launch.

Prepare a reusable training configuration for [model] and verify credentials stay out of scripts and logs.

Evaluate [candidate model] against a held-out dataset and record performance regressions in ClearML.

Review ClearML pipeline artifacts for duplicate jobs, missing metadata and unexpected dataset dependencies.

Audit a ClearML deployment handoff for reproducibility, environment drift, secret leakage and rollback readiness.

Compare [topic] content briefs from competing results, distinguishing overlapping questions from original insight opportunities.

Audit [content inventory] for articles losing relevance, then prioritize factual refreshes and intent consolidation.

Build a content brief for [search query] with primary reader questions, competitor themes and original evidence needed.

Compare [draft article] with [search intent] and identify sections that add little value despite high term coverage.

Develop a revision plan for [declining guide] prioritizing factual updates, examples and navigation clarity.

Review [content grade feedback] and distinguish meaningful missing concepts from repetitive keyword insertions.

Analyze [competing search pages] to identify unmet decision-making questions for [buyer audience].

Create a content audit queue for [article cluster] based on intent overlap, stale claims and underdeveloped sections.

Validate a revised [long-form article] against citations, heading hierarchy, internal links and readability before release.

Extract action items from [meeting notes] into ClickUp tasks, leaving ambiguous assignees for human review.

Draft a weekly status using task activity and due dates, identifying missing updates and dependency risks.

Turn [meeting transcript] into proposed tasks with owners only when explicitly stated and otherwise mark unassigned.

Prepare a sprint summary from [project board] that distinguishes delivered items, blocked tasks and slipping milestones.

Create a task dependency map for [release checklist] highlighting missing prerequisites and potential critical path blockers.

Summarize [comment history on task] into decisions, open questions and the latest confirmed status.

Draft a project handoff from [ClickUp space] with objectives, key links, current blockers and responsible teams.

Create a weekly dashboard narrative from [task fields] while clearly indicating missing or outdated status updates.

Suggest subtasks for [approved feature request] with acceptance criteria and test/QA checkpoints for human review.

Implement [feature] in existing files while listing necessary terminal commands and asking before destructive operations.

Review [proposed changes] against the project's security constraints, then explain test gaps and unintended dependencies.

Trace [failing integration test] through relevant source files, propose a minimal fix and run only scoped commands.

Implement [new API endpoint] using the project's existing router conventions, validations and regression tests.

Review [terminal command plan] for destructive effects and require confirmation before changing deployment state.

Find the source of [unexpected null value] across [component and API], showing the call chain and proposed tests.

Plan a repository-wide rename of [public interface] with backwards-compatibility checks and automated validation.

Use [existing project documentation] to identify missing configuration for [local development environment].

Summarize [completed code change] with modified files, test output, remaining risks and rollback instructions.

Relight [authorized portrait] to match a soft [studio setup], checking skin tones and natural shadow direction.

Upscale [low-resolution graphic] while inspecting text artifacts, edge halos and invented fine details.

Clean [unwanted prop] from [owned interior photo] while protecting wall textures and nearby shadows.

Upscale [small e-commerce product image] and compare edges, logos and printed text against the original.

Generate variations of [licensed product background] without changing package labeling or product geometry.

Replace [image background] with a neutral studio setup while keeping reflections and contact shadows plausible.

Adjust lighting on [approved furniture photo] to suggest daylight while retaining accurate material colors.

Prepare [five product thumbnails] with consistent framing, background cleanliness and output dimensions.

QA [AI-edited marketing image] for invented objects, altered brand marks and unrealistic edges before use.

Generate a vertical [product clip] from approved source images; add accurate subtitles and inspect cut pacing.

Combine [owned visuals and licensed audio] into a social edit, keeping captions readable in 9:16 safe zones.

Draft prompts for a six-second [original product reveal] with camera movement, light direction and shot continuity.

Create an image-to-video storyboard from [owned still image] with subtle motion and safe boundaries around facial details.

Edit [approved video clip] into a 15-second vertical social ad with readable captions and one verified CTA.

Plan [three-shot short story] using consistent character appearance, scene location and transition timing.

Generate a music-and-edit concept for [brand teaser] using licensed sound and timing that preserves message clarity.

Review [AI-generated video output] for warped hands, text hallucinations and visual continuity before publication.

Create alternate cuts of [approved footage] for 1:1 and 9:16 placements while preserving subject framing and key text.

Create a multi-stage copy workflow for [landing page] with verified benefits, objections and CTA alternatives.

Audit generated [blog draft] for unsupported statistics, semantic duplication and overly promotional wording.

Write three sales headline concepts for [verified SaaS service], each emphasizing a distinct user problem.

Draft a product landing-page narrative from [approved benefits and proof points] with a concrete but nonmisleading CTA.

Create an objection-handling email sequence for [B2B audience] without unsupported customer results or artificial scarcity.

Outline an evergreen SEO article on [customer pain point] with differentiated insights and source requirements.

Rewrite [long-form campaign copy] to improve clarity, remove repeated claims and tighten transitions.

Test [two ad-copy variants] against platform policy, factual accuracy and one measurable hypothesis.

Prepare a content QA checklist for [AI-generated campaign set] covering brand tone, claims, links and approval ownership.

Compare reviewer agreement for [text labels] and escalate ambiguous or inconsistent records for adjudication.

Plan quality control of [speech transcript labels] with sampling, double review and traceable corrections.

Define a video-labeling specification for [warehouse safety footage], including object classes, boundary examples and hard negatives.

Build a managed annotation staffing plan for [multilingual audio collection], assigning language expertise and independent reviewers.

Audit [annotated image batches] for missed boxes, class drift and inconsistent treatment of occluded objects.

Prepare a double-blind quality sample for [sentiment classification project], tracking disagreement by category and annotator cohort.

Design a dataset handoff from [labeling team] into [ML training pipeline] with export schema, version IDs and checksums.

Investigate [labeling throughput slowdown] by comparing reviewer queues, rework rates and difficult content types.

Create a secure processing checklist for [restricted training data], covering annotator permissions, retention and access audit.

Create a project tracker table in Superhuman Docs from these requirements: [requirements].

Rewrite this section for [audience] while preserving the underlying facts: [text].

Organize the information in this doc into a clear table with useful columns.

Review unresolved comments in this document and propose the concrete edits needed to address them.

Create a release-readiness table in Superhuman Docs from [approved milestones] with owner, dependency, evidence link and status columns.

Use Docs AI to turn [project retrospective notes] into recurring blockers, decisions and proposed process improvements.

Compare [two versions of a project plan] and draft an updated decision summary without changing unapproved commitments.

Prepare a status report using [document tables and comments], clearly distinguishing overdue items from unassigned tasks.

Draft a structured meeting agenda from [open project issues] with links to underlying document sections.

Generate equivalence tests for [converted module] covering nulls, boundaries and exception behavior.

Explain differences between [source and translated code] and flag type coercion or async semantics that need manual fixes.

Translate [Java class] into [TypeScript equivalent], explicitly mapping types, exceptions and mutable state.

Convert [Python data transformation] into [JavaScript] and document behavioral differences around nulls and numeric values.

Migrate [legacy SQL stored procedure] into [target dialect], preserving joins and transaction assumptions.

Review [AI-converted function] for incorrect library names, silent type coercion and changed error behavior.

Design a cross-language equivalence test set for [API handler] with identical requests and expected responses.

Produce a modernization checklist for [batch processing script] including I/O, logging, encoding and dependency mapping.

Compare [source and target implementations] for algorithmic complexity and unexpected changes to floating-point rounding.

Summarize the high-impact changes in [diff] and separate verified defects from stylistic preferences.

Apply [repository review rules] to [security-sensitive module] and propose focused tests instead of unreviewed mass edits.

Analyze [pull request diff] for race conditions, state mutations and backward compatibility problems.

Review [authentication refactor] for authorization checks, untrusted input handling and missing integration tests.

Summarize reviewer feedback from [PR comments] into must-fix defects, optional improvements and open questions.

Audit [database migration PR] for rollback strategy, null constraints and assumptions about existing rows.

Check [CI-related code changes] for hidden dependency upgrades, stale snapshots and tests that fail silently.

Apply [team code review standards] to [repository PR] while distinguishing objective defects from formatting choices.

Create a concise review report for [large PR] with severity, file/line context, reproducibility and verification steps.

Create a support knowledge base from [approved website sections] and test unanswered questions before exposing it to customers.

Audit role access to [knowledge repository] and verify that responses do not reveal information outside authorized documents.

Design a private knowledge-base assistant for [employee handbook] that only answers from current approved documents.

Generate a staff FAQ from [uploaded operations manuals] with source links and unresolved questions explicitly flagged.

Test [Cody assistant] on [conflicting policy documents] and require it to identify the version mismatch before answering.

Organize [technical troubleshooting guides] into a knowledge collection with access permissions and metadata.

Prepare a customer-facing bot response policy for [returns inquiries] that avoids unsupported policy exceptions.

Review [website indexing setup] to exclude private, outdated and irrelevant pages from an assistant's knowledge base.

Create a QA set for [internal knowledge bot] covering citation completeness, unsupported requests and escalation.

Test [voice/chat support flow] with ambiguous requests and multilingual variations; report NLU misroutes.

Analyze [agent assist transcripts] for repeated questions and unmet information needs, protecting private customer details.

Build a phone support flow for [appointment rescheduling] with authentication, slot availability and transfer on ambiguity.

Design intent training examples for [billing inquiries] including paraphrases, spelling errors and multilingual variants.

Prepare an agent-assist brief for [customer issue] that surfaces relevant policy guidance without fabricating resolutions.

Test [voicebot] for interruption, silence, failed speech recognition and a clear route to a human representative.

Integrate [approved CRM lookup] into a conversational flow with least-privilege fields and audit logging.

Analyze [conversation analytics sample] to find misunderstood intents and repeated escalation triggers.

Create a release checklist for [new customer-support intent] with fallback coverage, compliance and QA sign-off.

Compare embeddings and Rerank results on [labeled search questions], tracking answer-source ranking and latency.

Design a limited-scope tool-use task with Command models for [internal lookup], including permission checks and abstention.

Design a multilingual semantic search benchmark for [approved help-center articles] with relevance labels and language coverage.

Compare Cohere embeddings on [product catalog] using retrieved relevance, false matches and latency.

Build a Rerank evaluation for [support query set], reporting whether the top results actually support an answer.

Create an enterprise RAG prompt for [policy question] that requires citations and abstains on missing evidence.

Plan an authorized document summarization flow using Command models with bounded context and source verification.

Test [tool-use assistant] on [read-only order-status API] with authentication rules and safe error behavior.

Assess [model deployment design] for sensitive document access, retention policy and prompt-injection resilience.

Extract a palette from [owned moodboard image], checking sufficient text-to-background contrast.

Export [selected palette] as CSS variables and test components in light and dark UI states.

Produce a restrained five-color palette for [fintech dashboard] with primary, background, accent, alert and neutral roles.

Lock [brand navy hex code] while generating accessible complementary colors for buttons, borders and backgrounds.

Extract dominant colors from [licensed photograph] and translate them into a usable website theme.

Compare [two proposed palettes] for readability of navigation, links, disabled controls and small text.

Prepare CSS variables from [approved hex palette] and show examples for primary and secondary actions.

Generate a warm-neutral palette for [portfolio site] while avoiding oversaturated accents and low-contrast combinations.

Create a design handoff checklist for [palette] covering color roles, contrast checks and light/dark state behavior.

Localize [course clip] for [target language] and review pronunciation, technical terms and avatar timing.

Design a scenario-based learning video with [customer situation], comprehension prompts and accurate content approvals.

Transform [approved workplace safety module] into a short avatar-led video with a knowledge check and source-linked claims.

Script a two-person training scenario about [service escalation] with roles, dialogue, learning goal and recap.

Adapt [onboarding video script] for [new employee audience] with consistent terminology and an accessible pace.

Prepare a localization plan for [training course] with language variants, captions, name pronunciation and QA owners.

Turn [slide deck] into a video lesson plan, specifying where avatar narration or on-screen diagrams add clarity.

Review [synthetic presenter video] for consent, mispronunciation, missing captions and claims requiring expert approval.

Design a follow-up assessment for [generated training video] using three scenario questions and corrective feedback.

Compare [two model runs] on identical holdout data, showing variance, cost and evaluation caveats.

Set an alert for [production model metric] crossing defined thresholds and investigate changes against deployment history.

Log [classification experiment] with dataset hash, training configuration, evaluation metrics and code revision.

Compare [five hyperparameter runs] to identify trade-offs between accuracy, inference cost and evaluation variance.

Build an experiment-review dashboard for [model family] that highlights best runs and weak evaluation coverage.

Register [candidate model version] with required artifacts, approval notes and reproducibility evidence.

Investigate [metric regression] by comparing training data versions, random seeds and dependency changes.

Create a production monitoring plan for [prediction endpoint] covering latency, input drift and ground-truth feedback delay.

Prepare an auditable handoff of [ML experiment] with lineage, charts, model limitations and known failure modes.

Use an image-to-image graph to modify [owned illustration] while preserving structure; compare denoise strengths.

Export a reusable JSON workflow for [product mockup series], testing required models and custom-node dependencies.

Create a repeatable text-to-image node workflow for [original sci-fi environment], setting checkpoint, sampler, steps and seed.

Plan an inpainting pipeline to replace [object in owned photo] while protecting the surrounding composition.

Use ControlNet on [authorized sketch] to preserve composition across several variations of [illustration].

Design a LoRA-enabled portrait workflow with clear model-version dependencies and reproducible generation settings.

Create a batch render workflow for [product backgrounds] using consistent aspect ratio, lighting and negative prompts.

Troubleshoot [ComfyUI missing-node or VRAM error] by isolating broken custom nodes and model loading requirements.

Review [exported workflow JSON] for nonportable model paths, undocumented custom nodes and hidden dependencies.

Rewrite [paragraph] in a warmer professional voice without altering the technical meaning.

Create a reusable text shortcut for [recurring status update] with editable fields and no fabricated metrics.

Shorten [lengthy email] into a polite two-paragraph reply while keeping agreed dates, requests and commitments intact.

Create a custom writing shortcut for [meeting follow-up] with placeholders for attendees, decisions and action owners.

Rewrite [client-facing note] in a more formal tone without changing numbers, technical details or contractual language.

Generate three subject-line and opening-sentence alternatives for [routine outreach] that avoid misleading urgency.

Turn [rough customer response] into a concise answer with a clear next step and no invented resolution.

Prepare a reusable status-report snippet from [verified project facts] with placeholders for progress and blockers.

Proofread [workplace message] for clarity, politeness and ambiguity while preserving the author's original intent.

Compare backtested [two investment strategies] using identical periods, fees and drawdown metrics; flag survivorship bias.

Inspect an automated strategy's trigger conditions and execution risks before enabling any real trading or capital exposure.

Build a hypothetical rebalancing strategy for [basket of ETFs] with stated constraints and a paper-only evaluation plan.

Run a historical scenario analysis for [strategy] and interpret annual return, volatility and maximum drawdown together.

Compare [momentum rule] with [buy-and-hold allocation] under matched dates, transaction costs and rebalancing assumptions.

Inspect the logic of [nested symphony] for contradictory conditions, concentration risks and unexpected exposure.

Model how [cash allocation rule] affects a backtest during [specified drawdown period] without projecting future returns.

Prepare a prelaunch risk checklist for [automated strategy] including liquidity, execution timing and tax considerations.

Summarize [backtest results] with caveats about overfitting, survivorship, slippage and unseen market regimes.

Compare neighboring paper clusters on [topic], noting chronological relationships and missing areas of the literature.

Export a reading shortlist to [reference manager] with source links, publication year and a one-line relevance reason.

Explore prior work around [seminal article DOI] and sort related papers by the methodological question they answer.

Use a literature graph to find adjacent approaches to [research problem], then validate each suggested paper's actual topic.

Trace newer derivative research from [seed paper] and identify techniques that were adopted or challenged.

Create a reading sequence from [paper graph] that moves from foundational methods to recent empirical evaluations.

Compare [two seed-paper networks] to identify bridging publications and topics each network underrepresents.

Audit [reference shortlist] for missing publication metadata, retracted papers and unsupported relevance assumptions.

Document a literature-map gap on [research theme] with linked articles and an explicit explanation of search limits.

Compare findings of [recent papers] with different sample sizes and methods, reporting why their conclusions diverge.

Review a Consensus synthesis of [question] for study quality, scope limits and claims that need primary-source checking.

Search for peer-reviewed evidence on [intervention versus comparator] in [population] and distinguish outcomes by study design.

Summarize [research question] using cited studies while explicitly flagging findings based on small or observational samples.

Compare meta-analyses on [clinical topic] and identify differences in inclusion criteria, time windows and outcome measures.

Find contradictory studies on [hypothesis] and tabulate publication year, methodology, sample size and effect direction.

Screen [set of paper abstracts] for relevance to [PICO question] and separate uncertain eligibility for manual review.

Prepare a plain-language research summary on [topic] that communicates both potential benefits and evidence limitations.

Verify [Consensus answer] by checking whether each cited paper supports the specific claim and whether newer studies change it.

Repurpose [approved blog article] into three social posts with different hooks and no new factual claims.

Review [generated article] for duplicated passages, citation gaps and misleading product assertions before publishing.

Build a monthly editorial workflow for [B2B blog] around [approved themes], including briefs, review ownership and publication checks.

Generate a customer-education article draft from [product documentation] with grounded examples and accurate feature terminology.

Prepare four variations of [newsletter introduction] matched to [audience persona], keeping event dates and facts unchanged.

Convert [webinar transcript] into a factual article outline with topic sections and quotes requiring speaker approval.

Create a landing-page FAQ from [sales objection notes] without adding unsupported guarantees or pricing information.

Audit [batch-generated articles] for repeated structures, duplicate headings, irrelevant keywords and factual inconsistencies.

Set up a human-in-the-loop content automation checklist for [campaign] with validation gates before anything is published.

Compare [two available coding models] on [repository task] with identical instructions and test cases.

Explain [failing function] by inspecting source and call sites, then propose a minimal verified correction.

Locate all call sites of [deprecated API] in [repository] and propose a staged migration with tests before editing.

Generate unit tests for [uncovered utility] using current project conventions, emphasizing errors and boundary inputs.

Compare an in-editor code suggestion with [team lint and security rules] before recommending acceptance.

Explain [repository architecture] by mapping entry points, shared interfaces and key dependencies from the actual files.

Prepare an incremental refactor of [large function] that preserves behavior and identifies where tests are currently missing.

Review [configuration file changes] for accidental credential exposure, incompatible settings and rollback requirements.

Create a scoped implementation plan for [bug report] using codebase search, minimal file changes and verification commands.

Map [product marketing brief] into consistent email and landing-page copy, preserving proof points and brand tone.

Test an automation chain for [lead enrichment] with missing-data cases, duplicate suppression and auditable source fields.

Define a lead enrichment workflow for [target account list] with approved sources, duplicate checks and explicit CRM-write authorization.

Create personalized outbound email drafts for [audience segment] from verified industry pain points without invented prospect research.

Design a product-messaging workflow that transforms [approved feature brief] into landing page, email and sales summary variants.

Build a conditional GTM workflow for [inbound form submission] that validates fields and routes incomplete records for review.

Test [automated prospect research workflow] against missing websites, subsidiaries and conflicting company names.

Prepare a sales enablement brief from [approved case studies] with source-linked outcomes and disallowed marketing claims.

Audit [Copy.ai GTM workflow] for stale source data, permission boundaries, misleading personalization and failed downstream steps.

Develop three different descriptions for [approved product] using its exact features, dimensions and warranty terms.

Audit a generated [blog post] for near-duplicate paragraphs, unsupported assertions and correct links.

Turn [approved company research] into a blog outline targeting [buyer question] with specific source requirements and original examples.

Draft an email sequence for [product launch] using supplied audience segments, verified features and one CTA per message.

Create five social captions about [approved webinar] adapted to platform character constraints and consistent brand voice.

Revise [landing-page copy] to reduce vague promises and clarify who the product suits, what it does and how to try it.

Generate a structured FAQ for [service page] from [customer questions] while marking answers that require validation.

Rewrite [long article section] into concise plain language while retaining its citations, technical meaning and caveats.

Prepare a prepublication checklist for [AI-written content] covering originality, links, claim verification and heading structure.

Compare [two listing title variants] for shopper clarity, policy compliance and testable hypotheses.

Audit [catalog listings] for wrong dimensions, unsupported claims and duplicated bullet points before bulk changes.

Draft an Amazon product title for [SKU] using only the approved brand, material, size and key differentiator within marketplace rules.

Rewrite five listing bullets for [product] to answer common buyer questions without unsupported superlatives or medical claims.

Compare [priority search terms] with [current Amazon listing] to identify relevant terms missing from shopper-facing copy.

Create three conversion-focused product description variants for [verified kitchen product] without altering specifications.

Review [competitor listings] for useful differentiators and overlooked customer questions rather than copying their descriptions.

Prepare a localization checklist for [Amazon marketplace] covering measurements, idioms, regulatory claims and search vocabulary.

Analyze [listing performance observations] and propose a measurable content test without attributing sales changes to copy alone.

Compare [suspected duplicate pages] side by side to identify substantial overlap and legitimate reuse.

Run a batch check on [new site articles], recording source matches, dates and editorial resolution without asserting plagiarism automatically.

Check [published article URL] for overlapping web pages and create an editorial review list with matching passages and source URLs.

Compare [two competing blog pages] for duplicate sections while excluding quotations, common definitions and licensed excerpts.

Monitor [site's most copied articles] and triage new overlap alerts using date, source evidence and reuse permissions.

Build a plagiarism review checklist for [guest-submitted post] covering quotations, attribution and substantially reused passages.

Investigate [suspected scraped product description] with URL matching and keep an evidence log before issuing any complaint.

Screen [batch of landing pages] for reused paragraphs and prioritize pages that require original examples or editorial rewrite.

Document [content originality audit] with page URL, matching source, overlap type, manual decision and required next action.

Using Frase, audit [existing SEO article] for Google search and AI-answer visibility, prioritizing source-backed fixes for the stated audience.

Prepare a Frase content plan for [topic cluster] based on existing pages, measurable search opportunities and an editorial approval gate.

Use Describely to assess missing attributes and inconsistent descriptions across [ecommerce product CSV] before generating any new copy.

Generate Describely product descriptions for [five verified SKUs] from approved technical specifications, preserving measurements and prohibited claims.

Create a Describely catalog-content enrichment checklist that logs the authoritative source for every product attribute and queues uncertain fields for review.

Use Rytr to draft three on-brand versions of [customer email] from [approved message] while preserving factual details and the intended action.

Compare Rytr writing variations for [support response] against [brand voice guide] and highlight phrases that misstate policy or product capabilities.

Build a coordinated Copysmith portfolio plan that uses Frase to identify an AI-search gap, Describely to correct product content and Rytr for customer communication.

Design a monthly Copysmith portfolio quality review for [site], checking Frase opportunity outcomes, Describely product-data accuracy and Rytr brand consistency separately.

Create a study guide from [owned lecture notes], identifying key definitions, worked examples and five practice questions.

Compare [my solution] to the reference method for [topic], showing the first error without completing graded work dishonestly.

Explain [uploaded calculus exercise] with given assumptions and a worked solution the student can independently check.

Build a flashcard set from [approved lecture notes] with key definitions and short examples.

Create a practice quiz on [biology chapter] that reveals explanations after each answer.

Summarize [class reading] into concepts, evidence and unresolved questions without inventing citations.

Guide me through [physics homework problem] using hints first instead of giving the full answer immediately.

Compare [my written answer] with [rubric] and explain missing reasoning while preserving academic integrity.

Prepare a one-week study schedule for [exam topics] prioritizing weak concepts identified in practice questions.

Workflow: Screen [abstract collection] using independent reviewers and reconcile disagreements with recorded reasons.

Build a data extraction form for [included trials] covering sample size, methods, effects and risk-of-bias judgments.

Configure abstract screening criteria for [systematic review question] with explicit inclusion and exclusion cases.

Create a duplicate-reference cleanup plan before importing [literature search results].

Audit disagreements between [two reviewers] and prepare an adjudication queue with reasons.

Design an extraction form for [clinical study outcomes] including sample sizes, follow-up and uncertainty.

Plan a risk-of-bias assessment for [included studies] with reviewer guidance and audit notes.

Check [PRISMA flow counts] against imported, excluded and full-text-screened references.

Prepare a review-team handoff highlighting unresolved eligibility decisions and missing source documents.

Build a visual workflow to classify [incoming inquiries] and pass structured fields to a permitted plugin.

Test [agent workflow] with ambiguous requests, failed tools and missing evidence before channel publication.

Build a knowledge-backed bot for [product FAQ] that cites approved articles and falls back on uncertainty.

Design a no-code agent workflow for [event registration inquiries] with validation and human transfer rules.

Test [bot workflow] on misleading user messages, missing records and plugin failures.

Plan plugin permissions for [information retrieval assistant] so it cannot make unapproved external writes.

Create a multilingual conversation flow for [customer support topic] with consistent policy answers.

Audit [bot knowledge base] for outdated files, conflicting instructions and overbroad retrieval.

Define deployment QA for [messaging bot] covering channel formatting, latency, privacy and escalation.

Turn [rough meeting notes] into a structured brief with decisions and next actions, preserving uncertainty.

Design an offline-friendly knowledge page for [field team], testing links, attachments and synchronization afterwards.

Organize [project brainstorm] into linked Craft documents for objectives, decisions and open questions.

Create a meeting-note template with attendees, confirmed action owners, decisions and follow-up dates.

Turn [research notes] into a readable document with source links, callouts and a concise executive summary.

Build a knowledge map linking [product specs], [meeting notes] and [design decisions] without duplicate pages.

Review [shared team document] for ambiguous responsibilities, broken references and outdated statements.

Design a weekly project-status page with completed items, blockers and decisions awaiting approval.

Prepare an export checklist for [Craft workspace documents], preserving embedded links and document hierarchy.

Compare feature explanations for [model decisions] across segments and identify patterns that require fairness review.

Define monitoring and retraining thresholds for [deployed model], with human approval before model replacement.

Design an enterprise assistant answering [HR policy questions] solely from authorized, versioned documents.

Create a read-only agent workflow to summarize [customer case history] without exposing unrelated accounts.