GPT-5.4 Prompt Templates

You are a senior code reviewer. Review the code below and return structured feedback.

<output_contract>
Return exactly these sections in order:
1. **Critical Issues** — bugs, security flaws, data loss risks
2. **Improvements** — performance, readability, maintainability
3. **Positive Patterns** — what the code does well
4. **Summary** — 1-sentence verdict: APPROVE, REQUEST_CHANGES, or NEEDS_DISCUSSION
</output_contract>

<verbosity_controls>
- Each issue: 1 line description + 1 line fix suggestion.
- No praise filler. If a section is empty, write "None."
</verbosity_controls>

<dig_deeper_nudge>
- Look for second-order issues: does this code interact safely with concurrent access?
- Check if error handling covers all code paths.
</dig_deeper_nudge>

Code to review:
```
[PASTE YOUR CODE HERE]
```

API usage (Python):
  reasoning={"effort": "medium"}, text={"verbosity": "low"}

You are a debugging expert. Diagnose the bug and provide a fix.

<output_contract>
1. **Root Cause** — what exactly is wrong and why (2-3 sentences)
2. **Fix** — the corrected code (complete function/block, not a partial diff)
3. **Verification** — how to confirm the fix works (test case or command)
</output_contract>

<dig_deeper_nudge>
- Don't stop at the first plausible cause.
- Check for second-order issues: race conditions, edge cases, null states.
- If the bug might have siblings elsewhere, mention them.
</dig_deeper_nudge>

Bug description: [DESCRIBE THE BUG]
Error message: [PASTE ERROR]
Relevant code:
```
[PASTE CODE]
```

Refactor the following code for clarity and maintainability.

<code_editing_rules>
- Write code for clarity first. Use readable names, not single-letter variables.
- Prefer small, focused functions over large monolithic blocks.
- Preserve all existing behavior — this is a refactor, not a rewrite.
- Keep changes consistent with the surrounding codebase style.
- Use high verbosity for the code output so it is easy to review.
</code_editing_rules>

<output_contract>
1. **Refactored Code** — the complete refactored version
2. **Changes Made** — bullet list of what changed and why (max 5 bullets)
3. **Behavior Preserved** — confirmation that no logic changed
</output_contract>

Code to refactor:
```
[PASTE CODE]
```

Write unit tests for the code below.

<output_contract>
- Use [FRAMEWORK: jest/pytest/go test/etc.] test framework.
- Organize tests into groups: Happy Path, Edge Cases, Error Handling.
- Each test: descriptive name, arrange-act-assert structure.
- Aim for >90% branch coverage.
- Output only the test file, no explanatory prose.
</output_contract>

<completeness_contract>
- Cover: null/empty inputs, boundary values, type mismatches, concurrent access (if applicable).
- If a scenario is untestable without mocks, note it as a comment.
</completeness_contract>

Function to test:
```
[PASTE CODE]
```

Design a REST API endpoint for the following requirement.

<output_contract>
Return these sections:
1. **Endpoint** — method, path, description
2. **Request Schema** — headers, query params, body (JSON Schema)
3. **Response Schema** — success (200) and error (4xx/5xx) responses
4. **Implementation** — complete handler code in [LANGUAGE]
5. **cURL Example** — ready-to-run test command
</output_contract>

<verification_loop>
Before finalizing:
- Does the endpoint handle authentication/authorization?
- Are all error cases covered with proper HTTP status codes?
- Is input validated and sanitized?
</verification_loop>

Requirement: [DESCRIBE THE ENDPOINT NEED]
Tech stack: [e.g., Node.js/Express, Python/FastAPI, Go/Gin]

Design a database schema for the following requirements.

<output_contract>
1. **ER Diagram** — entities, relationships, cardinality (text description)
2. **SQL DDL** — CREATE TABLE statements with types, constraints, indexes
3. **Indexes** — explain why each index exists (query pattern it serves)
4. **Migration Script** — versioned up/down migration
5. **Sample Queries** — 3 common queries the schema supports
</output_contract>

<verification_loop>
- Is the schema at least 3NF?
- Are foreign keys and cascading deletes handled correctly?
- Will the indexes support the expected read patterns without excessive write overhead?
</verification_loop>

Requirements: [DESCRIBE YOUR DATA MODEL]
Database: [PostgreSQL/MySQL/SQLite]

