GPT-6 Sol Prompt Generator

Review the following system architecture and provide a structured assessment. System purpose: [describe what this system does] Scale targets: [requests/sec, data volume, user count] Current stack: [list your services, databases, queues, etc.] Architecture diagram or description: [paste your architecture or describe the components and how they connect] Assess: 1. BOTTLENECKS — where will this system break under load? Be specific about which component and why. 2. SINGLE POINTS OF FAILURE — what fails with no redundancy? 3. DATA CONSISTENCY GAPS — where could the system produce inconsistent or incorrect data? 4. SECURITY SURFACE — the 3 highest-risk attack vectors given this architecture. 5. RECOMMENDED CHANGES — exactly 3 changes, in priority order, with implementation effort estimate (S/M/L) and the improvement each delivers.

Synthesise the following research materials into a structured report for a [executive / technical / general] audience. Research materials: [paste your sources, notes, papers, or raw data — as much as you have] Report structure: 1. EXECUTIVE SUMMARY (3 sentences: what we know, what it means, what to do) 2. KEY FINDINGS (5–8 bullets, each a distinct, specific finding — not topic headers) 3. CONFLICTING EVIDENCE (where sources disagree and why it matters) 4. CONFIDENCE LEVELS (rate each key finding: High / Medium / Low, with one-sentence rationale) 5. GAPS AND OPEN QUESTIONS (what we still don't know that would change the conclusions) 6. RECOMMENDED ACTIONS (3 specific next steps, in priority order) Be direct. Flag uncertainty rather than smoothing it over. Do not pad findings with background context.

Plan the following agentic task as a numbered step-by-step execution plan for an AI agent with access to the listed tools. Goal: [describe the end state — what should be true when the task is complete?] Available tools: [list: web search, code execution, file read/write, API calls, browser, etc.] Constraints: [rate limits, auth scope, off-limits domains, output format requirements] Starting state: [what information or files the agent already has] Produce: 1. A numbered plan (each step: ACTION, TOOL, INPUT, EXPECTED OUTPUT, FAILURE MODE) 2. The 3 most likely failure points and how to detect them 3. A verification step at the end — how the agent confirms the goal is actually complete, not just apparently complete 4. Estimated step count and the step with the highest risk

Audit the following codebase for code quality, security, and maintainability issues. Language/framework: [specify] Critical paths (the code that must work correctly): [list the most important features or flows] Known problem areas: [anything the team already suspects is fragile] Code: ``` [paste your codebase, key files, or the most critical modules] ``` Audit dimensions: 1. CORRECTNESS BUGS — logic errors that will produce wrong output in production 2. SECURITY VULNERABILITIES — injection, auth bypass, secrets exposure, unvalidated input — rate each CRITICAL / HIGH / MEDIUM 3. PERFORMANCE RISKS — O(n²) loops, N+1 queries, blocking calls in hot paths 4. DEAD CODE AND COMPLEXITY — code that should be deleted or simplified 5. TEST COVERAGE GAPS — the 3 scenarios most likely to fail without a test For each finding: file, line, severity, one-sentence description, and the specific fix.

Write a complete, publication-ready [report / white paper / technical spec / proposal] on the following topic. Topic: [describe the subject in detail] Audience: [who will read this — technical / executive / policy / general?] Length: [target word count or page count] Key arguments or conclusions to reach: [list the 3–5 points the document must land] Evidence or data I have: [paste any facts, stats, or quotes to incorporate] Tone: [authoritative / accessible / formal / analytical] Structure: - Executive summary (150 words max) - Numbered sections with H2 headings - A conclusion with specific recommendations - No filler — every paragraph must advance the argument Write the full document, not an outline.

Review the following API design for correctness, usability, and security. API type: [REST / GraphQL / gRPC / WebSocket] Purpose: [what this API does and who will consume it] Documentation or spec: [paste your OpenAPI spec, GraphQL schema, endpoint list, or API documentation] Assess: 1. DESIGN INCONSISTENCIES — naming, versioning, error response formats — flag anything that won't behave predictably 2. SECURITY GAPS — unauthenticated endpoints, over-permissive scopes, mass assignment vulnerabilities 3. PAGINATION AND RATE LIMITS — are there endpoints that could return unbounded results or be abused? 4. BREAKING CHANGE RISKS — what current design decisions will force a breaking change at v2? 5. DEVELOPER EXPERIENCE PROBLEMS — the 3 things a new consumer will find most confusing For each finding: severity, endpoint or field, specific recommendation.

Analyse the following competitors and produce a competitive intelligence report. Our product/service: [describe what we offer and who it's for] Competitors to analyse: [list 3–6 competitor names] Competition dimensions that matter most to us: [e.g. pricing, features, positioning, distribution, technical capability] For each competitor: 1. How they position themselves (core message in 1 sentence) 2. Their 3 strongest advantages over us 3. Their 3 most exploitable weaknesses 4. The customer segments they win and the ones they lose Then: 5. THE WHITESPACE — what problem is no competitor currently solving well? 6. OUR BEST MOVE — given this landscape, the single highest-leverage action to take in the next 90 days

Help me debug the following issue. Apply systematic root-cause analysis, not guessing. Language/framework: [specify] Environment: [local / staging / production / cloud provider] Expected behaviour: [what should happen] Actual behaviour: [what is actually happening] Error message or stack trace: ``` [paste the full error output] ``` Relevant code: ``` [paste the code in question] ``` What I've already tried: [list any steps already attempted] Approach: 1. Identify the most likely cause (state your confidence level) 2. List 3 alternative explanations in order of likelihood 3. A step-by-step diagnostic process to confirm the root cause before changing anything 4. The specific fix for the most likely cause 5. A regression test to prevent recurrence

Write a strategy memo on the following decision or situation. Context: [describe the situation — what is happening, what decision is pending, what the stakes are] Audience: [who will read this — direct manager / C-suite / board / team lead?] Recommendation I want to make: [state your preferred direction, even tentatively] Counterarguments I anticipate: [list the objections you expect] Data or evidence I have: [paste any relevant metrics, facts, or precedents] Memo structure: - SITUATION (2–3 sentences: what is happening and why it matters now) - RECOMMENDATION (1 sentence: exactly what you are proposing) - RATIONALE (3 numbered reasons, most compelling first) - RISKS AND MITIGATIONS (2–3 risks with a specific mitigation for each) - ALTERNATIVES CONSIDERED (1–2 sentences on the next-best option and why it was rejected) - REQUESTED ACTION (what you need from the reader, by when) Keep total length under 400 words. No filler.

Design a data pipeline for the following requirements. Data sources: [list sources — databases, APIs, files, streams, etc.] Data destinations: [warehouse, lake, downstream services, dashboards] Transformations needed: [describe what needs to happen to the data — enrichment, aggregation, deduplication, etc.] Volume and velocity: [rows/day or events/sec, data size] Latency requirements: [real-time / near-real-time / batch, acceptable delay] Existing stack: [list your cloud provider and any tools already in use] Design deliverable: 1. A named pipeline architecture (Lambda / Kappa / ELT / streaming — justify the choice) 2. Component-by-component breakdown: what each component does, the specific tool recommendation, and why 3. The failure scenario that would cause data loss and how to prevent it 4. Schema evolution strategy — how to handle upstream schema changes without breaking downstream consumers 5. Estimated infrastructure cost tier (low/medium/high) and the biggest cost driver

I am attaching a long document. Answer the following questions based strictly on its content. Do not use outside knowledge — if the document doesn't answer a question, say so explicitly. Document: [paste your full document — contract, report, research paper, transcript, etc.] Questions: 1. [Your first question] 2. [Your second question] 3. [Your third question] [add more as needed] For each answer: - Quote the exact passage that supports it (or state 'not found in document') - Give the answer in plain language - Flag if the document is ambiguous or contradictory on this point

Create a refactoring plan for the following code. Do not just rewrite it — produce a phased plan that can be executed without breaking production. Language/framework: [specify] Reason for refactoring: [technical debt / performance / new requirements / onboarding difficulty] Team size and familiarity: [how many devs, how well do they know this code?] Current test coverage: [percentage or description] Code to refactor: ``` [paste the code] ``` Plan format: 1. PHASE 1 — SAFE PREPARATION (test coverage, interfaces, no behaviour change) 2. PHASE 2 — INCREMENTAL RESTRUCTURE (module by module, each step verifiable) 3. PHASE 3 — CLEANUP AND VALIDATION For each phase: what changes, what tests confirm correctness, estimated effort (S/M/L), rollback strategy if something breaks.

Write a compelling grant application or proposal for the following opportunity. Organisation/project overview: [who you are and what you do] Funding body and call: [who you're applying to and what they fund] Requested amount: [budget] Project description: [what you want to do with the funding, in plain terms] Evidence of impact or track record: [paste any relevant data, testimonials, or past results] Evaluation criteria listed in the call: [paste the scoring criteria or requirements] Write: - An executive summary (150 words) - A project narrative that addresses each evaluation criterion directly - A simple budget justification (1 paragraph per major cost line) - A measurable outcomes section with 3–5 specific, observable indicators of success - A risk section that pre-empts the funder's most likely objection Tone: authoritative and specific. No boilerplate mission statements.

Write a blameless post-mortem for the following incident. Incident summary: [what happened, when, how long it lasted] Systems affected: [list the services, features, or users impacted] Timeline of events: [paste a rough chronological log — even rough notes are fine] Root cause (initial assessment): [what do you currently believe caused it?] Response actions taken: [what was done to detect, contain, and resolve it?] Post-mortem structure: 1. IMPACT SUMMARY (users affected, duration, business impact in one paragraph) 2. ROOT CAUSE ANALYSIS (5-whys chain — go at least 3 levels deep) 3. CONTRIBUTING FACTORS (conditions that made the incident possible or worse) 4. TIMELINE (precise, from first signal to full resolution) 5. ACTION ITEMS (each with owner, priority HIGH/MEDIUM/LOW, and deadline) 6. WHAT WENT WELL (do not skip this — it is as important as what failed) Blameless framing throughout — describe system failures, not person failures.

Prepare me for a technical interview at [company name or type] for a [role] position. My background: [years of experience, tech stack, key projects] Interview format I expect: [system design / algorithm / coding / behavioural / all of the above] Areas I am weakest in: [be specific — e.g. 'distributed systems', 'dynamic programming', 'SQL query optimisation'] Level: [junior / mid / senior / staff / principal] Prepare: 1. The 5 most likely technical topics for this specific role and company 2. For each topic: 1 sample question (at the right level), what a strong answer covers, and a common mistake to avoid 3. A system design question likely for this role with a structured approach for answering it 4. The 3 behavioural questions most frequently asked at this company type with the STAR structure filled in for a generic strong answer I can adapt 5. My recommended 2-week prep plan given my stated weaknesses

Review the following contract or legal document and flag the issues that matter. Document type: [NDA / service agreement / employment contract / terms of service / other] My role: [which party am I — the one signing, the one sending, a third party?] My primary concern: [liability / IP ownership / termination terms / payment / confidentiality / other] Document text: [paste the full contract or relevant sections] Flag: 1. UNFAVOURABLE CLAUSES — terms that disadvantage my position, in plain English 2. AMBIGUOUS LANGUAGE — clauses open to interpretation that could cause disputes 3. MISSING PROTECTIONS — standard provisions that are absent and should be added 4. JURISDICTION AND GOVERNING LAW — any issues with the chosen jurisdiction for my situation 5. NEGOTIATION PRIORITIES — rank the 3 clauses I should push hardest to change, most important first Note: This is not legal advice. Flag issues for discussion with a qualified attorney.

Write a product requirements document (PRD) for the following feature or product. Product/feature name: [name] Problem it solves: [describe the user problem in one sentence] Target users: [persona description — who specifically, their context, their goal] Success metrics: [how will we know this worked? List 2–3 measurable outcomes] Out of scope: [explicitly list what this PRD does NOT cover] Constraints: [technical, timeline, budget, regulatory — list all] PRD sections: 1. BACKGROUND AND MOTIVATION (why now, what evidence exists for this problem) 2. USER STORIES (3–5 stories in the format: 'As a [persona], I want [goal] so that [outcome]') 3. FUNCTIONAL REQUIREMENTS (numbered, each must be testable — use 'the system shall' format) 4. NON-FUNCTIONAL REQUIREMENTS (performance, security, accessibility, localisation) 5. OPEN QUESTIONS (list anything that needs a decision before development starts, with owner and deadline) 6. DEPENDENCIES (other teams, systems, or approvals this work depends on)

Write an onboarding guide for a new developer joining this codebase. Codebase overview: [describe the product and what the code does] Language/framework: [specify] Team size and workflow: [number of devs, branch strategy, PR process] Critical paths (what a new dev must understand first): [list the most important flows or modules] Code or architecture notes: [paste key files, README, or your own architecture notes] Guide sections: 1. WHAT THIS CODEBASE DOES (2 paragraphs: what the product does, what the code's job is) 2. GETTING STARTED (exact setup steps from fresh clone to running tests — no assumed knowledge) 3. THE MENTAL MODEL (how the key components relate — use a short pseudo-diagram or numbered relationship list) 4. WHERE TO START READING (the 3 most important files in the order a new dev should read them, and why) 5. THE GOTCHAS (3–5 non-obvious things that trip up new contributors) 6. HOW TO ADD A FEATURE (a worked example walkthrough of the pattern used across the codebase)

Write a concise executive briefing on the following topic for a [CEO / Board / C-suite] audience. Topic: [describe the subject — a strategic situation, a market shift, a technical risk, a business decision] Context: [what the executives already know and what they don't] Decision or action needed: [what do you need from them? Or is this informational only?] Data or evidence: [paste any relevant metrics, reports, or analysis] Time sensitivity: [is this urgent? Explain why.] Briefing format: - SITUATION (1 paragraph: what is happening, why it matters to this organisation specifically) - RECOMMENDATION (1 sentence: the specific action you are recommending, or the decision required) - KEY FACTS (3–5 bulleted facts that support the recommendation — no background filler) - RISKS (2 risks with a mitigation sentence each) - NEXT STEPS (exactly 3 steps, each with owner and deadline) Total length: under 350 words. Write for someone who will read this in 90 seconds.

Design an automated workflow for the following recurring task or process. Process to automate: [describe what currently happens manually — steps, people involved, frequency] Trigger: [what starts this process — a schedule, an event, a human action, an incoming message?] Inputs: [what data or files does the process need to start?] Outputs: [what should exist when the process completes?] Tools and systems available: [list your tech stack, APIs, services] Error handling requirement: [what should happen if a step fails — retry, alert, fallback?] Design: 1. TRIGGER → ACTION flow diagram (text-based, each step as: [step name] → [tool/system] → [output] → [next step or condition]) 2. The human-in-the-loop decision points — where a human must review before proceeding 3. The data validation checks at each major step 4. The single most likely failure mode and how the workflow detects and recovers from it 5. Estimated automation coverage — what percentage of manual effort this removes and what still needs human handling