GPT-6.1 Sol Prompt Generator

Design and execute a multi-agent workflow for the following task. You are the orchestrator agent. Task: [describe the end goal in one sentence] Available sub-agents: [list their capabilities — e.g. code execution, web search, file access, API calls, database query] Constraints: [time budget, auth scope, off-limits systems, output format] Successful completion means: [define the exact state that confirms the task is done] As orchestrator: 1. Decompose the task into the minimum number of sub-agent calls needed (no redundant calls) 2. Specify each call: AGENT → INPUT → EXPECTED OUTPUT → NEXT STEP OR BRANCH 3. Identify the dependencies — which calls must complete before others can start (parallelise where safe) 4. Define the 3 most likely failure modes and the recovery action for each 5. Write the verification step: how you confirm the final output is correct, not just complete Return the orchestration plan as a numbered DAG with explicit branch logic.

Perform a deep code review on the following code. Match the depth of a senior engineer with a security background. Language/framework: [specify] PR description or change intent: [what this change is supposed to do] Code diff or full files: ``` [paste the code] ``` Known risks or concerns: [anything the team already suspects] Review dimensions (cover all, don't skip): 1. CORRECTNESS — logic errors that produce wrong output in production. Cite the specific line and the exact failure scenario. 2. SECURITY — injection, auth bypass, secrets exposure, SSRF, insecure deserialization, rate-limit bypass. Each finding: severity (CRITICAL/HIGH/MEDIUM), line, exploit path, specific fix. 3. PERFORMANCE — O(n²) or worse, N+1 queries, blocking I/O in hot paths, unbounded memory growth. 4. AGENT SAFETY — if this code runs in an agent: prompt injection vectors, tool call boundaries, unintended side effects, missing confirmation gates. 5. TEST GAPS — the 3 inputs most likely to expose a bug, with the expected behaviour and why it won't be caught without a test. End with: SHIP / SHIP WITH CHANGES / DO NOT SHIP and a one-sentence rationale.

Write a complete agentic task specification that a coding agent (GPT-6.1 Sol in Codex) can execute end-to-end without human clarification. Task goal: [describe the software change or feature to implement] Repository context: [language, framework, relevant file paths, coding conventions] Acceptance criteria: [what must be true for the task to be complete — write as testable assertions] Out of scope: [explicitly list what the agent must NOT change] Available tools: [file read/write, shell execution, test runner, linter, git] Specification must include: 1. STARTING STATE — what the agent reads first and why 2. IMPLEMENTATION STEPS — numbered, each with: action, file(s) affected, validation check 3. SELF-VERIFICATION — the exact commands to run (tests, lint, typecheck) before declaring success 4. ROLLBACK PLAN — how the agent restores the original state if a step fails mid-way 5. EDGE CASES — the 3 scenarios the implementation must handle that aren't obvious from the goal statement

Debug the following failing test or broken behaviour using a structured root-cause process. Do not guess — diagnose before proposing fixes. Language/framework: [specify] Failing test or error: ``` [paste the exact test, error message, or stack trace] ``` Relevant code: ``` [paste the code under test and any relevant helpers] ``` Environment details: [OS, runtime version, relevant env vars or config] What I've already tried: [list any steps already taken] Process: 1. HYPOTHESIS RANKING — list the top 3 root causes by probability, with your confidence percentage and the evidence for each 2. DIAGNOSTIC STEPS — for each hypothesis: the exact command or code change that would confirm or rule it out (no destructive changes yet) 3. ROOT CAUSE — after diagnosis: the specific line(s) and the mechanism of the failure 4. FIX — the minimal change that resolves the root cause (show the diff) 5. REGRESSION TEST — the new test case that would catch this failure in future 6. SIMILAR RISKS — 2 other places in the codebase where the same pattern could cause the same failure

Design an enterprise automation workflow for the following recurring process. Process: [describe the current manual process — steps, stakeholders, frequency, systems involved] Trigger: [what initiates this process — a schedule, an event, an email, a form submission?] Enterprise tools in use: [Salesforce / Jira / Confluence / Slack / SAP / ServiceNow / other — list all] Compliance requirements: [audit trail, approval gates, data residency, access controls] Error budget: [can errors be caught and corrected, or must this be zero-failure?] Deliver: 1. WORKFLOW DIAGRAM (text-based): each step as [STEP] → [SYSTEM/AGENT] → [OUTPUT] → [NEXT STEP or BRANCH CONDITION] 2. HUMAN-IN-THE-LOOP GATES — exactly where a human must review or approve before the workflow continues 3. AUDIT TRAIL — what is logged at each step, where, and in what format 4. FAILURE HANDLING — for each gate: what triggers escalation, who is notified, and what the SLA is 5. ROI ESTIMATE — hours of manual effort replaced per week, and the single highest-risk step that still needs a human

Plan a migration of the following codebase from its current architecture to the target architecture. Produce a phased plan an engineering team can execute. Current architecture: [describe — monolith / modular monolith / microservices, language, frameworks, databases] Target architecture: [describe the goal state and why it's being pursued] Critical constraints: [zero downtime, data integrity, rollback capability, team size, timeline budget] Known risks: [anything the team already knows is fragile or tightly coupled] Key codebase files or modules: [paste relevant architecture docs, key files, or dependency lists] Migration plan: 1. PHASE 0 — PREPARATION (no behaviour changes — tests, interfaces, seams) 2. PHASE 1 — STRANGLER FIG / PARALLEL RUN (incremental replacement with traffic shadowing) 3. PHASE 2 — CUTOVER (switchover strategy, rollback gate) 4. PHASE 3 — CLEANUP (remove old code, update documentation) For each phase: duration estimate, team roles, the go/no-go criteria, and the rollback procedure.

Analyse the following document(s) thoroughly. Use the full context — do not summarise or skip sections. Document type: [contract / research corpus / codebase / legal filing / financial statements / other] Analysis goal: [what decision or action does this analysis need to support?] Key questions: 1. [First specific question] 2. [Second specific question] 3. [Third specific question] [add more] Document(s): [paste the full text — GPT-6.1 Sol's 1M+ context window handles very long documents] For each question: - DIRECT ANSWER (plain English, 2–3 sentences) - SUPPORTING EVIDENCE (exact quote and location in the document) - CONFIDENCE (High / Medium / Low — and why if Medium or Low) - CAVEATS (where the document is ambiguous, inconsistent, or silent on the question) End with: SUMMARY OF KEY FINDINGS (5 bullets) and OPEN QUESTIONS (anything not answerable from the document alone).

Create a complete agentic integration plan for the following API or service. Service to integrate: [name and purpose of the API] Authentication method: [API key / OAuth2 / service account / other] My system: [language, framework, existing architecture] Integration goal: [what should my system be able to do after integration?] Available API documentation or spec: [paste the relevant endpoints, schema, or OpenAPI spec] Plan: 1. AUTHENTICATION FLOW — exact steps to obtain, store, and refresh credentials securely 2. ENDPOINT MAP — the 3–5 endpoints needed for the integration goal, with input/output schema for each 3. IMPLEMENTATION ORDER — which endpoint to build first and why (usually the simplest read operation) 4. ERROR CATALOGUE — the 5 most common API errors and the handling logic for each 5. RATE LIMIT STRATEGY — the rate limit constraints and the retry / backoff logic 6. INTEGRATION TEST PLAN — 3 test cases that confirm the integration works end-to-end without hitting production data 7. PRODUCTION CHECKLIST — what must be verified before enabling this integration for real traffic

Generate the following code using the full repository context I am providing. Do not generate in isolation — use the patterns, conventions, and existing utilities already in this codebase. What to implement: [describe the feature, function, or component] Language/framework: [specify] Acceptance criteria: [what must be true for this to be correct?] Conventions to follow: [naming patterns, error handling style, logging format — describe or let me show examples] Full codebase context: [paste all relevant files — GPT-6.1 Sol handles very long context; include the modules yours will interact with] Generate: 1. The implementation (complete, no truncation, no 'add the rest yourself' shortcuts) 2. The unit tests (cover the happy path, one boundary case, and one error case) 3. Any changes needed to existing files to wire this in 4. A brief comment for any non-obvious decision made during implementation

Write a strategy document for the following decision or situation, including scenario analysis. Decision or situation: [describe clearly — what is being decided, why now, what the stakes are] Audience: [who reads this — C-suite / board / team leads / investors?] Time horizon: [1 year / 3 years / 5 years] Known constraints: [budget, team size, regulatory, competitive] Data and evidence I have: [paste relevant metrics, market data, or internal analysis] Document structure: 1. SITUATION ANALYSIS (what is true now — opportunities, risks, competitive position) 2. STRATEGIC OPTIONS (3 distinct options, each with: description, key assumptions, resource requirements) 3. SCENARIO ANALYSIS (for each option: best case / base case / downside — with probability and impact) 4. RECOMMENDATION (one option, the 3 reasons supporting it, and the one strongest counterargument) 5. SUCCESS METRICS (3–5 specific, measurable indicators at 6 months and 12 months) 6. DECISION GATES (the conditions under which you would switch to a different option) Length: 800–1,200 words. No filler.

Perform a security audit of the following agentic system. This is a system where an LLM agent takes actions based on instructions and tool outputs. System description: [what the agent does, what tools it has access to, who uses it] Agent framework: [LangChain / LlamaIndex / AutoGen / custom / other] Tools available to the agent: [list all — file access, shell, APIs, databases, external services] Trust model: [who provides instructions to the agent, what levels of user are there] Agent code or system prompt: [paste the system prompt, tool definitions, and relevant orchestration code] Audit dimensions: 1. PROMPT INJECTION — attack vectors where malicious content in tool outputs could redirect the agent's behaviour 2. TOOL MISUSE — how each tool could be abused if an attacker influences the agent's inputs 3. PRIVILEGE ESCALATION — paths by which an unprivileged user could cause the agent to perform privileged actions 4. DATA EXFILTRATION — how sensitive data accessed by the agent could leak through tool outputs or logs 5. DENIAL OF SERVICE — inputs that could cause the agent to loop, consume excessive resources, or stall indefinitely For each finding: severity (CRITICAL/HIGH/MEDIUM), specific attack scenario, and the exact mitigation.

Write a competitive intelligence brief on the following market or competitive situation. Our position: [describe our product, target market, and stage] Competitors to analyse: [list 3–5 by name] Time frame: [current state, or a specific event like a recent product launch or funding round] Key intelligence questions: 1. [First question — e.g. 'Why did they win the last three deals we lost?'] 2. [Second question] 3. [Third question] Available intelligence: [paste everything you know — public announcements, customer feedback, sales call notes, product reviews, pricing pages, job postings — GPT-6.1 Sol's context handles very long inputs] Brief format: - EXECUTIVE SUMMARY (3 bullets: what we know, what it means, what to do) - COMPETITOR-BY-COMPETITOR ANALYSIS (for each: core strengths, exploitable weaknesses, their likely next move) - MARKET DYNAMICS (what is shifting in the market and who benefits) - OUR BEST MOVE (one specific action to take in the next 30 days based on this intelligence) - INTELLIGENCE GAPS (what we don't know that would change this analysis)

Review the following pull request as if you were an orchestrating senior engineer running multiple specialist checks in parallel. PR title and description: [paste the PR title, description, and any linked issue] Code diff: ``` [paste the full diff] ``` Run all of these checks and report findings in a single structured review: CHECK 1 — CORRECTNESS: Logic errors. State each as: location → failure scenario → fix. CHECK 2 — SECURITY: Vulnerabilities. Each: severity → exploit path → fix. CHECK 3 — PERFORMANCE: Regressions. Each: location → impact → fix. CHECK 4 — TESTS: Coverage gaps. Each: scenario missing a test → recommended test. CHECK 5 — AGENT SAFETY: If this code runs in an agent context — injection vectors, unintended side effects. CHECK 6 — STYLE: Violations of the conventions implied by the existing code (not personal preferences). Final verdict: APPROVE / REQUEST CHANGES / NEEDS DISCUSSION Top 3 must-fix items before merge, in priority order.

Synthesise the following research corpus into a coherent, publication-ready analysis. Use the full text — do not skim. Research goal: [what question is this corpus trying to answer?] Audience: [who will read the synthesis — researchers / executives / policymakers / general?] Length: [target word count] Corpus: [paste all research materials — papers, articles, reports, transcripts — GPT-6.1 Sol's 1M+ context handles large corpora] Synthesis structure: 1. CONSENSUS FINDINGS — what the sources agree on (cite each source) 2. CONTESTED CLAIMS — where sources disagree and why (describe each side fairly) 3. METHODOLOGY ASSESSMENT — for empirical sources: study quality, sample size, potential biases 4. EVIDENCE STRENGTH MAP — rate each key finding: Strong / Moderate / Weak, with one-sentence rationale 5. GAPS — what the corpus doesn't cover that would be needed for a definitive answer 6. SYNTHESIS CONCLUSION — your assessment given the evidence, with confidence level Note where the evidence is thin or where you are drawing an inference beyond what the sources directly state.

Write a technical roadmap for the following product or system over the specified time horizon. Product/system: [what it is and what it currently does] Time horizon: [6 months / 12 months / 18 months] Strategic goals: [the 2–3 outcomes this roadmap should achieve — business and technical] Current state: [what exists today — strengths, known gaps, technical debt] Constraints: [team size, budget, existing commitments, external dependencies] Architecture notes or backlog: [paste any existing technical docs, epic backlog, or architecture decisions — GPT-6.1 Sol can handle full backlogs] Roadmap format: - MILESTONE STRUCTURE (3–4 milestones across the horizon, each with: name, target date, definition of done) - PER-MILESTONE WORK BREAKDOWN (key technical items grouped by theme, with effort estimate S/M/L) - DEPENDENCIES AND RISKS (what could delay each milestone and the mitigation) - SUCCESS METRICS (how you measure each milestone's completion — not just 'it's shipped') - SCOPE PARKING LOT (important but deferred work, with the rationale for deferral)

Generate a comprehensive test suite for the following code. Cover the cases a manual review would miss. Language/framework: [specify] Testing framework: [Jest / pytest / RSpec / Go test / xUnit / other] Code to test: ``` [paste the full module, class, or function] ``` Dependencies available for mocking: [list external services, databases, APIs the code calls] Generate tests for: 1. HAPPY PATH — each function's expected behaviour with valid inputs (complete, runnable) 2. BOUNDARY CONDITIONS — edge values (empty, zero, max, null, overflow) for each input 3. ERROR CASES — every documented error path and any undocumented ones you identify 4. CONCURRENCY — if the code has shared state: race conditions, deadlocks, out-of-order execution 5. SECURITY — input validation, injection resistance, auth boundary tests For each test: descriptive name, arrange/act/assert structure, and a one-line comment explaining WHAT failure it catches and WHY it's non-obvious.

Prepare a decision package for the following executive decision. Structure it so a decision-maker can act in 5 minutes. Decision to make: [state the decision precisely — one sentence] Deadline: [when must this be decided?] Decision maker(s): [who must approve?] Background: [what context do they already have?] Evidence and analysis: [paste all relevant data, reports, and analysis — GPT-6.1 Sol handles very long inputs] Package format: - DECISION REQUIRED (one sentence — exactly what you are asking them to decide) - RECOMMENDATION (your preferred option, stated directly) - THE CASE IN 60 SECONDS (3 bullets: the key fact, the key risk of inaction, the key risk of action) - OPTIONS CONSIDERED (2–3 alternatives, each: 1 sentence description, 1 sentence on why it was not recommended) - FINANCIAL IMPACT (best case / base case / downside, with confidence) - WHAT HAPPENS NEXT (exactly what you will do the day after a yes — the first 3 actions) - WHAT YOU NEED (one clear ask: approval / budget / headcount / signature — by when)

Write a production-ready system prompt for a Codex agent built on GPT-6.1 Sol. Agent purpose: [describe what the agent is supposed to do — e.g. 'implement GitHub issues as pull requests', 'maintain a monorepo's documentation', 'run automated QA on PRs'] Repository context: [language, framework, test runner, CI stack, key conventions] Tools available: [file read/write, shell execution, git, GitHub API, other] Constraints: - [constraint 1 — e.g. 'never push directly to main'] - [constraint 2 — e.g. 'always run tests before committing'] - [constraint 3 — e.g. 'do not modify files outside the src/ directory'] Success definition: [how the agent should know a task is complete] System prompt must include: 1. ROLE AND PURPOSE (who the agent is and what it does — one paragraph) 2. OPERATING RULES (numbered, each a specific, testable constraint — no vague instructions) 3. TOOL USE PROTOCOL (how and when to use each available tool — in what order, with what validation) 4. COMPLETION CRITERIA (exact conditions that determine the task is done, not just started) 5. ESCALATION CONDITIONS (exactly when to stop and report back rather than continuing) 6. ERROR HANDLING (what to do when a tool fails, a test fails, or the repository is in an unexpected state)

Audit the following financial model or business case for accuracy, assumptions, and risks. Model purpose: [what decision does this model support?] Key outputs: [what metrics does it produce — revenue, margin, IRR, NPV, payback period?] Audience: [board / investors / internal leadership] Model data: [paste the full model — spreadsheet data, assumptions table, formulas as text, or financial projections — GPT-6.1 Sol handles large data dumps] Audit checklist: 1. ARITHMETIC ERRORS — any formula that produces a wrong result given its inputs 2. ASSUMPTION AUDIT — each major assumption: reasonable / aggressive / too conservative, with a benchmark if available 3. SENSITIVITY ANALYSIS — the 3 inputs that swing the output most; for each: if this assumption is wrong by 20%, what happens to the headline metric? 4. MISSING FACTORS — variables the model ignores that could materially change the result 5. SCENARIO GAPS — what stress scenarios the model should include but doesn't 6. PRESENTATION RISKS — numbers or framings likely to be challenged in a board meeting, with suggested reframings

Write a complete incident response runbook for the following system or service. System: [describe the service — what it does, who depends on it, what failure looks like] Severity tiers: [define SEV1/SEV2/SEV3 or P0/P1/P2 for this system] On-call team: [who is paged, in what order, what their access levels are] Monitoring stack: [what tools alert — PagerDuty, Datadog, Grafana, CloudWatch, other] Runbook must cover: 1. DETECTION AND TRIAGE (how to confirm it's an incident, not a fluke — the first 3 checks) 2. SEVERITY CLASSIFICATION (decision tree: which signals → which severity) 3. COMMUNICATION PROTOCOL (who to notify at each severity, in what channel, using what template) 4. COMMON FAILURE MODES (for each: symptoms, diagnostic steps, remediation, and the command or config change that fixes it) 5. ROLLBACK PROCEDURE (exact steps to revert the last deployment or config change) 6. ESCALATION PATH (when to escalate, to whom, and what information to bring) 7. POST-INCIDENT REQUIREMENTS (what must be filed, by whom, and within what timeframe)