Perform a security audit on the code below. Focus on OWASP Top 10 vulnerabilities.

<output_contract>
For each finding:
- **Severity**: CRITICAL / HIGH / MEDIUM / LOW
- **Vulnerability**: type (e.g., SQL Injection, XSS, IDOR)
- **Location**: file/line/function
- **Impact**: what an attacker could do
- **Fix**: specific code change
If no vulnerabilities found, state "No issues found" with confidence level.
</output_contract>

<dig_deeper_nudge>
- Check authentication bypasses, privilege escalation, data exposure.
- Look for hardcoded secrets, insecure defaults, missing rate limits.
- Consider supply chain risks in dependencies.
</dig_deeper_nudge>

Code to audit:
```
[PASTE CODE]
```

Analyze and optimize the performance of this code.

<output_contract>
1. **Current Complexity** — time and space (Big O)
2. **Bottlenecks** — ranked list of hotspots with explanation
3. **Optimized Code** — rewritten version with improvements
4. **New Complexity** — time and space after optimization
5. **Tradeoffs** — what was sacrificed (if anything) for the speedup
</output_contract>

Consider: algorithmic improvements, data structure choices, caching opportunities,
I/O reduction, and parallelization potential.

Code to optimize:
```
[PASTE CODE]
```
Context: [e.g., "called 10K times/sec", "dataset is ~1M rows"]

Implement the following feature end-to-end.

<self_reflection>
Before writing code, create an internal quality rubric with 5-7 categories
(correctness, security, performance, readability, UX, error handling, testability).
Iterate on your solution until it scores highly on all categories.
</self_reflection>

<output_contract>
Deliver in this order:
1. **Plan** — 5-bullet implementation plan
2. **Database** — migration/schema changes
3. **Backend** — API routes, business logic, validation
4. **Frontend** — components, state management, API integration
5. **Tests** — key test cases for each layer
</output_contract>

Tech stack: [e.g., Next.js, TypeScript, Prisma, PostgreSQL]
Feature: [DESCRIBE THE FEATURE]

API usage (Python):
  reasoning={"effort": "xhigh"}, text={"verbosity": "high"}
  # xhigh recommended — this is a long-horizon, multi-step reasoning task

Generate documentation for the following code.

<output_contract>
Format: [Markdown README / JSDoc / Python docstrings / Go doc comments]
Include:
- Purpose and overview (2-3 sentences)
- Parameters/arguments with types and descriptions
- Return values with types
- Usage examples (at least 2)
- Error cases and how they are handled
Do NOT add redundant comments that merely restate the code.
</output_contract>

Code to document:
```
[PASTE CODE]
```

Write a blog post on the topic below.

<personality_and_writing_controls>
- Persona: Experienced industry practitioner who teaches clearly
- Channel: Blog
- Emotional register: Confident and approachable, not academic or salesy
- Formatting: Use H2/H3 headings, short paragraphs (2-3 sentences), bullet lists where helpful
- Length: 1200-1800 words
</personality_and_writing_controls>

<output_contract>
Structure:
1. Hook opening (no generic "In today's world..." starters)
2. 3-5 main sections with H2 headings
3. Practical examples or data points in each section
4. Actionable conclusion with clear next steps
Include: meta title (60 chars), meta description (155 chars), 5 SEO keywords
</output_contract>

Topic: [YOUR TOPIC]
Target audience: [WHO READS THIS]
Target keyword: [PRIMARY KEYWORD]

Write a 3-email cold outreach sequence.

<personality_and_writing_controls>
- Persona: Peer who genuinely wants to help, not a pushy salesperson
- Channel: Email
- Emotional register: Direct and warm, not desperate or overly formal
- Formatting: No bullets in emails. Plain text, short paragraphs.
- Length: Email 1: <=100 words, Email 2: <=80 words, Email 3: <=60 words
</personality_and_writing_controls>

<output_contract>
For each email provide:
- Subject line (under 50 characters, no clickbait)
- Body text
- [PERSONALIZATION] placeholders where prospect-specific details go
- Send timing recommendation (days after previous)
</output_contract>

Product/Service: [WHAT YOU SELL]
Target persona: [THEIR ROLE AND PAIN POINT]
Key value prop: [WHY THEY SHOULD CARE]

Create a product launch announcement package.

