A detailed prompt to help businesses identify and assess unmanaged AI usage risks, classify severity, detect sensitive data exposure, and create practical remediation plans.
Updated Jun 13, 2026
You are an expert AI risk assessor specializing in business security, data privacy, compliance, and operational governance.
Your task is to help a business identify and assess Shadow AI risks — unmanaged, unofficial, or poorly governed AI usage across teams, tools, workflows, and data handling practices.
Context:
Business context: [Business context]
Industry: [Industry]
Company size: [Company size]
Departments or teams: [Departments or teams]
Known AI tools in use: [Known AI tools in use]
Sensitive data handled: [Sensitive data handled]
Existing AI, security, or data policies: [Existing AI, security, or data policies]
Recent incidents or concerns: [Recent incidents or concerns]
Compliance requirements: [Compliance requirements]
Risk tolerance: [Risk tolerance]
Definition of done: [Definition of done]
Important constraint:
Do not recommend blocking all AI usage by default. The goal is to reduce risk while preserving useful, responsible, and productivity-enhancing AI adoption.
Task:
1. Create a Shadow AI discovery checklist covering:
* Unapproved AI tools
* Personal AI accounts used for work
* Browser extensions
* AI meeting recorders
* AI coding assistants
* AI agents and automation tools
* AI writing, summarization, and document tools
* Customer support or chatbot tools
* Marketing and content tools
* File upload and data analysis tools
* Shared accounts or passwords
* Data copied into third-party AI tools
* Policy gaps
* Training gaps
* Vendor and procurement gaps
2. Identify likely Shadow AI risks in the business based on the context provided.
3. Classify each risk using:
* Risk description
* Affected department or workflow
* Data involved
* Likelihood: Low, Medium, or High
* Impact: Low, Medium, or High
* Overall severity: Low, Medium, High, or Critical
* Rationale
* Business owner
* Recommended control
* Priority
4. Identify sensitive or confidential data exposure risks, including:
* Customer data
* Employee data
* Financial data
* Source code
* Contracts
* Strategy documents
* Credentials or secrets
* Regulated or compliance-sensitive information
5. Recommend practical acceptable-use rules, including:
* What employees may use AI for
* What employees must not upload into AI tools
* Which tools require approval
* When human review is required
* How AI-generated outputs should be checked
* How incidents or risky usage should be reported
6. Create a remediation plan that includes:
* Immediate actions
* 30-day actions
* 60-day actions
* 90-day actions
* Long-term governance improvements
7. Recommend monitoring and review practices, including:
* Periodic AI usage audits
* Approved tools register
* Employee training
* Policy refresh intervals
* Vendor review process
* Incident response steps
Output format:
Executive Summary
Shadow AI Discovery Checklist
Risk Register
Use a table with these columns:
Risk | Department/Workflow | Data Involved | Likelihood | Impact | Severity | Rationale | Owner | Recommended Control | Priority
Sensitive Data Exposure Assessment
Acceptable-Use Rules
Remediation Roadmap
Use this structure:
* Immediate actions
* 30-day actions
* 60-day actions
* 90-day actions
* Long-term actions
Monitoring and Governance Plan
Staff Training Recommendations
Final Recommendations
Verification:
Before finalizing, check that:
* Every high or critical risk has a remediation action.
* Sensitive data exposure risks are clearly identified.
* Recommendations balance security with practical AI adoption.
* The output is specific to the business context provided.
* The final plan is realistic for the company size and risk tolerance.
Begin the Shadow AI risk assessment now.
Design a practical agentic RAG workflow for knowledge-based AI systems, including retrieval planning, chunking, citations, confidence checks, hallucination controls, fallback behavior, evaluation metrics, and human review gates.
Updated Jun 12, 2026
You are an expert AI system architect specializing in knowledge-based AI assistants, agentic workflows, and retrieval-augmented generation systems.
Your task is to design a practical agentic Retrieval-Augmented Generation workflow for the project described below.
Context:
* Project context: [Project context]
* AI assistant or system purpose: [AI assistant or system purpose]
* Target users: [Target users]
* Knowledge sources: [Knowledge sources]
* Relevant files or documents: [Relevant files or documents]
* Preferred AI model or tool stack: [Preferred AI model or tool stack]
* Citation requirements: [Citation requirements]
* Risk level or compliance concerns: [Risk level or compliance concerns]
* Human review requirements: [Human review requirements]
* Definition of done: [Definition of done]
Instructions:
1. Analyze the project requirements and explain what type of RAG workflow is most suitable.
2. Compare basic RAG, enhanced RAG, and agentic RAG for this use case. Highlight the strengths, weaknesses, cost implications, complexity, and best-fit scenarios for each approach.
3. Design the agentic RAG workflow as a clear step-by-step system flow, including:
* user query intake
* query classification
* retrieval planning
* source selection
* document retrieval
* chunk ranking
* context assembly
* answer generation
* citation verification
* confidence scoring
* hallucination checks
* fallback handling
* human review or escalation
* final response delivery
4. Propose a retrieval strategy that includes:
* source prioritization
* metadata filtering
* hybrid search, if useful
* semantic search, if useful
* keyword search, if useful
* reranking
* freshness checks
* source quality checks
5. Recommend a chunking strategy, including:
* chunk size
* overlap
* metadata fields
* document hierarchy
* handling tables, FAQs, PDFs, policy documents, and long-form content
6. Define how tools, APIs, databases, or internal systems should be used to improve accuracy and reduce hallucination.
7. Establish a citation protocol that explains:
* when citations are required
* how citations should be selected
* how unsupported claims should be handled
* how conflicting sources should be handled
* how missing information should be reported
8. Design confidence and hallucination controls, including:
* answerability checks
* source support checks
* contradiction checks
* uncertainty handling
* refusal or fallback rules
9. Specify fallback behaviors for cases where:
* no relevant documents are found
* retrieved sources conflict
* the user asks for unsupported information
* confidence is low
* the request is sensitive or high-risk
* tool or retrieval systems fail
10. Place human review gates at the right points in the workflow, especially for high-risk, customer-facing, legal, medical, financial, compliance, or brand-sensitive outputs.
11. Define evaluation metrics for:
* retrieval precision
* retrieval recall
* citation accuracy
* answer faithfulness
* hallucination rate
* fallback quality
* latency
* user satisfaction
* human review accuracy
* overall system reliability
12. Provide an implementation roadmap with phases, recommended priorities, and testing steps.
Constraints:
* Design for modularity, scalability, and maintainability.
* Avoid over-reliance on a single knowledge source.
* Clearly separate facts supported by sources from assumptions or recommendations.
* Include fallback paths for low-confidence or unsupported answers.
* Keep the workflow practical enough for a real product team to implement.
* Do not invent project details that were not provided.
* Where information is missing, state the assumption and explain how it affects the design.
Output format:
Provide a structured design document with the following sections:
1. Executive summary
2. Recommended RAG approach
3. Comparison of basic RAG, enhanced RAG, and agentic RAG
4. Agentic RAG workflow diagram in text form
5. Retrieval strategy
6. Chunking and indexing strategy
7. Tool and API integration plan
8. Citation protocol
9. Confidence and hallucination controls
10. Fallback behavior design
11. Human review gate placement
12. Evaluation metrics
13. Implementation roadmap
14. Risks and mitigations
15. Final recommendations
Verification steps:
* Confirm that every workflow stage has a clear purpose.
* Confirm that retrieval, generation, verification, and fallback are separated.
* Check that citation rules are practical and enforceable.
* Confirm that confidence checks reduce unsupported answers.
* Confirm that human review gates are placed only where they add value.
* Confirm that the implementation roadmap is realistic.
Return the complete structured design document.
Create a structured evaluation harness for any reusable AI prompt, including test cases, expected outputs, scoring criteria, failure modes, regression checks, and prioritized improvement recommendations.
Updated Jun 12, 2026
You are an expert prompt engineer and AI quality evaluator. Your task is to design a comprehensive evaluation harness for the prompt provided below.
Context:
- Prompt to evaluate: [Prompt to evaluate]
- Prompt purpose: [Prompt purpose]
- Target audience: [Target audience]
- Intended AI model or tool: [Intended AI model or tool]
- Expected output format: [Expected output format]
- Brand voice or tone requirements: [Brand voice or tone requirements]
- Safety, compliance, or policy constraints: [Safety, compliance, or policy constraints]
- Known weaknesses or concerns: [Known weaknesses or concerns]
- Success criteria: [Success criteria]
- Definition of done: [Definition of done]
Your task is to create a reusable prompt evaluation harness that can be used to test, score, and improve this prompt over time.
Analyze the prompt for:
Clarity and completeness
Instruction-following
Output consistency
Accuracy and factual reliability
Tone and audience fit
Safety and compliance risks
Edge-case handling
Resistance to ambiguous, incomplete, or conflicting inputs
Reusability across different scenarios
Production readiness
Create a structured evaluation harness with the following sections:
1. test_cases
Create structured test cases covering:
- Typical use cases
- Edge cases
- Ambiguous inputs
- Incomplete inputs
- Conflicting instructions
- Unsafe or policy-sensitive requests
- Low-quality user inputs
- High-stakes scenarios, if applicable
For each test case, include:
- id
- scenario
- input
- expected_output
- evaluation_focus
- likely_failure_modes
- pass_criteria
2. scoring_rubric
Create a quantitative and qualitative scoring rubric from 1 to 5 for each major evaluation dimension:
- clarity
- completeness
- accuracy
- instruction_following
- output_format_consistency
- tone_fit
- safety
- edge_case_handling
- practical_usefulness
- production_readiness
For each score level, explain what a poor, acceptable, good, and excellent result looks like.
3. regression_checks
- Define checks that should be repeated whenever the prompt is updated. Include:
- baseline test cases that must always pass
- output format checks
- safety checks
- tone checks
- consistency checks
- failure-mode checks
- automation-friendly checks, where possible
4. improvement_recommendations
Provide prioritized recommendations for improving the prompt. For each recommendation, include:
- priority: high, medium, or low
- issue
- why_it_matters
- suggested_fix
- expected_impact
5. final_assessment
Provide a concise final assessment of the prompt, including:
- overall_score_out_of_100
- strongest_parts
- weakest_parts
- readiness_level: draft, usable, strong, or production-ready
- next_best_action
Constraints:
- Output must be valid structured JSON.
- Do not include markdown outside the JSON.
- Test cases must be realistic and specific.
- Recommendations must be practical and prioritized.
- Do not invent sensitive facts or unsupported claims.
- Make the harness reusable for future prompt versions.
Return only the JSON object.
A detailed prompt that guides AI to rigorously verify its generated answers, code, plans, or documents by checking facts, assumptions, source reliability, consistency, risks, and actionability.
Updated Jun 12, 2026
You are an expert AI output verifier tasked with thoroughly auditing the following AI-generated content for accuracy, reliability, and usability.
Context:
[Project context]
Content to Verify:
[AI-generated content]
Verification Checklist:
1. Factual Accuracy: Identify and fact-check all claims. Highlight any unverifiable or incorrect statements.
2. Assumptions: List implicit or explicit assumptions and assess their validity.
3. Missing Context: Detect any missing background or information that could affect interpretation.
4. Source Reliability: Evaluate the credibility and relevance of any cited or implied sources.
5. Internal Consistency: Check for contradictions or logical inconsistencies within the content.
6. Edge Cases & Risks: Identify scenarios where the output might fail or cause unintended consequences.
7. Actionability: Assess whether the recommendations or conclusions are practical and clear.
Output Format:
- Safe to Use: Sections verified as accurate and reliable.
- Needs Review: Sections requiring further validation or clarification.
- Do Not Use Yet: Sections with significant errors or risks that must be addressed before use.
Instructions:
- Provide concise explanations for each category.
- Suggest specific next steps for sections needing review or rejection.
- Clearly label anything that cannot be verified from the provided context or available sources.
- End with an overall trustworthiness rating (High, Medium, Low).
Please perform this verification carefully and comprehensively.
Expert prompt to audit AI agent workflows for unsafe permissions, prompt injection, data leakage, secret exposure, approval gaps, logging, and failure recovery risks.
Updated Jun 12, 2026
You are an expert AI security auditor specializing in autonomous AI workflows and agent operations.
Context:
Analyze the following AI agent or automation workflow in detail, focusing on security and operational risks:
* Project context: [Project context]
* AI agent permissions and external tool access: [AI agent permissions and external tool access]
* Browser actions and file access scopes: [Browser actions and file access scopes]
* Approval gates and human review points: [Approval gates and human review points]
* Logging and monitoring configurations: [Logging and monitoring configurations]
* Failure recovery and rollback plans: [Failure recovery and rollback plans]
* Known concerns or incidents: [Known concerns or incidents]
* Definition of done: [Definition of done]
Task:
1. Inspect all provided details carefully to identify potential security risks including but not limited to:
- Unsafe or excessive permissions
- Vulnerabilities to prompt injection
- Data leakage or secret exposure
- Gaps in approval or human oversight
- Insufficient logging or audit trails
- Lack of failure recovery or rollback mechanisms
2. Rank identified risks by severity (Critical, High, Medium, Low) with clear explanations.
3. Provide a practical mitigation checklist addressing each risk, including recommended fixes, additional controls, or procedural changes.
4. Suggest verification steps to confirm mitigations are effective.
5. Outline next actions for continuous security improvement and monitoring.
Constraints:
- Focus strictly on security and operational risks relevant to autonomous AI agents.
- Avoid generic or vague recommendations; be specific and actionable.
- Format output as a structured report with sections: Risk Summary, Severity Ranking, Mitigation Checklist, Verification Steps, and Next Actions.
Output Format:
Risk Summary:
- List of identified risks with descriptions.
Severity Ranking:
- Risks categorized by severity level.
Mitigation Checklist:
- Actionable items to resolve or reduce each risk.
Verification Steps:
- Concrete methods or commands to verify fixes.
Next Actions:
- Recommendations for ongoing security governance.
Begin your detailed security audit now using the context and inputs provided above.
Guide Codex to safely review Laravel pull requests by inspecting changed files, detecting bugs, security risks, regressions, missing tests, and verification gaps, then producing a clear review summary without rewriting unrelated code.
Updated Jun 12, 2026
You are an expert Laravel software engineer and code reviewer specializing in safe, precise pull request reviews for SaaS applications.
Context:
- Goal or task: [Goal or task]
- Project context: [Project context]
- Relevant files: [Relevant files]
- Error message or logs: [Error message or logs]
- Current behavior: [Current behavior]
- Expected behavior: [Expected behavior]
- Constraints: [Constraints]
- Environment details without secrets: [Environment details without secrets]
- Verification commands: [Verification commands]
- Definition of done: [Definition of done]
Instructions:
1. Carefully inspect all changed files and related code areas to understand the intended behavior and scope of the pull request.
2. Identify any bugs, security vulnerabilities, regressions, missing or incomplete tests, and gaps in verification coverage.
3. Avoid suggesting broad rewrites or changes unrelated to the pull request scope.
4. Do not expose or request any secrets or sensitive information.
5. Distinguish clearly between blocking issues that must be fixed before merging and non-blocking suggestions.
6. Summarize your findings in a clear, concise review comment, including:
- A list of blocking issues with detailed explanations.
- Suggestions for improvements or best practices.
- Verification checklist items to confirm before merging.
7. End with a clear next steps section advising what actions the developer should take.
Output format:
Provide your review in markdown format with the following sections:
# Pull Request Review Summary
## Blocking Issues
- List blocking issues that must be fixed before merging, with clear explanations.
## Suggestions
- List non-blocking improvements, best practices, or cleanup recommendations.
## Verification Checklist
- List concrete checks, tests, commands, and manual review steps to complete before merging.
## Next Steps
- List the recommended actions the developer should take next.
Ensure your review is actionable, precise, and respects the constraints above.
Direct Codex to analyze Laravel payment-related code and logs, identify checkout or webhook bugs, apply minimal safe fixes, verify payment flow integrity, and preserve existing gateway compatibility.
Updated Jun 12, 2026
You are an expert Laravel developer and payment integration specialist.
Context:
- Project context: [Project context]
- Relevant payment-related files or code snippets: [Relevant payment-related files or code snippets]
- Recent error messages or logs: [Recent error messages or logs]
- Current checkout or webhook behavior: [Current checkout or webhook behavior]
- Expected correct behavior: [Expected correct behavior]
- Constraints or special considerations: [Constraints or special considerations]
- Environment details without secrets: [Environment details without secrets]
- Verification commands or tests: [Verification commands or tests]
- Definition of done: [Definition of done]
Instructions:
1. Carefully inspect all provided relevant files and context before making any code changes, focusing on:
- Routes handling payment and checkout flows
- Controllers managing payment logic and webhook processing
- Payment gateway integration classes
- Environment configurations related to payment credentials (ensure no secrets are exposed)
- Application logs capturing payment errors or webhook failures
- Database migrations affecting payment-related tables
- Frontend checkout views and scripts
2. Identify the precise root cause of any bugs affecting checkout or webhook functionality.
3. Implement the smallest safe code change that resolves the identified issue, avoiding broad rewrites or risky modifications.
4. Ensure all existing payment gateway configurations remain intact and compatible.
5. Run syntax checks and all available automated tests to confirm no new errors or regressions.
6. Provide a detailed summary including:
- Clear explanation of the root cause
- List of all files modified with brief descriptions of changes
- Exact code snippets added or modified
- Verification steps performed and their outcomes
- Recommended next actions or improvements, if any
Constraints:
- Do not expose or log any sensitive environment variables or secrets.
- Avoid broad or risky code rewrites.
- Maintain full compatibility with all existing payment gateways.
Before proceeding, confirm you have thoroughly inspected all relevant files and gathered sufficient context.
After completing the fix, deliver the summary and verification results clearly.
Replace all bracketed placeholders with your specific Laravel project details and payment bug context before running this prompt.
Test whether an analysis supports causal claims by checking confounders, selection bias, timing, and alternatives.
Updated Jun 11, 2026
Act as a senior Data Analysis specialist using ChatGPT. Your task is: [Goal or task].
Context:
- Current situation: [Current context]
- Constraints: [Constraints]
- Available materials: [Files, data, examples, URLs, logs, notes]
- Success criteria: [Definition of done]
Workflow:
1. Restate the objective in operational terms and identify any missing information that would block a reliable answer.
2. Make reasonable assumptions only when they are low risk, and label them clearly.
3. Produce the main deliverable for "Causal Assumption Check Prompt" with enough detail that a skilled operator can execute it immediately.
4. Include edge cases, failure modes, dependencies, and tradeoffs that a junior prompt would usually miss.
5. Add a verification checklist with concrete tests, review questions, metrics, or acceptance criteria.
6. End with the smallest safe next action.
Output format:
- Executive summary
- Detailed plan or implementation
- Risks and mitigations
- Verification checklist
- Next action
Do not give generic advice. Optimize for a production-quality analytics review outcome.
Design a multi-agent workflow with roles, handoffs, shared context, review gates, and failure recovery.
Updated Jun 12, 2026
Act as a senior Prompt Engineering specialist using ChatGPT. Your task is: [Goal or task].
Context:
- Current situation: [Current context]
- Constraints: [Constraints]
- Available materials: [Files, data, examples, URLs, logs, notes]
- Success criteria: [Definition of done]
Workflow:
1. Restate the objective in operational terms and identify any missing information that would block a reliable answer.
2. Make reasonable assumptions only when they are low risk, and label them clearly.
3. Produce the main deliverable for "Multi-Agent Workflow Design Prompt" with enough detail that a skilled operator can execute it immediately.
4. Include edge cases, failure modes, dependencies, and tradeoffs that a junior prompt would usually miss.
5. Add a verification checklist with concrete tests, review questions, metrics, or acceptance criteria.
6. End with the smallest safe next action.
Output format:
- Executive summary
- Detailed plan or implementation
- Risks and mitigations
- Verification checklist
- Next action
Do not give generic advice. Optimize for a production-quality agent design outcome.
Create a verification plan that covers unit tests, manual checks, edge cases, logs, and deployment confidence.
Updated Jun 12, 2026
Act as a senior Codex & Coding specialist using Codex. Your task is: [Goal or task].
Context:
- Current situation: [Current context]
- Constraints: [Constraints]
- Available materials: [Files, data, examples, URLs, logs, notes]
- Success criteria: [Definition of done]
Workflow:
1. Restate the objective in operational terms and identify any missing information that would block a reliable answer.
2. Make reasonable assumptions only when they are low risk, and label them clearly.
3. Produce the main deliverable for "Test and Verification Prompt" with enough detail that a skilled operator can execute it immediately.
4. Include edge cases, failure modes, dependencies, and tradeoffs that a junior prompt would usually miss.
5. Add a verification checklist with concrete tests, review questions, metrics, or acceptance criteria.
6. End with the smallest safe next action.
Output format:
- Executive summary
- Detailed plan or implementation
- Risks and mitigations
- Verification checklist
- Next action
Do not give generic advice. Optimize for a production-quality testing outcome.
Build focused quarterly OKRs with measurable outcomes, owner clarity, dependencies, and review checkpoints.
Updated Jun 11, 2026
Act as a senior Business specialist using ChatGPT. Your task is: [Goal or task].
Context:
- Current situation: [Current context]
- Constraints: [Constraints]
- Available materials: [Files, data, examples, URLs, logs, notes]
- Success criteria: [Definition of done]
Workflow:
1. Restate the objective in operational terms and identify any missing information that would block a reliable answer.
2. Make reasonable assumptions only when they are low risk, and label them clearly.
3. Produce the main deliverable for "Quarterly OKR Planning Prompt" with enough detail that a skilled operator can execute it immediately.
4. Include edge cases, failure modes, dependencies, and tradeoffs that a junior prompt would usually miss.
5. Add a verification checklist with concrete tests, review questions, metrics, or acceptance criteria.
6. End with the smallest safe next action.
Output format:
- Executive summary
- Detailed plan or implementation
- Risks and mitigations
- Verification checklist
- Next action
Do not give generic advice. Optimize for a production-quality planning outcome.
Plan internal links that connect money pages, supporting articles, category hubs, and topical clusters.
Updated Jun 11, 2026
Act as a senior SEO & Blogging specialist using ChatGPT. Your task is: [Goal or task].
Context:
- Current situation: [Current context]
- Constraints: [Constraints]
- Available materials: [Files, data, examples, URLs, logs, notes]
- Success criteria: [Definition of done]
Workflow:
1. Restate the objective in operational terms and identify any missing information that would block a reliable answer.
2. Make reasonable assumptions only when they are low risk, and label them clearly.
3. Produce the main deliverable for "Internal Linking Architecture Prompt" with enough detail that a skilled operator can execute it immediately.
4. Include edge cases, failure modes, dependencies, and tradeoffs that a junior prompt would usually miss.
5. Add a verification checklist with concrete tests, review questions, metrics, or acceptance criteria.
6. End with the smallest safe next action.
Output format:
- Executive summary
- Detailed plan or implementation
- Risks and mitigations
- Verification checklist
- Next action
Do not give generic advice. Optimize for a production-quality seo architecture outcome.