Gemini 3.7 Flash Prompt Generator

Build a complete user authentication flow for a Next.js 15 application using App Router. Include: (1) Sign-up page with email, password, and display name — real-time validation as the user types, password strength indicator, and accessible error messaging; (2) Sign-in page with email/password and a 'Remember me' option that persists the session for 30 days; (3) Forgot password flow — request form, email link (mock the send), and token-validated reset form; (4) Server Actions for all form submissions with CSRF protection via the built-in Next.js mechanism; (5) Middleware that redirects unauthenticated users away from protected routes and authenticated users away from auth pages; (6) A session cookie with httpOnly, secure, and sameSite='strict' flags; (7) Rate limiting on sign-in to 5 attempts per IP per 15 minutes using an in-memory store for the prototype. Provide complete file contents for every file. Use TypeScript throughout. No auth library — implement the logic directly so I understand each step.

Build a reusable data table component in React 19 with TypeScript that handles: (1) Column definitions with type (string, number, date, badge, action), sortable flag, and optional custom render function; (2) Client-side sorting — click a column header to sort ascending, click again to sort descending, click a third time to remove sort; (3) Pagination — configurable page size (default 25), page controls, and a 'Showing X–Y of Z results' label; (4) Row selection — checkboxes per row and a select-all checkbox in the header that handles indeterminate state correctly; (5) A search/filter input that filters visible rows across all string and badge columns; (6) An empty state and a loading skeleton that matches the column structure; (7) Keyboard navigation — arrow keys to move between rows, space to toggle selection, enter to trigger the row's primary action. Export the component with a full TypeScript generic signature so columns and row data are type-safe. Include a usage example with at least 5 different column types.

Build a production-ready webhook handler for Stripe events in a Node.js/Express application. The handler must: (1) Verify the Stripe-Signature header using the Stripe SDK's constructEvent method — reject any request that fails signature verification with a 400 and log the attempt; (2) Handle idempotency — store processed event IDs in a database and return 200 without reprocessing if the same event arrives twice; (3) Handle the following event types: checkout.session.completed (provision access), customer.subscription.updated (update plan tier), customer.subscription.deleted (revoke access), invoice.payment_failed (send notification, retry logic); (4) Process each event type in a separate handler function — the router should only dispatch, not contain business logic; (5) Return 200 immediately and process the event asynchronously — webhook processing must not time out; (6) Dead-letter queue for events that fail processing three times — write them to a 'failed_webhooks' database table with the error and a timestamp; (7) Structured logging for each event: event ID, type, processing result, and duration. Provide TypeScript, full error handling, and a test for the signature verification step.

Analyse and rewrite the following algorithm for maximum performance. Current code: [paste code]. Optimization requirements: (1) Identify the time and space complexity of the current implementation using Big O notation — explain why; (2) Find every O(n²) or worse operation and propose a more efficient data structure or algorithm for each; (3) Identify any redundant computations that can be memoized or cached; (4) Profile the hot path — which branch or loop will execute most frequently for typical inputs, and is it optimized?; (5) Rewrite the algorithm to the best achievable complexity given the problem constraints — if the theoretical lower bound has been reached, say so and explain why; (6) Provide a benchmark comparison: estimated operations for n=1,000, n=100,000, and n=10,000,000 for both the original and optimized versions; (7) Add inline comments for every non-obvious optimization — explain what the trick is and why it works. If multiple optimization strategies are possible with different trade-offs, present them as options before writing the final version.

I have a distributed tracing log from a microservices system that is exhibiting intermittent latency spikes. The log spans 6 services: API Gateway, Auth Service, User Service, Inventory Service, Order Service, and Payment Service. Distributed trace: [paste trace JSON or describe spans]. Analysis requirements: (1) Reconstruct the full call graph — which service calls which, in what order, and what are the parallel vs sequential dependencies; (2) Identify the slowest span in each trace and whether it is on the critical path; (3) Find any span that shows high variance (p50 fast, p95 slow) — this indicates intermittent contention rather than constant slowness; (4) Identify any N+1 call patterns — a service being called in a loop rather than in a single batched call; (5) Find missing spans — gaps in the trace that suggest an untraced external call or a missing instrumentation point; (6) Calculate the theoretical minimum latency if all identified bottlenecks were fixed; (7) Prioritised fix list: issue, root cause hypothesis, estimated latency reduction, implementation effort (Low/Medium/High). Output: a trace analysis document followed by a prioritised action plan.