<personality_and_writing_controls>
- Persona: The company's brand voice — [DESCRIBE: e.g., innovative and bold]
- Emotional register: Excited but grounded in specifics, not hype
- Length: Press release 400 words, each social post <280 chars, email 200 words
</personality_and_writing_controls>

<output_contract>
Deliver exactly:
1. **Press Release** — headline, subhead, 3-paragraph body, boilerplate, quote from exec
2. **Twitter/X Post** — 3 variations (hook, feature-focus, social-proof)
3. **LinkedIn Post** — 1 longer-form post with storytelling angle
4. **Email to Customers** — subject line + body announcing the launch
</output_contract>

Product: [PRODUCT NAME AND DESCRIPTION]
Key features: [TOP 3 FEATURES]
Launch date: [DATE]
Target audience: [WHO]

Write an executive summary memo.

<memo_mode>
- Write in a polished, professional memo style.
- Use exact names, dates, entities, and authorities when supported by the record.
- Prefer precise conclusions over generic hedging.
- When uncertainty is real, tie it to the exact missing fact or conflicting source.
- Synthesize across inputs rather than summarizing each one independently.
</memo_mode>

<output_contract>
Format:
- TO / FROM / DATE / RE header
- **Bottom Line Up Front** (2-3 sentences)
- **Key Findings** (3-5 bullet points)
- **Recommendation** (1-2 sentences with confidence level)
- **Next Steps** (action items with owners and deadlines)
Total length: 300-500 words.
</output_contract>

Context: [PASTE BACKGROUND MATERIAL / DATA / SITUATION]
Decision needed: [WHAT DECISION IS THIS SUPPORTING]

Create a 7-day social media content calendar.

<output_contract>
For each day provide:
| Day | Platform | Post Text | Hashtags | Best Time | Content Type |
Platforms: Twitter/X, LinkedIn, Instagram
Content mix: 40% educational, 30% engagement, 20% promotional, 10% behind-the-scenes
Output as a Markdown table.
</output_contract>

<verbosity_controls>
- Twitter posts: max 240 characters
- LinkedIn: max 300 words
- Instagram captions: max 150 words + 10 hashtags
</verbosity_controls>

Brand: [BRAND NAME AND DESCRIPTION]
Industry: [YOUR INDUSTRY]
Key message this week: [THEME OR CAMPAIGN]
Tone: [e.g., professional, playful, authoritative]

Write landing page copy that converts.

<output_contract>
Sections in order:
1. **Hero** — headline (max 10 words), subheadline (max 25 words), CTA button text
2. **Problem** — 2-3 sentences describing the pain point
3. **Solution** — how the product solves it (3 bullet points)
4. **Features** — 3 features with icon-friendly titles and 1-sentence descriptions
5. **Social Proof** — 2 testimonial templates with [PLACEHOLDER] fields
6. **Final CTA** — urgency-driven closing with button text
</output_contract>

<personality_and_writing_controls>
- Emotional register: Confident and specific, not generic or hyperbolic
- Ban phrases: "revolutionize", "game-changing", "world-class", "cutting-edge"
- Every claim must be backed by a specific benefit or metric
</personality_and_writing_controls>

Product: [NAME AND DESCRIPTION]
Target customer: [WHO]
Key differentiator: [WHY YOU vs COMPETITORS]

Write a technical tutorial on the topic below.

<output_contract>
Structure:
1. **What You'll Build** — 2-sentence outcome description
2. **Prerequisites** — bullet list of required tools/knowledge
3. **Steps** — numbered, each with explanation + code block + expected output
4. **Common Errors** — 3 pitfalls with solutions
5. **Next Steps** — where to go from here
</output_contract>

<personality_and_writing_controls>
- Persona: Senior developer explaining to a mid-level colleague
- Formatting: Use numbered steps, code fences with language tags
- Ban: "simply", "just", "easy" — respect the reader's learning process
</personality_and_writing_controls>

Topic: [TUTORIAL TOPIC]
Target reader: [SKILL LEVEL AND BACKGROUND]
Tech stack: [TOOLS AND VERSIONS]

Rewrite the text below in the specified tone and style.

<personality_and_writing_controls>
- Target tone: [e.g., casual and witty / formal and authoritative / warm and empathetic]
- Target audience: [WHO WILL READ THIS]
- Constraints: Preserve all factual content and key messages.
  Do not add new claims. Do not remove critical information.
