Gemini 3.8 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.

Act as an autonomous software engineer with access to my codebase. Your task: implement the following feature end to end without stopping for clarification on steps you can infer from the code. Feature: [describe feature]. Repo context: [describe the stack, main directories, and any conventions you know]. Execution workflow: (1) Explore relevant files — list the files you plan to touch and explain why each one is in scope; (2) Write a mini design doc: the data model change (if any), the API contract, the UI components, and the test plan; (3) Implement in this order: data layer → service layer → API route → UI → tests; (4) After each layer, state what you just built and what comes next; (5) At the end, list every file you modified or created, the commands to run the tests, and any environment variables or migration steps needed. Use TypeScript. Do not skip edge cases — handle them where you find them, not as follow-up tasks.

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.

You are an autonomous terminal agent. Complete the following multi-step workflow using shell commands: [describe workflow — e.g. 'set up a new Node.js project with ESLint, Prettier, Jest, and a GitHub Actions CI pipeline']. Execution rules: (1) Before each command, state in one sentence what it does and why it is needed; (2) After each command, check its exit code and output — if it failed, diagnose the cause and retry with a fix rather than continuing; (3) Do not ask for confirmation on steps you can infer from the task description — only stop if you reach an ambiguity that would change the architecture; (4) If a step has multiple valid approaches, pick the one with the lowest complexity and explain your choice in one line; (5) At the end, run a smoke test that verifies the workflow completed correctly — describe what you checked and what the results were. Output the final project structure as a tree.

Act as a financial analysis agent. I am providing portfolio data: [paste holdings, cost basis, and current prices, or describe the portfolio]. Analysis tasks: (1) Calculate portfolio-level metrics: total market value, total cost basis, unrealised gain/loss in dollars and percentage, and portfolio CAGR since inception if dates are provided; (2) Sector and asset-class breakdown: what percentage of the portfolio is in each sector (use GICS classification) and asset class (equity, fixed income, cash, alternative); (3) Concentration risk: identify any single position that exceeds 10% of the portfolio and any sector that exceeds 30%; (4) Correlation analysis: which 3 pairs of holdings are most likely to move together in a downturn — explain the relationship in plain English; (5) Rebalancing proposal: if the portfolio has drifted more than 5% from a 60/40 (or user-specified) target allocation, propose the minimal set of trades to rebalance while minimising tax impact; (6) Risk-adjusted return: calculate or estimate the Sharpe ratio if return and volatility data are available; (7) Plain-English summary: what is the biggest risk in this portfolio today and what is the single highest-conviction action to reduce it? Output: a structured report with a one-page executive summary at the top.

You have access to a desktop browser. Complete the following research task by navigating multiple websites: Task: [describe the research task — e.g. 'compare pricing for 3 project management tools and fill in a comparison spreadsheet']. Execution requirements: (1) Before navigating to any page, state the URL you will visit and what information you expect to find there; (2) For each page visited, describe: the page type (pricing page, blog, docs), the information successfully extracted, and any information that was not available; (3) If a page requires a login to see pricing, note this as a data gap and move on — do not create accounts; (4) Keep a running structured table of your findings — update it after each source; (5) If two sources give conflicting information for the same product, record both values and flag the conflict; (6) After visiting all planned sources, identify any remaining gaps and suggest one additional source per gap; (7) Final output: the completed comparison table, a list of data sources visited with their quality (authoritative / secondary / inferred), and a one-paragraph recommendation based on the data collected.

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].

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.

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.

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.

Use high thinking effort. 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]

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]

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.

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]. 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.

You have access to a desktop OS environment. Complete the following multi-application task without human assistance: Task: [describe the task — e.g. 'download the Q3 report from our SharePoint, summarise the revenue section, and paste it into a new Notion page titled Q3 Revenue Summary']. Execution rules: (1) At each step, describe: current application, current screen state, and your next action; (2) When switching applications, confirm the target application name and window title before proceeding; (3) If a drag-and-drop, right-click menu, or keyboard shortcut would be faster than clicking through menus — use it and state why; (4) Handle modal dialogs immediately — describe the dialog, then choose the action that continues the task (dismiss, confirm, or cancel with explanation); (5) If you encounter an error or unexpected state, describe it precisely, form a hypothesis, and attempt recovery before stopping; (6) Verify the final state: confirm every deliverable from the task description exists and matches the specification; (7) Total time estimate: at the end, report how many application switches and distinct actions the task required — use this as a complexity signal for future automation.

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, 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; (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.

Use high thinking effort. 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?; (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.