Write a reusable Terraform module that provisions a production-ready ECS Fargate service on AWS. The module must: (1) Accept these input variables: service_name, container_image (ECR URI), cpu, memory, desired_count, environment_variables (map), secrets (map of SSM Parameter Store ARNs), health_check_path, and vpc_id; (2) Create: ECS cluster (if not existing), ECS task definition, ECS service, IAM execution role and task role (least-privilege), security group for the container (inbound from ALB only), and a CloudWatch log group; (3) Output: service ARN, task definition ARN, security group ID, and CloudWatch log group name; (4) The task role must be able to read from Secrets Manager and Systems Manager Parameter Store, write to CloudWatch Logs, and push metrics to CloudWatch; (5) Use lifecycle rules to prevent task definition and IAM policy changes from causing unnecessary service replacements; (6) Include a README with a usage example showing a minimal and a full-featured invocation. Write complete Terraform — no pseudocode. Use Terraform 1.7 syntax.

Act as an autonomous debugging agent. I will provide a failing test suite and the implementation under test. Your workflow: Step 1 — run the test suite mentally and produce a structured failure report: test name, expected, actual, stack trace summary; Step 2 — for each failure, form a hypothesis about the root cause — distinguish between (a) logic error in the implementation, (b) incorrect test expectation, (c) environment or setup issue; Step 3 — for each logic error hypothesis, identify the minimal code change that would fix it — show the before/after diff; Step 4 — check whether the proposed fix would break any other passing test — if yes, revise the fix; Step 5 — after fixing all logic errors, re-run the test suite and confirm no regressions; Step 6 — if any test expectation is wrong (not the code), explain why it is wrong and propose the corrected assertion. Final output: (a) a diff for every changed file, (b) a summary table of each bug fixed with its root cause and severity, (c) any test corrections proposed. Code and tests: [paste below]

Design a browser automation workflow using Playwright that extracts structured data from a paginated web table. Target site description: [describe site structure]. Workflow steps: Step 1 — navigate to the target URL and wait for the table to fully load (handle lazy loading and JavaScript-rendered content); Step 2 — extract column headers and map them to output field names; Step 3 — for each row, extract all fields and handle these edge cases: (a) cells with nested elements — extract text content only; (b) cells with links — capture both the display text and the href; (c) empty cells — use null, not empty string; (d) cells with formatted numbers — strip commas and currency symbols to return a raw number; Step 4 — detect and handle pagination: find the 'next page' control, click it, wait for the new page to load (not just the DOM — wait for a row count change), and repeat; Step 5 — write extracted data to a JSON file with one object per row; Step 6 — handle and log: session timeouts (re-login if credentials provided), rate limiting (exponential backoff), and CAPTCHA detection (pause and notify rather than fail silently). Provide complete Playwright TypeScript code.

Act as a contract analysis agent. I am providing a contract document. Your task: Step 1 — identify the document type (NDA, SaaS agreement, employment contract, vendor agreement, other) and the parties involved; Step 2 — extract the following structured fields and output as a JSON object: { parties: [...], effective_date: '...', term: '...', renewal: '...', payment_terms: '...', liability_cap: '...', ip_ownership: '...', non_compete: '...', governing_law: '...', dispute_resolution: '...' }; Step 3 — for each field where the clause is non-standard or potentially unfavourable to the signing party, add a 'risk_note' key with a one-sentence plain-English explanation; Step 4 — flag any clause that uses language a court might interpret ambiguously — quote the exact clause and explain the ambiguity; Step 5 — produce a risk summary: Critical (immediate action needed) / High / Medium / Low — with the clause type and the specific risk for each. [Paste contract text below]

Reproduce the following benchmark result from a recent machine learning paper. Paper citation and claim: [paste citation and the specific number you are trying to reproduce, e.g. '73.2% accuracy on ImageNet-1k val with ResNet-50']. Reproduction plan I need you to generate: (1) Exact model architecture — list every layer, its configuration, and initialization scheme as described in the paper; (2) Training hyperparameters — optimizer, learning rate schedule, batch size, number of epochs, data augmentation pipeline, regularization — flag any that are not specified in the paper; (3) Dataset preparation — exact preprocessing steps, train/val/test split, any filtering or deduplication mentioned; (4) Evaluation protocol — how to compute the reported metric exactly, including any test-time augmentation; (5) Known reproducibility gaps — components the paper leaves underspecified that would require an assumption; (6) A minimal PyTorch training script that implements the above faithfully — include comments linking each implementation choice to the specific paper section; (7) Expected resource requirements: GPU type, VRAM, estimated training time. Flag any discrepancy between what you implemented and what the paper describes.