- Length: Same as original (within 10%)
</personality_and_writing_controls>

<output_contract>
Return only the rewritten text. No explanations or comparisons.
</output_contract>

Original text:
"""
[PASTE TEXT HERE]
"""

Conduct deep research on the topic below and produce a comprehensive report.

<research_mode>
Do research in 3 passes:
1) Plan: list 3-6 sub-questions to answer.
2) Retrieve: investigate each sub-question, follow 1-2 second-order leads.
3) Synthesize: resolve contradictions and write the final report with citations.
Stop only when more searching is unlikely to change the conclusion.
</research_mode>

<citation_rules>
- Only cite sources retrieved in the current workflow.
- Never fabricate citations, URLs, or quotes.
- Attach citations to specific claims, not only at the end.
- If sources conflict, state the conflict and attribute each side.
</citation_rules>

<output_contract>
1. **Executive Summary** (200 words)
2. **Key Findings** (organized by sub-question)
3. **Analysis** (evidence-backed, with inline citations)
4. **Limitations** (what the research could not answer)
5. **Sources** (numbered reference list)
</output_contract>

Research topic: [YOUR TOPIC]
Scope/constraints: [TIME PERIOD, GEOGRAPHY, INDUSTRY]

Perform a competitive analysis for the following product/market.

<research_mode>
1) Plan: identify 3-5 key competitors and 4-6 comparison dimensions.
2) Retrieve: gather data on each competitor across all dimensions.
3) Synthesize: compare, rank, and identify strategic opportunities.
</research_mode>

<output_contract>
1. **Competitor Overview** — table: name, founding, funding, key product, target market
2. **Feature Comparison** — matrix table with checkmarks/ratings
3. **SWOT for Each** — 4 bullets per quadrant, per competitor
4. **Market Positioning Map** — describe where each sits (price vs. quality or similar)
5. **Strategic Implications** — 3-5 opportunities for your product
</output_contract>

Your product: [NAME AND DESCRIPTION]
Market: [INDUSTRY AND GEOGRAPHY]
Known competitors: [LIST OR "identify automatically"]

Analyze the following data and extract actionable insights.

<output_contract>
1. **Summary Statistics** — key metrics at a glance
2. **Trends** — 3-5 significant patterns with evidence
3. **Anomalies** — anything unusual that warrants investigation
4. **Root Causes** — likely explanations for the top findings
5. **Recommendations** — 3 concrete actions ranked by expected impact
</output_contract>

<grounding_rules>
- Base claims only on the provided data.
- If the data is insufficient, narrow the answer or state what additional data is needed.
- Label inferences explicitly — distinguish correlation from causation.
</grounding_rules>

Data:
```
[PASTE DATA: CSV, JSON, or table format]
```
Context: [WHAT THIS DATA REPRESENTS]
Business question: [WHAT YOU WANT TO LEARN]

Review the following papers/documents and synthesize the findings.

<research_mode>
1) Plan: identify key themes, methodologies, and claims across the papers.
2) Retrieve: extract evidence for each theme from each paper.
3) Synthesize: resolve contradictions, identify consensus, and note gaps.
</research_mode>

<citation_rules>
- Cite using [Author, Year] format inline.
- Never fabricate citations.
- If papers conflict, present both sides with citations.
</citation_rules>

<output_contract>
1. **Overview** — scope, number of papers, time range
2. **Thematic Synthesis** — organized by theme, not by paper
3. **Methodology Comparison** — table of approaches used
4. **Consensus & Disagreements** — where authors agree and diverge
5. **Research Gaps** — what remains unanswered
6. **Implications** — practical takeaways
</output_contract>

Papers/Documents:
[PASTE ABSTRACTS OR FULL TEXT]

Estimate the market size (TAM, SAM, SOM) for the following product/market.

<output_contract>
1. **Definitions** — TAM, SAM, SOM defined for this specific context
2. **Methodology** — bottom-up calculation steps with formulas
3. **Assumptions** — numbered list, each with source or rationale
4. **Calculations** — step-by-step math with intermediate results
5. **Results Table** — TAM/SAM/SOM in annual revenue
6. **Sensitivity Analysis** — how results change if top 3 assumptions vary +/-25%
7. **Confidence Level** — high/medium/low with explanation
</output_contract>

<grounding_rules>
- Label each assumption as "data-backed" or "estimated."
- If a number is a rough estimate, provide a range.
</grounding_rules>

Product: [WHAT YOU'RE SIZING]
Geography: [MARKET REGION]
Known data points: [ANY DATA YOU HAVE]

Review the following contract/legal document. This is NOT legal advice.

<output_contract>
1. **Document Type & Parties** — what it is and who is involved
2. **Key Terms** — table: term, value/description, section reference
3. **Obligations** — what each party must do, with deadlines
4. **Risk Flags** — clauses that are unusual, one-sided, or potentially problematic
5. **Missing Clauses** — standard provisions that are absent
6. **Plain-English Summary** — 200-word version a non-lawyer can understand
</output_contract>

<grounding_rules>
- Quote specific clause numbers for every finding.
- Never invent clause numbers or content not in the document.
- Flag ambiguous language explicitly.
</grounding_rules>

Document:
"""
[PASTE DOCUMENT TEXT]
"""

Help me make a decision using a structured framework.

<output_contract>
1. **Decision Statement** — restate the decision clearly
2. **Options** — list all viable options (add any I missed)
3. **Criteria** — 5-7 evaluation criteria with weights (must sum to 100%)
4. **Scoring Matrix** — table with options as rows, criteria as columns, scores 1-5
5. **Weighted Totals** — calculated scores
6. **Recommendation** — the winning option with rationale
7. **Risk Check** — what could go wrong with the top choice
</output_contract>

Decision: [WHAT I'M DECIDING]
Options I'm considering: [LIST OPTIONS]
What matters most: [KEY PRIORITIES]
Constraints: [BUDGET, TIME, RESOURCES]

Extract structured information from the following meeting notes/transcript.

<output_contract>
1. **Meeting Summary** — 3-sentence overview
2. **Key Decisions** — numbered list with context
3. **Action Items** — table: | Owner | Action | Deadline | Priority |
4. **Open Questions** — unresolved items that need follow-up
5. **Parking Lot** — topics raised but deferred
</output_contract>

<verbosity_controls>
- Be concise. Each action item: one clear sentence.
- If a deadline was not mentioned, mark as "TBD."
- If an owner was not assigned, mark as "UNASSIGNED."
</verbosity_controls>

Meeting notes:
"""
[PASTE TRANSCRIPT OR NOTES]
"""

You have computer-use capabilities. Complete the following web task.

<computer_use_rules>
- Navigate to the target URL and wait for full page load.
- Use image detail level "original" for click-accuracy on dense layouts.
- Before clicking any button, verify the element text matches the intended action.
- For forms: fill fields in top-to-bottom order, verify each field after entry.
- Take a screenshot after each major step for verification.
</computer_use_rules>

<action_safety>
- Pre-flight: summarize the intended action in 1-2 lines before executing.
- Do NOT click submit/purchase/delete without explicit user confirmation.
- Post-flight: confirm the outcome after each action.
</action_safety>

<output_contract>
After completion, report:
1. **Steps Taken** — numbered list of actions performed
2. **Data Extracted** — structured output (table or JSON)
3. **Verification** — screenshot description confirming success
</output_contract>

Task: [DESCRIBE: e.g., "Go to example.com, search for X, extract the first 10 results"]
URL: [STARTING URL]

You have computer-use capabilities. Fill out the form at the specified URL.

<computer_use_rules>
- Navigate to the form URL and identify all required fields.
- Fill fields using the data provided below.
- For dropdowns: click to open, scroll to find the correct option, click to select.
- For date pickers: enter date in the format shown on the form.
- After filling all fields, take a screenshot for review BEFORE submitting.
</computer_use_rules>

<verification_loop>
Before clicking submit:
- Verify all required fields are filled (no red borders or error messages).
- Confirm dropdown selections show the correct values.
- Check date formats match what the form expects.
- Ask user for confirmation before final submit.
</verification_loop>

Form URL: [URL]
Data to fill:
- Name: [VALUE]
- Email: [VALUE]
- [ADD MORE FIELDS AS NEEDED]

You have computer-use capabilities. Test the following web application UI flow.

<computer_use_rules>
- Use image detail "original" for pixel-accurate visual inspection.
- Navigate through each step of the test flow.
- At each step, check: layout correctness, text content, interactive elements, responsive behavior.
- Test at viewport widths: 1440px (desktop), 768px (tablet), 375px (mobile).
</computer_use_rules>

<output_contract>
For each step in the flow, report:
| Step | Action | Expected | Actual | Status | Screenshot |
Mark status as: PASS, FAIL, or WARNING.

Summary at end:
- Total steps: X
- Passed: X
- Failed: X
- Warnings: X
- Critical issues that block release
</output_contract>

Application URL: [URL]
Test flow: [DESCRIBE STEP BY STEP: e.g., "1. Click Sign Up, 2. Fill form, 3. Submit, 4. Verify confirmation page"]

You have computer-use capabilities. Complete this multi-application desktop workflow.

<computer_use_rules>
- Use image detail "original" for accurate element targeting.
- Between application switches, wait for the new app to fully load.
- Use keyboard shortcuts when available (faster and more reliable than clicking menus).
- If a dialog box or popup appears unexpectedly, screenshot it and describe before proceeding.
</computer_use_rules>

<action_safety>
- Pre-flight: describe each action before executing it.
- For file saves, deletions, or sends: confirm with user first.
- Post-flight: verify the action completed successfully.
</action_safety>

<dependency_checks>
- Before each step, verify the prerequisite from the previous step completed.
- If an app is not open, open it first.
- If a file is not found, search for it before reporting failure.
</dependency_checks>

Workflow:
[DESCRIBE STEP BY STEP: e.g.,
"1. Open Excel file quarterly_report.xlsx
 2. Copy the chart from Sheet2
 3. Open PowerPoint presentation deck.pptx
 4. Paste chart on slide 5
 5. Save and close both files"]

Analyze the provided screenshot and extract all visible data.

<bbox_extraction_spec>
- Use image detail "original" for maximum fidelity.
- Process the image region by region (top-to-bottom, left-to-right).
- For tables: extract as structured data (CSV or JSON).
- For charts: describe the type, axes, data points, and trends.
- For text: OCR all visible text preserving layout hierarchy.
</bbox_extraction_spec>

<output_contract>
1. **Image Description** — what the screenshot shows (1-2 sentences)
2. **Extracted Data** — structured format (table, JSON, or key-value pairs)
3. **Visual Elements** — charts, icons, or indicators and their meaning
4. **Confidence Notes** — flag any text or values that were hard to read
</output_contract>

[ATTACH SCREENSHOT IMAGE]
Context: [WHAT THIS IMAGE SHOWS, e.g., "sales dashboard", "invoice scan"]

You are an autonomous agent. Complete the task fully before returning to the user.

<autonomy_and_persistence>
- Persist until the task is fully handled end-to-end.
- Do not stop at analysis or partial fixes — carry through to completion.
- Never ask for confirmation on reversible, low-risk actions. Just proceed.
- If you encounter blockers, attempt to resolve them yourself.
</autonomy_and_persistence>

<completeness_contract>
- Treat the task as incomplete until all requested items are covered.
- Keep an internal checklist of required deliverables.
- If any item is blocked, mark it [BLOCKED] with the specific reason.
- Confirm coverage before finalizing.
</completeness_contract>

<tool_persistence_rules>
- Use tools whenever they improve correctness or completeness.
- Do not stop early when another tool call would help.
- If a tool returns empty results, retry with a different strategy.
- Keep calling tools until the task is complete AND verification passes.
</tool_persistence_rules>

<user_updates_spec>
- Update the user only when starting a new major phase.
- Each update: 1 sentence on outcome + 1 sentence on next step.
- Do not narrate routine tool calls.
</user_updates_spec>

Task: [DESCRIBE THE MULTI-STEP TASK]

You are an agent with access to multiple tools. Optimize for speed and correctness.

<parallel_tool_calling>
- When multiple retrieval or lookup steps are independent, prefer parallel tool calls.
- Do NOT parallelize steps that have prerequisite dependencies.
- After parallel retrieval, pause to synthesize results before making more calls.
- Prefer selective parallelism: parallelize independent evidence gathering,
  not speculative or redundant tool use.
</parallel_tool_calling>

<dependency_checks>
- Before any action, check if prerequisite discovery or lookup steps are needed.
- Do not skip prerequisites just because the final action seems obvious.
- If the task depends on a prior step's output, resolve that dependency first.
</dependency_checks>

<empty_result_recovery>
If a lookup returns empty or partial results:
- Do not immediately conclude no results exist.
- Try at least 2 fallback strategies (alternate query, broader filters, different tool).
- Only then report "no results found" along with what you tried.
</empty_result_recovery>

Available tools: [LIST YOUR TOOLS]
Task: [DESCRIBE THE TASK]

You are an agent handling tasks that may include irreversible actions.

<default_follow_through_policy>
- If the next step is reversible and low-risk, proceed without asking.
- Ask permission ONLY if the next step is:
  (a) irreversible,
  (b) has external side effects (sending, purchasing, deleting, writing to production), or
  (c) requires missing sensitive information.
- If proceeding, briefly state what you did and what remains optional.
</default_follow_through_policy>

<verification_loop>
Before finalizing any action:
- Check correctness: does the output satisfy every requirement?
- Check grounding: are factual claims backed by context or tool outputs?
- Check formatting: does output match requested schema?
- Check safety: if the next step has external side effects, ask permission first.
</verification_loop>

<action_safety>
- Pre-flight: summarize the intended action and parameters in 1-2 lines.
- Execute via tool.
- Post-flight: confirm the outcome and any validation performed.
</action_safety>

<missing_context_gating>
- If required context is missing, do NOT guess.
- Use a lookup tool when the missing context is retrievable.
- Ask a clarifying question only when lookup is not possible.
- If you must proceed, label assumptions explicitly.
</missing_context_gating>

Task: [DESCRIBE THE TASK]
Safe actions (proceed freely): [e.g., read, search, list]
Dangerous actions (ask first): [e.g., delete, deploy, send, purchase]

You are an agent in a long-running session. Maintain consistency across many turns.

<instruction_priority>
- User instructions override default style, tone, and formatting preferences.
- Safety, honesty, and privacy constraints never yield.
- If a newer instruction conflicts with an earlier one, follow the newer instruction.
- Preserve earlier instructions that do not conflict.
</instruction_priority>

<task_update>
When the user changes the task mid-conversation:
- Explicitly state what changed, what still applies, and the new scope.
- Do not silently drop previous context.
- If the change invalidates prior work, say so.
</task_update>

<completeness_contract>
- Maintain an internal progress tracker across turns.
- At the start of each turn, briefly recall: current task, progress, next step.
- Never lose track of partially completed work.
</completeness_contract>

<user_updates_spec>
- Update when starting a new major phase or when something changes the plan.
- 1 sentence on outcome + 1 sentence on next step.
- Do not narrate routine actions.
</user_updates_spec>

Session context: [DESCRIBE THE ONGOING PROJECT]
Current phase: [WHERE WE ARE NOW]

You are an autonomous research agent with web search capability.

<research_mode>
Do research in 3 passes:
1) Plan: list 3-6 sub-questions to answer.
2) Retrieve: search each sub-question, follow 1-2 second-order leads.
3) Synthesize: resolve contradictions and write the final answer with citations.
Stop only when more searching is unlikely to change the conclusion.
</research_mode>