Design a Bayesian hyperparameter optimization study for the following model training setup. Model type and task: [describe]. Current training script: [paste or describe]. Study design requirements: (1) Define the search space — list every hyperparameter to tune with its type (continuous, integer, categorical), range or choices, and whether to sample in log space; explain the rationale for each range; (2) Define the objective function — what metric to optimize, and whether to maximize or minimize; if the metric is noisy, how to handle that (average over seeds, use a smoothed estimate); (3) Choose the number of trials and justify it relative to the search space dimensionality; (4) Define pruning criteria — at what epoch should a clearly underperforming trial be stopped early?; (5) Write a complete Optuna study script with the search space, the objective function calling your training script, early pruning, and result logging to a SQLite database so the study can be resumed; (6) After the study, how to interpret the results: importance plot, parallel coordinates plot, and how to identify the best trial robustly (not just the top-1); (7) How to validate the best configuration is not overfit to the validation set — describe the final evaluation protocol.

You have access to a desktop GUI environment. Complete the following multi-step form automation task: Task description: [describe the task — e.g. submit expense reports, fill in a weekly timesheet, complete a government form]. Execution requirements: (1) Before taking any action, describe the current screen state: application name, visible form fields, buttons, and any error or confirmation messages; (2) Fill in each field in tab order to avoid triggering validation errors; (3) For dropdown fields: click the dropdown, wait for options to render, then select by visible label rather than by index; (4) For date fields: use the keyboard-friendly format the field expects — do not assume MM/DD/YYYY; (5) Before submitting: capture a screenshot description of the completed form and list every field with its entered value for verification; (6) After submission: confirm the success state — either a confirmation message or a redirect to a confirmation page; (7) If you encounter a CAPTCHA, an unexpected modal, or a field you cannot fill, stop and describe what you see rather than guessing. Data to enter: [list all field values].

Act as a manual QA agent testing the following web application feature. You have access to a browser. Feature description: [describe the feature — e.g. 'user profile photo upload and crop']. Test plan I want you to execute: (1) Happy path — complete the feature successfully with valid inputs and confirm the expected outcome; (2) Boundary tests — test minimum and maximum values for every numeric or size-constrained field; (3) Invalid input — enter each type of invalid input the UI should reject, and confirm it shows an error rather than crashing or silently accepting; (4) Empty/null — submit the form with each required field left empty, one at a time, and confirm the correct field-level error appears; (5) Cancel/back — abandon the flow mid-way and confirm no partial state is persisted; (6) Reload resilience — reload the page mid-flow and confirm the user is either returned to a clean state or their progress is preserved (note which); (7) Accessibility — tab through all interactive elements and confirm the focus order is logical and all controls are keyboard-operable. For each test step, record: action taken, expected result, actual result, pass/fail.

Analyse the following financial report and produce a structured summary for a non-financial executive audience. Report: [paste or attach PDF]. Analysis requirements: (1) Revenue summary — total revenue, breakdown by segment or geography if reported, year-over-year growth rate, and whether the result beat or missed analyst consensus (if stated); (2) Profitability — gross margin, operating margin, and net margin — note any significant change from the prior period and the stated reason; (3) Cash and debt — cash on hand, total debt, net debt or net cash position, and free cash flow for the period; (4) Forward guidance — exact numbers stated by management for the next quarter and full year; (5) Key risks highlighted — any language in the MD&A that flags headwinds, regulatory exposure, or operational uncertainty, with the exact quote; (6) Three questions a board member would ask based on this report; (7) A plain-English executive summary: what happened this quarter in three sentences, what management said about the future in two sentences, and one sentence on the biggest risk. [paste report]

Synthesise the following set of research papers into a literature review section for an academic paper. Papers: [paste abstracts or full texts]. Synthesis requirements: (1) Group papers thematically — identify 3–5 sub-themes and name each; (2) For each sub-theme, write 2–3 paragraphs of synthesis — do not summarise papers individually; identify where they agree, where they disagree, and what gap remains; (3) Use academic citation format [Author, Year] inline — do not use footnotes; (4) Flag the most significant methodological limitation in each sub-theme — the weakness that makes the body of evidence uncertain; (5) Write a concluding paragraph that maps the literature landscape: what is settled, what is contested, and what is the key open question that motivates the work this review is embedded in; (6) Tone: formal academic prose — no first person, no hedging with 'it seems' or 'perhaps', no bullet points in the final output; (7) Target length: 800–1,000 words.