<citation_rules>
- Only cite sources retrieved in the current workflow.
- Never fabricate citations, URLs, IDs, or quote spans.
- Use exactly the citation format: [Source Title](URL)
- Attach citations to specific claims, not only at the end.
</citation_rules>

<grounding_rules>
- Base claims only on retrieved content.
- If sources conflict, state the conflict explicitly and attribute each side.
- If context is insufficient, narrow the answer rather than speculate.
- Label inferences as inferences.
</grounding_rules>

<tool_persistence_rules>
- Search thoroughly. If first results are thin, try alternate queries.
- Follow promising leads 1-2 levels deep.
- Do not conclude "no information available" after a single search.
</tool_persistence_rules>

Research question: [YOUR QUESTION]
Scope: [ANY CONSTRAINTS: time period, geography, sources to prioritize]

Analyze the following financial statements.

GPT-5.4 excels at spreadsheet and finance workflows with strong self-verification.
Use this with reasoning effort "high" for thorough ratio analysis.

<output_contract>
1. **Overview** — company, period, statement type (2 sentences)
2. **Key Metrics** — table of important ratios:
   | Metric | Formula | Value | YoY Change | Industry Benchmark |
3. **Trend Analysis** — 3-5 significant trends with evidence
4. **Red Flags** — anything concerning (declining margins, rising debt, etc.)
5. **Strengths** — positive indicators
6. **Conclusion** — overall financial health assessment (1 paragraph)
</output_contract>

<verification_loop>
Before finalizing:
- Double-check all ratio calculations (recompute to catch arithmetic errors).
- Verify YoY changes use the correct base year.
- Confirm that conclusions follow from the data, not assumptions.
</verification_loop>

<grounding_rules>
- Calculate ratios from the provided data. Show your math.
- If benchmark data is not provided, clearly state "benchmark not available."
- Distinguish between facts from the data and your interpretation.
</grounding_rules>

Financial data:
```
[PASTE FINANCIAL STATEMENT DATA]
```
Company: [NAME]
Period: [QUARTER/YEAR]

API usage (Python):
  reasoning={"effort": "high"}, text={"verbosity": "low"}
  # GPT-5.4 has specific strengths in finance/spreadsheet accuracy

Create Excel formulas or a spreadsheet solution for the following requirement.

GPT-5.4 has top-tier instruction following for spreadsheet workflows,
including formatting fidelity and stronger self-verification of formulas.

<output_contract>
1. **Formula(s)** — ready-to-paste Excel formulas with cell references
2. **Explanation** — what each part of the formula does (for complex formulas)
3. **Sheet Layout** — suggested column headers and sample data (3 rows)
4. **Validation** — how to verify the formula works (expected output for sample data)
5. **VBA Macro** (if needed) — complete macro code with comments
</output_contract>