I am uploading a batch of supplier invoices as PDF files. Extract structured data from each invoice and output a single JSON array where each element represents one invoice. Required fields for each invoice object: { invoice_number, invoice_date (ISO 8601), due_date (ISO 8601), supplier_name, supplier_address, buyer_name, line_items: [{ description, quantity, unit_price, line_total }], subtotal, tax_rate_pct, tax_amount, total_amount, currency, payment_terms, bank_details: { account_name, account_number, sort_code_or_routing, bank_name } }. For any field not present in the invoice, use null. Additional rules: (1) Normalise all dates to ISO 8601 regardless of the format on the invoice; (2) Normalise all amounts to two decimal places as numbers, not strings; (3) Strip currency symbols from amounts — record the currency code separately; (4) If a field appears multiple times with conflicting values (e.g. two different totals), flag it with a 'conflict' key and record both values; (5) After the JSON, output a one-line summary per invoice: invoice number, supplier, amount, and any flags. [Attach PDFs]

I am uploading screenshots of competitor product pages. Analyse each screenshot and produce a structured teardown. For each screenshot: (1) Page type — landing page, pricing page, feature page, checkout, onboarding — identify it; (2) Value proposition — what is the headline claim? Rate its clarity 1–5 with one-sentence justification; (3) Visual hierarchy — describe what the eye lands on first, second, and third, and whether this order serves the conversion goal; (4) Social proof — what trust signals are visible above the fold? List each one: type (logo wall, testimonial, rating, case study, media mention), placement, and prominence; (5) CTA analysis — button text, colour, placement, and what happens after clicking (if inferable); (6) Target audience signal — based on imagery, language register, and any visible pricing or job titles, who does this page appear to target? (7) Weakest element — the single design or copy choice most likely to reduce conversion, with a one-sentence fix. After all individual analyses, synthesise: (a) the strongest CTA approach across all pages, (b) the positioning gap none of them claim, (c) one element from each to combine into a stronger page.

Conduct a structured root cause analysis for the following production incident. Incident: [describe what broke, when, how long it lasted, and the customer impact]. Available evidence: [paste error logs, metrics graphs (describe them), alerts, and timeline]. RCA methodology: (1) Timeline reconstruction — build a precise UTC-timestamped timeline distinguishing system events from human actions; (2) 5-Why analysis — start from the customer-visible symptom and ask 'why' five levels deep; stop only when you reach a cause that would require a change to a system, process, or assumption to prevent — not just 'the server crashed'; (3) Contributing factors — list every condition that amplified the impact or delayed detection, even if it is not the root cause; (4) Detection gap — how long between the root cause event and the first alert? What monitoring would have detected it sooner?; (5) Impact quantification — users affected, requests failed, revenue impact (if estimable), and SLA breach (yes/no with details); (6) Corrective actions table: Root Cause | Action | Owner (role) | Due | Priority (P0/P1/P2); (7) Preventive measures — what architectural or process changes would prevent this class of incident, not just this specific instance. Format: post-mortem document suitable for engineering leadership review.

Review the following system architecture and provide a structured assessment. Architecture description: [paste diagram description or architecture decision record]. Review requirements: (1) Correctness — does the architecture achieve the stated functional requirements? Identify any requirements gap; (2) Scalability — at what load does each component become a bottleneck? For each bottleneck, is horizontal scaling possible, and what is the first scaling constraint (CPU, memory, I/O, network)?; (3) Reliability — identify every single point of failure in the data path. For each one, what happens to end users when it fails?; (4) Security — surface the three highest-risk attack vectors given this architecture (network exposure, auth model, data storage); (5) Operational complexity — what does this architecture require of the on-call team? What breaks silently vs. noisily?; (6) Cost model — identify the two or three components that will dominate the cloud bill at scale, and whether they scale linearly or super-linearly with load; (7) Recommendation — for each identified issue, propose the change with the best impact-to-effort ratio. Be specific — 'use a cache' is not a recommendation; 'add a Redis read-through cache in front of the PostgreSQL user table, keyed by user_id, with a 60-second TTL' is. Output: a prioritised findings table followed by an architecture decision record for each recommended change.

Analyse the following business decision using a structured framework. Decision: [describe what must be decided]. Options under consideration: [list 2–4 options]. Context: [describe the business situation — stage, constraints, competitive position]. Analysis requirements: (1) Clarify the decision — restate what is actually being decided, separating the real question from any framing that obscures it; (2) Identify the 5 criteria that matter most, rank them by importance, and justify the ranking; (3) Score each option against each criterion (1–5) with a one-sentence justification per score; (4) Build a weighted scoring table and identify the quantitative winner; (5) Sensitivity analysis — which single criterion, if its weight were doubled, would change the outcome? What does this tell us about the robustness of the recommendation?; (6) Non-quantifiable factors — name 3 factors that resist scoring but could override the model: culture fit, political feasibility, reversibility; (7) Recommended option — state it clearly, then give the two strongest arguments against your recommendation and respond to each with the most honest rebuttal you can. Output: the full analysis plus a one-paragraph decision memo suitable for a board or leadership team.