<structured_output_contract>
- Output only valid Excel syntax. Do not wrap formulas in markdown code fences.
- Validate that all parentheses and brackets are balanced.
- Use named ranges where it improves readability.
- For array formulas, specify if Ctrl+Shift+Enter is needed (or if LAMBDA/LET applies).
</structured_output_contract>

<verification_loop>
Before finalizing:
- Mentally trace the formula with sample data and verify the output matches.
- Check for common pitfalls: division by zero, empty cell handling, date format mismatch.
</verification_loop>

Requirement: [WHAT THE SPREADSHEET SHOULD DO]
Current setup: [DESCRIBE COLUMNS, e.g., "Column A = dates, Column B = revenue"]
Excel version: [e.g., Microsoft 365, Excel 2019]

API usage (Python):
  reasoning={"effort": "medium"}, text={"verbosity": "high"}

Create a budget plan and financial forecast.

<output_contract>
1. **Assumptions** — numbered list of all assumptions with sources
2. **Revenue Forecast** — monthly/quarterly projections with growth rates
3. **Expense Budget** — categorized by: fixed, variable, one-time
4. **Cash Flow Projection** — monthly for 12 months
5. **Scenario Analysis** — Optimistic / Base / Pessimistic with key variable changes
6. **Break-Even Analysis** — when do revenues cover costs?
7. **KPI Dashboard** — 5-7 metrics to track monthly
</output_contract>

<verification_loop>
- Do all numbers add up correctly?
- Are growth rate assumptions reasonable for the industry?
- Does the cash flow projection account for payment timing?
</verification_loop>

Business: [DESCRIBE YOUR BUSINESS]
Historical data: [PASTE OR DESCRIBE PAST FINANCIALS]
Planning period: [e.g., FY2027]
Key goals: [REVENUE TARGET, PROFITABILITY TARGET]

Clean and transform the following dataset.

<output_contract>
1. **Data Quality Report** — issues found:
   | Issue Type | Column | Count | Example |
   (duplicates, nulls, format inconsistencies, outliers)
2. **Cleaning Steps** — numbered list of transformations applied
3. **Cleaned Data** — the first 20 rows in the target format
4. **Transformation Code** — Python/SQL script to reproduce the cleaning
5. **Validation** — row counts before/after, checksum on key columns
</output_contract>

<structured_output_contract>
- Output cleaned data in the requested format (CSV, JSON, SQL INSERT).
- Do not invent data to fill gaps — mark unknowns as NULL.
- Preserve original column names unless instructed otherwise.
</structured_output_contract>

Raw data:
```
[PASTE DATA SAMPLE]
```
Target format: [DESIRED COLUMN STRUCTURE]
Known issues: [ANY ISSUES YOU ALREADY KNOW ABOUT]