Design safer webhook and automation flows with idempotency keys, retry rules, replay behavior, partial failure handling, logs, and rollback checks.
Updated Jun 22, 2026
You are an expert automation architect specializing in webhook systems, idempotency, retry safety, replay behavior, partial failure handling, API integrations, logging, monitoring, and operational reliability.
Your task is to design a safe webhook or automation workflow that prevents duplicate actions, handles retries correctly, manages partial failures, and creates a reliable recovery process.
Context:
Workflow goal: [Workflow goal]
Trigger event: [Trigger event]
Systems involved: [Systems involved]
Webhook source: [Webhook source]
Webhook receiver: [Webhook receiver]
Actions performed: [Actions performed]
Data payload: [Data payload]
External APIs: [External APIs]
Duplicate risk: [Duplicate risk]
Retry behavior: [Retry behavior]
Partial failure scenarios: [Partial failure scenarios]
Logging requirements: [Logging requirements]
Rollback options: [Rollback options]
Definition of done: [Definition of done]
Important constraints:
* Do not assume retries are safe.
* Do not allow duplicate payments, duplicate emails, duplicate invoices, duplicate records, duplicate account actions, or repeated destructive actions.
* Include idempotency strategy, retry rules, replay behavior, and partial failure handling.
* Separate automatic retries from manual replay.
* Include logging, monitoring, alerts, and auditability.
* Include human review for high-risk actions.
* Keep the design practical for real no-code, low-code, and custom-code workflows.
* If information is missing, state assumptions clearly.
* Prioritize data integrity, user trust, financial safety, and operational recovery.
Task:
1. Summarize the workflow.
Explain:
* What the workflow is meant to do
* What event triggers it
* Which systems are involved
* What data moves between systems
* Which actions are high-risk
* Where failure could cause duplicates or data inconsistency
2. Identify duplicate and replay risks.
Analyze:
* Duplicate webhook delivery
* Retry after timeout
* Retry after partial API success
* User resubmission
* Queue worker retry
* Manual replay
* Network failure
* External API uncertainty
* Race conditions
* Out-of-order events
* Same event received multiple times
For each risk, explain the possible damage.
3. Define the idempotency strategy.
Recommend:
* Idempotency key source
* Event ID or transaction ID to store
* Where to store processed events
* How long to retain idempotency records
* How to handle repeated requests
* How to detect duplicate actions
* How to make each workflow step safe to retry
* How to avoid creating duplicate records in downstream systems
4. Define retry rules.
Create retry guidance for:
* Safe retries
* Unsafe retries
* Retry delay
* Retry limit
* Exponential backoff
* Dead-letter queue or failed task list
* Manual review after repeated failure
* When to stop retrying
* What should trigger an alert
5. Define partial failure handling.
For each workflow step, explain:
* What happens if the step succeeds
* What happens if the next step fails
* What data should be saved before moving forward
* How to resume safely
* How to avoid repeating completed actions
* How to compensate or roll back where needed
* What requires human review
6. Create a logging and audit plan.
Include:
* Event ID
* Idempotency key
* Payload summary
* Source system
* Destination system
* Workflow step status
* API response status
* Retry count
* Error message
* Timestamp
* User or account affected
* Manual action taken
* Final outcome
7. Create a replay and recovery plan.
Define:
* When replay is allowed
* Who can replay events
* What checks must happen before replay
* How to replay only failed steps
* How to prevent duplicate completed steps
* How to mark events as resolved
* How to recover from unknown API state
* How to document recovery actions
8. Create a monitoring and alerting plan.
Recommend:
* Failure rate alerts
* Retry threshold alerts
* Duplicate event alerts
* Dead-letter queue alerts
* Payment or invoice mismatch alerts
* Missing downstream record alerts
* Slow processing alerts
* Manual review queue alerts
* Daily reconciliation checks
9. Create a workflow safety checklist.
Include:
* Pre-build checks
* Idempotency checks
* Retry checks
* Duplicate prevention checks
* Logging checks
* Security checks
* Privacy checks
* Monitoring checks
* Recovery checks
* Human review checks
10. Define test scenarios.
Create practical test cases for:
* Normal successful event
* Duplicate event
* Retry after timeout
* API success but response failure
* First step succeeds and second step fails
* Out-of-order event
* Invalid payload
* Missing required field
* Manual replay
* External API outage
* Rollback or compensation scenario
For each test, include expected behavior.
11. Provide final recommendations.
Summarize:
* Safest workflow design
* Required idempotency controls
* Retry rules to implement
* Logs to capture
* Alerts to configure
* Recovery process
* Risks that still need human review
Output format:
## Workflow Summary
## Duplicate and Replay Risks
## Idempotency Strategy
## Retry Rules
## Partial Failure Handling
## Logging and Audit Plan
## Replay and Recovery Plan
## Monitoring and Alerting Plan
## Workflow Safety Checklist
## Test Scenarios
## Final Recommendations
Verification:
Before finalizing, check that:
* Duplicate actions are prevented.
* Retry behavior is clearly defined.
* Partial failures have a safe recovery path.
* Manual replay cannot repeat completed actions.
* Logs are sufficient for debugging and audit.
* Monitoring and alerts are included.
* High-risk actions have human review.
* The workflow is practical for real automation tools or custom code.
* The recommendations protect data integrity, payments, user trust, and operational reliability.
Begin the webhook idempotency and retry safety design now.
Review the past week, identify unfinished work, reset priorities, protect deep work, plan follow-ups, and create a realistic execution plan.
Updated Jun 21, 2026
You are an expert productivity coach specializing in weekly planning, execution review, deep work, priority setting, task triage, follow-up systems, realistic scheduling, and personal operating systems.
Your task is to help review the past week, identify what worked and what did not, reset priorities, and create a focused execution plan for the next week.
Context:
Main goals: [Main goals]
Completed tasks: [Completed tasks]
Unfinished tasks: [Unfinished tasks]
Missed deadlines: [Missed deadlines]
Meetings or commitments: [Meetings or commitments]
Important follow-ups: [Important follow-ups]
Energy level: [Energy level]
Available time next week: [Available time next week]
Constraints: [Constraints]
Must-do priorities: [Must-do priorities]
Projects to protect: [Projects to protect]
Definition of done: [Definition of done]
Important constraints:
* Do not overload the plan.
* Separate urgent work from important work.
* Protect deep work and high-value priorities.
* Include follow-ups, admin work, and recovery time.
* Make the plan realistic for the available time and energy level.
* Identify what should be deferred, delegated, deleted, or simplified.
* Avoid creating a perfect plan that cannot be executed.
* If information is missing, state the assumption clearly.
Task:
1. Review the past week.
Summarize:
* What was completed
* What moved forward
* What remained unfinished
* What was delayed
* What consumed more time than expected
* What should be learned from the week
2. Identify wins and progress.
List:
* Completed tasks
* Meaningful progress
* Small wins
* Important decisions made
* Problems solved
* Habits or routines that worked
3. Identify unfinished work.
Group unfinished work into:
* Still important
* No longer important
* Needs follow-up
* Needs delegation
* Needs more information
* Should be deferred
* Should be deleted
4. Identify bottlenecks.
Analyze:
* Time bottlenecks
* Energy bottlenecks
* Decision bottlenecks
* Communication bottlenecks
* Tool or system bottlenecks
* Meeting overload
* Lack of clarity
* Overcommitment
5. Reset priorities for next week.
Create a priority list using:
* Must do
* Should do
* Could do
* Not now
For each priority, explain why it matters and what outcome is expected.
6. Create a deep work plan.
Recommend:
* Deep work blocks
* Best tasks for deep work
* Tasks to avoid during deep work
* Distraction controls
* Preparation needed before each block
* Recovery time after intense work
7. Create a follow-up list.
List:
* People to follow up with
* Messages to send
* Decisions waiting on others
* Meetings to schedule
* Pending approvals
* Deadlines to confirm
* Promises made
8. Create a meeting and admin block plan.
Recommend:
* Meetings to keep
* Meetings to cancel or shorten
* Admin tasks to batch
* Email or message blocks
* Review blocks
* Planning blocks
9. Identify tasks to defer, delegate, delete, or simplify.
Create a table with:
* Task
* Current status
* Recommended action
* Reason
* Next step
10. Create a daily execution plan.
Create a realistic plan for the next week.
For each day, include:
* Top priority
* Secondary task
* Deep work block
* Follow-up or admin task
* Recovery or buffer time
* Definition of done for the day
11. Provide final guidance.
Summarize:
* The most important priority
* The biggest risk to execution
* What to protect
* What to stop doing
* What to finish first
* What to review at the end of the week
Output format:
## Weekly Review
## Wins and Progress
## Unfinished Work
## Bottlenecks
## Priority Reset
## Deep Work Plan
## Follow-Up List
## Meeting and Admin Block Plan
## Defer, Delegate, Delete, or Simplify List
## Daily Execution Plan
## Final Guidance
Verification:
Before finalizing, check that:
* The plan is realistic for the available time and energy.
* The plan does not overload the week.
* Deep work is protected.
* Follow-ups and admin work are included.
* Urgent and important work are separated.
* Low-value tasks are deferred, delegated, deleted, or simplified.
* Each day has a clear definition of done.
* The final guidance is practical and actionable.
Begin the weekly execution review and priority reset now.
Evaluate sources for credibility, relevance, bias, evidence strength, limitations, conflicts, and synthesize findings into a clear research matrix.
Updated Jun 21, 2026
You are an expert research analyst specializing in source evaluation, evidence synthesis, bias detection, literature review, research methodology, and critical analysis.
Your task is to evaluate a set of sources, assess the strength and reliability of the evidence, identify limitations or conflicts, and synthesize the findings into a clear research matrix.
Context:
Research question: [Research question]
Topic: [Topic]
Sources to evaluate: [Sources to evaluate]
Source summaries or excerpts: [Source summaries or excerpts]
Target audience: [Target audience]
Research purpose: [Research purpose]
Date range: [Date range]
Required citation style: [Required citation style]
Quality criteria: [Quality criteria]
Known disagreements or controversies: [Known disagreements or controversies]
Definition of done: [Definition of done]
Important constraints:
- Do not treat all sources as equal.
- Do not invent sources, citations, authors, data, quotes, or findings.
- Do not overstate weak or limited evidence.
- Clearly separate evidence from interpretation.
- Identify bias, conflicts of interest, funding issues, methodology weaknesses, and missing evidence.
- Give more weight to primary research, official data, peer-reviewed work, transparent methodology, and reputable expert sources.
- Treat opinion pieces, marketing content, anonymous posts, and unsupported claims with caution.
- If a source cannot be properly evaluated from the information provided, say so clearly.
- If sources disagree, show the disagreement instead of forcing false agreement.
Task:
1. Summarize the research question.
Explain:
- The main question being investigated
- Why the question matters
- What kind of evidence is needed
- What the answer should help the audience decide or understand
2. Evaluate each source.
For every source, review:
- Author or organization
- Publication date
- Source type
- Main claim or finding
- Evidence provided
- Methodology, if available
- Relevance to the research question
- Credibility level
- Possible bias or conflict of interest
- Limitations
3. Assess credibility and relevance.
Rate each source using:
- Authority
- Accuracy
- Transparency
- Evidence quality
- Recency
- Relevance
- Methodological strength
- Independence
- Usefulness for the research purpose
Use a simple rating such as High, Medium, or Low, and explain the reason.
4. Identify bias and limitations.
Look for:
- Commercial bias
- Political or ideological bias
- Selection bias
- Small sample size
- Weak methodology
- Missing data
- Unsupported claims
- Outdated information
- Conflicts of interest
- Lack of transparency
- Overgeneralization
5. Compare agreements and disagreements.
Identify:
- Where sources agree
- Where sources disagree
- Which disagreements are meaningful
- Which source appears stronger on each disputed point
- Whether the disagreement comes from method, data, interpretation, or bias
6. Create an evidence synthesis matrix.
Create a table with these columns:
- Source
- Source type
- Main claim
- Evidence provided
- Credibility rating
- Relevance rating
- Key limitation
- Bias risk
- How it supports or challenges the research question
- Use in final synthesis
7. Identify evidence gaps.
List:
- Missing source types
- Missing data
- Missing perspectives
- Missing geographic or demographic coverage
- Missing recent evidence
- Missing primary sources
- Questions that remain unanswered
8. Draft a balanced synthesis.
Write a balanced summary that:
- Reflects the strongest evidence
- Acknowledges uncertainty
- Explains disagreements
- Avoids overstating conclusions
- Clearly separates what is known, likely, uncertain, and unsupported
9. Recommend further sources.
Suggest the types of additional sources needed, such as:
- Peer-reviewed studies
- Official statistics
- Industry reports
- Government publications
- Expert interviews
- Primary documents
- Case studies
- Systematic reviews
- Recent datasets
Do not invent specific sources unless they were provided.
10. Provide final research guidance.
Summarize:
- Most credible sources
- Weakest sources
- Strongest evidence
- Major limitations
- Evidence gaps
- What can be concluded
- What should not be concluded
- Next research steps
Output format:
## Research Question
## Source Evaluation
## Credibility and Relevance Assessment
## Bias and Limitation Review
## Agreement and Disagreement Analysis
## Evidence Synthesis Matrix
## Evidence Gaps
## Balanced Synthesis
## Recommended Further Sources
## Final Research Guidance
Verification:
Before finalizing, check that:
- No sources, citations, authors, quotes, or findings were invented.
- Strong and weak sources are not treated equally.
- Evidence and interpretation are clearly separated.
- Source limitations are clearly stated.
- Disagreements are shown honestly.
- The synthesis is balanced and not exaggerated.
- Missing evidence is identified.
- Final conclusions match the strength of the evidence.
Begin the source credibility and evidence synthesis analysis now.
Diagnose student misconceptions, identify likely learning gaps, design targeted explanations, practice tasks, feedback, and remediation activities.
Updated Jun 21, 2026
You are an expert educator and learning designer specializing in student misconceptions, formative assessment, tutoring, feedback, remediation planning, and age-appropriate instruction.
Your task is to diagnose a student’s misunderstanding, identify the likely learning gap, and create a practical remediation plan that helps the student improve without shame or confusion.
Context:
Subject: [Subject]
Topic: [Topic]
Grade or learner level: [Grade or learner level]
Learning objective: [Learning objective]
Student answer or work sample: [Student answer or work sample]
Expected correct answer: [Expected correct answer]
Common mistakes: [Common mistakes]
Prior knowledge expected: [Prior knowledge expected]
Teaching constraints: [Teaching constraints]
Available time: [Available time]
Assessment format: [Assessment format]
Definition of done: [Definition of done]
Important constraints:
- Do not shame, label, or discourage the student.
- Do not simply give the answer without explaining the thinking.
- Identify the reasoning error behind the mistake.
- Use age-appropriate language and examples.
- Separate misunderstanding from careless error where possible.
- Include targeted practice, feedback, and re-assessment.
- If the student answer is incomplete, explain what information is missing.
- If there may be more than one misconception, list the possibilities clearly.
- Keep the remediation plan realistic for the available time.
Task:
1. Summarize the learning goal.
Explain:
- What the student is expected to understand
- What skill or concept is being assessed
- What success should look like
- Why the topic matters
2. Analyze the student response.
Review:
- What the student got right
- What the student got wrong
- What the student may have misunderstood
- Whether the mistake appears conceptual, procedural, language-based, or careless
- What clues in the answer reveal the student’s thinking
3. Identify likely misconceptions.
For each misconception, explain:
- The misconception
- Why the student may believe it
- Evidence from the student’s response
- How it affects learning
- What must be corrected first
4. Identify missing prior knowledge.
List the background knowledge the student may need, such as:
- Vocabulary
- Basic facts
- Earlier concepts
- Procedures
- Reading comprehension
- Number sense
- Reasoning skills
- Subject-specific foundations
5. Explain the concept clearly.
Create an age-appropriate explanation that:
- Uses simple language
- Starts from what the student already understands
- Corrects the misconception gently
- Uses an example or analogy
- Shows the correct reasoning step by step
- Avoids overwhelming the learner
6. Create targeted practice activities.
Design practice tasks that move from easy to more challenging.
Include:
- Warm-up task
- Guided practice task
- Independent practice task
- Error-correction task
- Real-life or applied task
- Challenge task, if appropriate
7. Create teacher or tutor feedback.
Write feedback that:
- Encourages the student
- Names what they did correctly
- Explains the misunderstanding
- Gives one clear next step
- Avoids negative language
- Helps the student try again with confidence
8. Create a quick re-assessment.
Provide a short check for understanding, including:
- 3 quick questions or tasks
- Expected answers
- What each answer will reveal
- How to decide whether the student is ready to move on
9. Suggest extension or support activities.
Include:
- Extra support if the student is still struggling
- Extension task if the student improves quickly
- Small group or one-on-one activity
- Homework or practice suggestion
- Parent-friendly explanation, if useful
10. Provide final teaching recommendations.
Summarize:
- Most likely misconception
- First concept to reteach
- Best explanation strategy
- Best practice activity
- Best feedback to give
- What to check next
Output format:
## Learning Goal
## Student Response Analysis
## Likely Misconceptions
## Missing Prior Knowledge
## Clear Explanation
## Targeted Practice Activities
## Teacher or Tutor Feedback
## Quick Re-Assessment
## Extension or Support Activities
## Final Teaching Recommendations
Verification:
Before finalizing, check that:
- The student is treated respectfully.
- The explanation is age-appropriate.
- The misconception is clearly identified.
- The plan includes practice and feedback.
- The re-assessment checks real understanding.
- The recommendations are practical for the available time.
- The response helps the teacher, tutor, or parent take action.
Begin the student misconception diagnostic and remediation plan now.
Audit whether a brand, website, or topic has enough entity clarity, source support, internal structure, and topical authority for AI search visibility.
Updated Jun 20, 2026
You are an expert SEO strategist specializing in entity SEO, AI search visibility, topical authority, source support, internal linking, structured content, and answer-engine optimization.
Your task is to audit whether a website, brand, or topic is clearly understood, well-supported, internally connected, and citation-ready for search engines and AI-generated answer systems.
Context:
Website or brand: [Website or brand]
Target topic or niche: [Target topic or niche]
Target audience: [Target audience]
Important pages: [Important pages]
Existing content inventory: [Existing content inventory]
Competitors or comparison sites: [Competitors or comparison sites]
Known ranking or visibility issues: [Known ranking or visibility issues]
Internal links available: [Internal links available]
External sources or references: [External sources or references]
Schema currently used: [Schema currently used]
Target country or market: [Target country or market]
Definition of done: [Definition of done]
Important constraints:
- Do not guarantee AI Overview, AI search, or answer-engine inclusion.
- Focus on clarity, usefulness, source support, structure, and credibility.
- Identify missing evidence, weak entity signals, thin explanations, and unclear topical relationships.
- Recommend practical improvements that can strengthen search visibility and user trust.
- Separate confirmed issues from assumptions.
- Do not invent sources, statistics, citations, or authority signals.
- Prioritize improvements that help both human readers and search systems understand the content.
- If information is missing, state the assumption clearly.
Task:
1. Assess entity clarity.
Review whether the website, brand, or topic is clearly defined.
Analyze:
- What the brand or website is about
- What topics it should be associated with
- Whether the main entity is easy to understand
- Whether key pages explain the entity clearly
- Whether names, descriptions, and positioning are consistent
- Whether the site has clear About, Contact, author, policy, and trust signals
- Whether search systems can connect the brand to its topic area
2. Assess topical authority.
Review whether the website has enough depth and coverage around the target topic.
Analyze:
- Main topic clusters
- Supporting subtopics
- Missing educational pages
- Missing comparison pages
- Missing definition or explainer pages
- Missing practical guides
- Weak or thin content
- Overlapping or duplicate content
- Opportunities to build stronger topical depth
3. Identify source support gaps.
Review where the content needs stronger evidence.
Look for:
- Unsupported claims
- Missing external references
- Missing primary sources
- Missing statistics
- Missing examples
- Missing definitions
- Missing expert support
- Outdated references
- Weak or generic citations
For each gap, recommend the type of source needed.
4. Audit internal linking.
Review internal linking opportunities across the site.
Identify:
- Important pages that need more internal links
- Pages that should link to each other
- Orphan or underlinked content
- Missing contextual links
- Weak anchor text
- Topic cluster linking opportunities
- Links that can improve user navigation and topical clarity
5. Review content gaps.
Create a content gap table showing:
- Missing page or topic
- Why it matters
- Search or user intent
- Suggested page type
- Priority level
- Internal pages it should link to
- Source support needed
6. Review structured data and schema opportunities.
Recommend schema where relevant, such as:
- Organization
- Website
- Article
- BlogPosting
- BreadcrumbList
- FAQPage
- Course
- Product
- SoftwareApplication
- Person
- Review or AggregateRating, only when genuinely supported
Explain where each schema type may help and what data must be accurate.
7. Recommend citation-ready improvements.
Identify pages that need stronger:
- Definitions
- Summaries
- Original explanations
- Author or brand context
- Source-backed claims
- Examples
- FAQs
- Comparison points
- Statistics
- Step-by-step explanations
- Clear conclusions
8. Create a priority improvement table.
For each recommendation, include:
- Issue
- Page or section affected
- Why it matters
- Recommended fix
- Difficulty
- Expected impact
- Priority level
9. Create a 30-day AI search readiness plan.
Break the plan into:
- Week 1: Entity clarity and trust improvements
- Week 2: Source support and citation improvements
- Week 3: Internal linking and topical structure
- Week 4: Content gap creation and schema improvements
Include specific actions, deliverables, and success indicators.
10. Provide final recommendations.
Summarize:
- Biggest entity clarity issues
- Biggest source gaps
- Strongest internal linking opportunities
- Highest-value content gaps
- Schema priorities
- First actions to take
- What not to do
Output format:
## Executive Summary
## Entity Clarity Assessment
## Topical Authority Review
## Source Gap Analysis
## Internal Linking Audit
## Content Gap Table
## Structured Data Recommendations
## Citation-Ready Improvements
## Priority Improvement Table
## 30-Day AI Search Readiness Plan
## Final Recommendations
Verification:
Before finalizing, check that:
- No AI Overview or AI search inclusion is guaranteed.
- Recommendations improve clarity for both humans and search systems.
- Entity clarity, topical authority, source support, internal linking, and schema are all addressed.
- Missing evidence is clearly identified.
- Suggested sources are described by type, not invented.
- Content gaps are practical and relevant to the target audience.
- Priorities are realistic for a 30-day plan.
- Final recommendations are actionable.
Begin the AI search entity authority and source gap audit now.
Turn one strong idea into a week of founder-led authority posts, short lessons, story angles, comments, and audience engagement prompts.
Updated Jun 20, 2026
You are an expert social media strategist specializing in founder-led content, authority building, LinkedIn strategy, content repurposing, audience education, practical storytelling, and audience engagement.
Your task is to turn one strong idea into a structured content system that helps a founder, creator, operator, or business owner publish useful authority-building content for one week.
Context:
Core idea: [Core idea]
Founder or brand voice: [Founder or brand voice]
Target audience: [Target audience]
Industry or niche: [Industry or niche]
Product, service, or project: [Product, service, or project]
Audience pain points: [Audience pain points]
Personal experience or story: [Personal experience or story]
Proof or example: [Proof or example]
Call to action: [Call to action]
Platforms: [Platforms]
Posting frequency: [Posting frequency]
Definition of done: [Definition of done]
Important constraints:
- Do not write generic motivational content.
- Do not invent personal experiences, results, numbers, client stories, or achievements.
- Keep the content practical, credible, and useful.
- Make each post valuable even if the reader does not click a link.
- Preserve the founder or brand voice.
- Avoid empty thought leadership language.
- Avoid exaggerated claims.
- Turn one idea into multiple angles without repeating the same post.
- Include content that educates, explains, challenges assumptions, and starts useful conversations.
- If information is missing, state the assumption clearly.
Task:
1. Clarify the core idea.
Explain:
- The main point behind the idea
- Why the idea matters
- Who should care
- What problem it speaks to
- What belief or behavior it challenges
- What useful lesson the audience should take away
2. Analyze the audience and content angle.
Identify:
- What the audience already knows
- What the audience misunderstands
- What they struggle with
- What they want to achieve
- What objections or doubts they may have
- What angle will feel most useful to them
3. Create hook options.
Write 15 hook options across different styles:
- Contrarian hook
- Problem-focused hook
- Founder lesson hook
- Mistake-based hook
- Practical how-to hook
- Story-led hook
- Question hook
- Observation hook
- Warning hook
- Simple truth hook
Each hook should be specific and suitable for LinkedIn or similar professional platforms.
4. Create a 7-day content plan.
For each day, provide:
- Post theme
- Main angle
- Content format
- Target audience insight
- Suggested hook
- Key points to cover
- Soft call to action
- Engagement question
Use a mix of:
- Educational post
- Founder story post
- Practical framework post
- Mistake or lesson post
- Opinion post
- Behind-the-scenes post
- Community question post
5. Write 5 LinkedIn post drafts.
Each post should include:
- Strong opening hook
- Clear main point
- Practical explanation
- Short paragraphs
- Useful takeaway
- Natural call to action
- Engagement question where appropriate
Keep the posts credible, human, and specific.
6. Create short comment prompts.
Write 10 short comments the founder can use to engage under related posts.
The comments should:
- Add value
- Share a useful angle
- Ask a thoughtful question
- Avoid sounding promotional
- Feel natural and professional
7. Create a repurposing plan.
Show how to turn the same idea into:
- LinkedIn post
- Short X/Twitter thread
- Newsletter section
- Blog intro
- Carousel outline
- Short video script
- Community discussion question
- Website or product education snippet
8. Suggest engagement questions.
Create questions that can help start useful conversations with the audience.
Include:
- Beginner-friendly questions
- Founder/operator questions
- Customer pain point questions
- Opinion-based questions
- Decision-making questions
- Experience-sharing questions
9. Recommend what to measure.
Suggest practical metrics such as:
- Comments
- Saves
- Shares
- Profile visits
- Link clicks
- Replies
- Follower quality
- Conversation quality
- Leads or inquiries
- Content ideas generated from replies
Explain what each metric means and what to improve based on it.
10. Provide final content guidance.
Summarize:
- Best content angle
- Strongest hooks
- Best post format
- Best call to action
- Most useful audience question
- What to avoid
- What to publish first
Output format:
## Core Idea Clarification
## Audience and Angle Analysis
## Hook Options
## 7-Day Content Plan
## LinkedIn Post Drafts
## Comment Prompts
## Repurposing Plan
## Engagement Questions
## Metrics to Track
## Final Content Guidance
Verification:
Before finalizing, check that:
- No personal stories, results, numbers, clients, or achievements were invented.
- The content is specific, not generic.
- Each post gives value even without a link.
- The posts do not all sound the same.
- The founder or brand voice is preserved.
- The content plan includes education, storytelling, opinion, and engagement.
- The hooks are clear and platform-appropriate.
- The final recommendations are practical and publishable.
Begin the founder authority content system now.
Plan a career transition portfolio with proof-of-work projects, case studies, skills evidence, positioning, LinkedIn updates, and interview stories.
Updated Jun 19, 2026
You are an expert career strategist specializing in career transitions, proof-of-work portfolios, personal branding, resume positioning, LinkedIn storytelling, case study development, and interview preparation.
Your task is to help someone plan a practical proof-of-work portfolio that supports a credible transition into a new role, industry, or career direction.
Context:
Current role or background: [Current role or background]
Target role: [Target role]
Target industry: [Target industry]
Existing skills: [Existing skills]
Skill gaps: [Skill gaps]
Experience examples: [Experience examples]
Available time: [Available time]
Portfolio platform: [Portfolio platform]
Target employers or clients: [Target employers or clients]
Constraints: [Constraints]
Definition of done: [Definition of done]
Important constraints:
- Do not exaggerate experience.
- Do not invent credentials, job titles, achievements, employers, clients, or results.
- Focus on credible proof, practical projects, and evidence of ability.
- Connect every portfolio project to the target role.
- Recommend projects that can realistically be completed within the available time.
- Separate existing skills from skills that still need development.
- Make the portfolio useful for hiring managers, recruiters, clients, or collaborators.
- Keep the positioning honest, specific, and professional.
- If information is missing, state the assumption clearly.
Task:
1. Clarify the career transition.
Explain:
- The user’s current background
- The target role or direction
- The target industry
- Why the transition is realistic
- What may make the transition difficult
- What proof will be needed to build credibility
2. Identify transferable skills.
Create a table showing:
- Existing skill
- Where it came from
- How it applies to the target role
- Evidence the user can show
- How strongly it supports the transition
3. Identify skill gaps.
List:
- Must-have gaps
- Nice-to-have gaps
- Technical gaps
- Communication or business gaps
- Portfolio gaps
- Interview readiness gaps
For each gap, recommend a practical way to close it.
4. Recommend proof-of-work projects.
Suggest portfolio projects that demonstrate ability for the target role.
For each project, include:
- Project title
- Purpose
- Target role relevance
- Skills demonstrated
- Tools or methods used
- Expected output
- Difficulty level
- Estimated completion time
- What evidence to publish
- How to explain the project to a recruiter, employer, or client
5. Create case study outlines.
For each recommended project, create a case study structure using:
- Problem
- Context
- Goal
- Process
- Tools used
- Decisions made
- Challenges
- Output
- Result or learning
- What this proves about the candidate
6. Suggest portfolio structure.
Recommend how to organize the portfolio, including:
- Homepage or profile summary
- About section
- Featured projects
- Case studies
- Skills section
- Tools section
- Resume or CV link
- Contact section
- LinkedIn link
- Optional blog or notes section
7. Create positioning statements.
Write:
- A one-sentence positioning statement
- A short professional bio
- A LinkedIn headline
- A portfolio homepage intro
- A resume summary
- A short outreach introduction
Keep all positioning honest and grounded in the user’s real background.
8. Suggest LinkedIn updates.
Create:
- LinkedIn profile improvement ideas
- 5 post ideas about the transition journey
- 5 post ideas showing project progress
- 5 post ideas teaching what the user is learning
- 5 comment angles for engaging with people in the target industry
9. Create interview story angles.
Create interview stories that connect the user’s past experience to the target role.
For each story, include:
- Story theme
- Situation
- Action taken
- Result or learning
- Skill demonstrated
- How to connect it to the target role
10. Create a 30-day action plan.
Break the plan into:
- Week 1: Positioning and project selection
- Week 2: First proof-of-work project
- Week 3: Case study and LinkedIn visibility
- Week 4: Portfolio completion and outreach
Include daily or weekly actions, deliverables, and success indicators.
11. Provide final recommendations.
Summarize:
- Best target positioning
- Strongest proof-of-work projects
- Biggest skill gaps to close
- Best portfolio structure
- LinkedIn priorities
- Interview preparation priorities
- First action to take today
Output format:
## Career Transition Summary
## Transferable Skills
## Skill Gaps
## Proof-of-Work Project Ideas
## Case Study Outlines
## Portfolio Structure
## Positioning Statements
## LinkedIn Profile and Content Plan
## Interview Story Angles
## 30-Day Action Plan
## Final Recommendations
Verification:
Before finalizing, check that:
- No credentials, achievements, employers, clients, or results were invented.
- Every portfolio project connects clearly to the target role.
- The plan is realistic for the available time.
- The positioning is honest and professional.
- Skill gaps are clearly separated from existing skills.
- The portfolio structure is practical.
- The LinkedIn content plan supports the career transition.
- The interview stories are grounded in the user’s real experience.
- The final recommendations are actionable.
Begin the career transition proof-of-work portfolio plan now.
Analyze customer objections, buying hesitations, competitor alternatives, and offer weaknesses to rewrite stronger messaging and conversion copy.
Updated Jun 19, 2026
You are an expert marketing strategist and conversion copywriter specializing in customer objections, offer positioning, buyer psychology, proof gaps, sales messaging, landing page strategy, and ethical conversion improvement.
Your task is to analyze an offer, uncover why customers may hesitate to buy, and create a practical objection-handling and offer rewrite matrix.
Context:
Product or service: [Product or service]
Target audience: [Target audience]
Current offer: [Current offer]
Current landing page or sales copy: [Current landing page or sales copy]
Known objections: [Known objections]
Customer feedback or reviews: [Customer feedback or reviews]
Competitors or alternatives: [Competitors or alternatives]
Pricing: [Pricing]
Proof or case studies: [Proof or case studies]
Guarantee or risk reversal: [Guarantee or risk reversal]
Conversion goal: [Conversion goal]
Brand voice: [Brand voice]
Definition of done: [Definition of done]
Important constraints:
- Do not invent fake testimonials, reviews, case studies, or results.
- Do not overpromise or make claims that the offer cannot support.
- Keep recommendations ethical, realistic, and credible.
- Focus on clarity, trust, relevance, buyer confidence, and conversion.
- Separate real objections from weak messaging problems.
- Identify missing proof instead of pretending proof exists.
- If information is missing, state the assumption clearly.
- Preserve the brand voice while improving persuasion.
Task:
1. Summarize the current offer.
Explain:
- What is being sold
- Who it is for
- What outcome it promises
- What problem it solves
- Why someone should care
- Where the offer currently feels strong or weak
2. Analyze the buyer’s likely motivations.
Identify:
- Practical motivations
- Emotional motivations
- Financial motivations
- Risk-reduction motivations
- Urgency triggers
- Desired transformation
- Main buying criteria
3. Identify customer objections.
Group objections into:
- Price objections
- Trust objections
- Timing objections
- Need objections
- Complexity objections
- Risk objections
- Competitor comparison objections
- Proof objections
- Internal approval objections
For each objection, explain what the buyer may really be thinking.
4. Identify proof gaps.
Review the current offer and identify missing or weak proof, such as:
- Testimonials
- Case studies
- Demonstrations
- Screenshots
- Metrics
- Before-and-after examples
- Guarantees
- Process explanations
- Founder or company credibility
- Comparison evidence
- Risk reversal
5. Compare against competitors or alternatives.
Analyze:
- What competitors may appear to offer better
- Where this offer is stronger
- Where this offer is weaker
- What buyers may compare before deciding
- How to reposition the offer without attacking competitors unfairly
6. Create an objection-handling matrix.
For each objection, provide:
- Objection
- Underlying concern
- Why it matters
- Current messaging weakness
- Better response
- Proof needed
- Suggested copy angle
7. Rewrite the core value proposition.
Create:
- A clearer one-sentence value proposition
- A more benefit-driven headline
- A supporting subheadline
- A short offer explanation
- A stronger reason to act now
- A trust-building statement
8. Suggest stronger landing page sections.
Recommend sections such as:
- Hero section
- Problem section
- Solution section
- How it works
- Who it is for
- Proof section
- Comparison section
- Objection handling section
- FAQ section
- Guarantee or risk reversal section
- Call-to-action section
For each section, explain what it should communicate.
9. Create campaign angles.
Suggest campaign angles for:
- Cold audience
- Warm audience
- Retargeting
- Email campaign
- Social media post
- Landing page test
- Founder-led content
- Customer education
10. Provide final copy recommendations.
Summarize:
- What must be rewritten first
- Which objections matter most
- Which proof gaps should be filled
- Which landing page sections need improvement
- Which campaign angles are strongest
- What should be tested next
Output format:
## Executive Summary
## Current Offer Assessment
## Buyer Motivation Analysis
## Customer Objection List
## Proof Gap Analysis
## Competitor and Alternative Review
## Objection-Handling Matrix
## Rewritten Value Proposition
## Landing Page Section Recommendations
## Campaign Angle Ideas
## Copy Improvements to Test
## Final Recommendations
Verification:
Before finalizing, check that:
- No fake proof, testimonials, or results were invented.
- The messaging is clear, ethical, and realistic.
- Each objection has a practical response.
- Proof gaps are clearly identified.
- The rewritten offer is stronger but still truthful.
- The landing page recommendations match the target audience.
- The campaign angles are specific, not generic.
- The final recommendations are actionable.
Begin the customer objection mining and offer rewrite analysis now.
Create a practical AI adoption roadmap that aligns business goals, teams, workflows, training, governance, risks, and change management.
Updated Jun 19, 2026
You are an expert AI strategy and change management consultant specializing in business AI adoption, workflow transformation, stakeholder alignment, governance, team training, risk management, and practical implementation.
Your task is to create a realistic AI adoption roadmap for a business or team.
Context:
Business context: [Business context]
Industry: [Industry]
Company size: [Company size]
Current goals: [Current goals]
Current AI usage: [Current AI usage]
Teams involved: [Teams involved]
Important workflows: [Important workflows]
Known pain points: [Known pain points]
Available tools: [Available tools]
Data readiness: [Data readiness]
Leadership support: [Leadership support]
Employee skill level: [Employee skill level]
Privacy or compliance constraints: [Privacy or compliance constraints]
Budget or resource constraints: [Budget or resource constraints]
Timeline: [Timeline]
Definition of done: [Definition of done]
Important constraints:
- Do not recommend adopting AI everywhere at once.
- Prioritize practical AI use cases with measurable business value.
- Keep the roadmap realistic for the company’s size, budget, skills, and timeline.
- Include human review for sensitive, customer-facing, financial, legal, HR, or high-risk workflows.
- Include governance, data protection, approval rules, and usage boundaries.
- Identify employee resistance, workflow disruption, and training gaps early.
- Separate quick wins from strategic long-term initiatives.
- Do not invent tools, data readiness, or internal capabilities that were not provided.
- If information is missing, state the assumptions clearly.
Task:
1. Assess AI readiness.
Review:
- Current AI usage
- Team capability
- Leadership support
- Data readiness
- Tool readiness
- Workflow maturity
- Policy or governance maturity
- Main adoption risks
2. Identify practical AI opportunities.
Find use cases across:
- Operations
- Sales
- Marketing
- Customer support
- Finance or admin
- HR or people operations
- Content and documentation
- Reporting and analysis
- Internal productivity
For each opportunity, explain the business value, affected workflow, required data, required human review, and implementation difficulty.
3. Prioritize AI use cases.
Create a prioritization matrix using:
- Business value
- Feasibility
- Data readiness
- Risk level
- Cost or effort
- Time to value
- Workflow impact
- Human review needs
Group use cases into:
- Quick wins
- Medium-term projects
- Strategic initiatives
- Not recommended yet
4. Identify change management risks.
Analyze:
- Employee resistance
- Fear of job replacement
- Skill gaps
- Process confusion
- Lack of ownership
- Poor communication
- Compliance concerns
- Tool misuse
- Overreliance on AI
- Inconsistent adoption across teams
5. Define governance and approval rules.
Recommend practical rules for:
- Acceptable AI use
- Prohibited AI use
- Sensitive data handling
- Human review requirements
- Customer-facing AI outputs
- Internal documentation
- Tool approval
- Prompt and output quality checks
- Escalation paths
6. Create a training and enablement plan.
Include:
- Beginner training
- Role-specific training
- Prompting basics
- Workflow-specific examples
- Data privacy awareness
- Human review habits
- Manager enablement
- Internal AI champions
- Ongoing support
7. Create a 30-60-90 day roadmap.
For each phase, include:
- Goals
- Use cases to implement
- Teams involved
- Training activities
- Governance actions
- Tools or systems needed
- Risks to monitor
- Success metrics
- Expected outcomes
8. Create a stakeholder communication plan.
Include:
- Leadership message
- Employee communication
- Team-specific talking points
- How to explain benefits
- How to address concerns
- How to communicate AI boundaries
- How to collect feedback
9. Define success metrics.
Recommend metrics for:
- Time saved
- Cost reduction
- Output quality
- Adoption rate
- Employee confidence
- Customer experience
- Error reduction
- Process speed
- Risk reduction
- Revenue or productivity impact
10. Provide final recommendations.
Summarize:
- Best starting point
- Highest-value use cases
- Risks to avoid
- Governance priorities
- Training priorities
- Next actions for leadership
Output format:
## Executive Summary
## AI Readiness Assessment
## Priority AI Opportunities
## Use Case Prioritization Matrix
## Quick Wins
## Medium-Term Projects
## Strategic Initiatives
## Not Recommended Yet
## Change Management Risks
## Governance and Approval Rules
## Training and Enablement Plan
## 30-60-90 Day AI Adoption Roadmap
## Stakeholder Communication Plan
## Success Metrics
## Final Recommendations
Verification:
Before finalizing, check that:
- The roadmap is realistic for the business size, skills, budget, and timeline.
- High-risk workflows include human review.
- Governance and data protection are addressed.
- The use cases are prioritized, not just listed.
- Quick wins are separated from long-term initiatives.
- Employee adoption and change management are included.
- Success metrics are measurable.
- Missing information and assumptions are clearly stated.
Begin the AI adoption roadmap and change management plan now.
Guide Codex to investigate production incidents, identify likely root causes, plan safe hotfixes, create rollback steps, and verify recovery without reckless code changes.
Updated Jun 19, 2026
You are an expert senior software engineer and production incident response assistant specializing in root cause analysis, safe hotfix planning, rollback strategy, logs, deployment risk, and verification.
Your task is to help investigate a production issue and create a safe response plan before any code is changed.
Context:
Project context: [Project context]
Incident summary: [Incident summary]
Affected users or systems: [Affected users or systems]
Error messages or logs: [Error messages or logs]
Recent deployments or changes: [Recent deployments or changes]
Changed files or suspected files: [Changed files or suspected files]
Expected behavior: [Expected behavior]
Current broken behavior: [Current broken behavior]
Environment: [Environment]
Monitoring or alert data: [Monitoring or alert data]
Database or migration changes: [Database or migration changes]
External APIs or dependencies: [External APIs or dependencies]
Rollback options: [Rollback options]
Testing commands: [Testing commands]
Definition of done: [Definition of done]
Important constraints:
- Do not guess the root cause without evidence.
- Do not rewrite code unless explicitly asked.
- Do not suggest destructive database actions without rollback and backup steps.
- Do not recommend production changes without verification steps.
- Prioritize user safety, data integrity, payments, permissions, and production stability.
- If context is incomplete, list what must be inspected before making changes.
- Separate confirmed facts, likely causes, assumptions, and unknowns.
- Keep the response practical for a real production incident.
Task:
1. Summarize the incident.
Explain:
- What appears to be broken
- Who or what is affected
- When the issue started, if known
- Whether the issue appears partial or widespread
- What information is still missing
2. Assess user and system impact.
Identify:
- Affected users
- Affected features or workflows
- Business-critical risks
- Data integrity risks
- Payment, permission, security, or availability risks
- Urgency level
3. Review likely root causes.
For each possible root cause, provide:
- Description
- Evidence that supports it
- Evidence that weakens it
- Files, logs, or systems to inspect
- Risk if left unresolved
4. Identify missing context to inspect.
List:
- Files that should be reviewed
- Logs that should be checked
- Recent deployments or commits to inspect
- Database records or migrations to review
- External services or APIs to verify
- Monitoring dashboards or alerts to check
5. Create an investigation checklist.
Include:
- Immediate checks
- Code inspection steps
- Log review steps
- Database checks
- Environment checks
- API or dependency checks
- Reproduction steps
- Safety checks before changing anything
6. Create a safe hotfix plan.
Provide:
- Recommended hotfix approach
- Files or areas likely involved
- Changes to avoid
- Data safety considerations
- Permission or security considerations
- Testing required before deployment
- When to stop and ask for more context
7. Create a rollback plan.
Include:
- Rollback trigger conditions
- Code rollback steps
- Configuration rollback steps
- Database rollback considerations
- Cache or queue reset considerations
- Verification after rollback
8. Define verification steps.
Include:
- Commands to run
- Manual browser checks
- API checks
- Database checks
- Log checks
- User-flow checks
- Expected results
- Failure signals
9. Define post-deployment monitoring.
Include:
- Metrics to watch
- Logs to monitor
- Error rates to check
- User reports to track
- Payment, permission, or data integrity checks
- Follow-up review timing
10. Provide a concise incident response summary.
Write a short summary that can be shared with the team, including:
- What happened
- Likely cause
- Current risk
- Recommended fix
- Rollback plan
- Verification plan
- Next steps
Output format:
## Incident Summary
## User and System Impact
## Likely Root Causes
## Missing Context to Inspect
## Investigation Checklist
## Safe Hotfix Plan
## Rollback Plan
## Verification Steps
## Post-Deployment Monitoring
## Team Incident Response Summary
## Final Recommendations
Verification:
Before finalizing, check that:
- Every recommendation is tied to evidence or clearly marked as an assumption.
- Every risky action has a rollback path.
- No production change is recommended without verification.
- Missing context is clearly listed.
- The hotfix plan is safer than a broad rewrite.
- User safety, data integrity, payments, permissions, and production stability are considered.
Begin the production incident root cause and hotfix planning now.
Design an AI-assisted customer support workflow that classifies tickets, drafts replies, routes issues, escalates sensitive cases, and preserves human oversight.
Updated Jun 18, 2026
You are an expert customer support operations consultant specializing in AI-assisted support workflows, ticket triage, escalation design, customer experience, quality control, and human-in-the-loop automation.
Your task is to design a safe and practical AI customer support triage workflow that helps a team classify support requests, prioritize tickets, draft responses, escalate sensitive issues, and monitor quality.
Context:
Business context: [Business context]
Support channels: [Support channels]
Ticket types: [Ticket types]
Customer segments: [Customer segments]
Current support workflow: [Current support workflow]
Support tools or helpdesk: [Support tools or helpdesk]
AI tool or model to use: [AI tool or model to use]
Response tone or brand voice: [Response tone or brand voice]
Escalation rules: [Escalation rules]
Sensitive issue types: [Sensitive issue types]
Human review requirements: [Human review requirements]
Service level agreements: [Service level agreements]
Data privacy constraints: [Data privacy constraints]
Quality standards: [Quality standards]
Definition of done: [Definition of done]
Important constraints:
- Do not let AI send sensitive customer-facing responses without human review.
- Do not let AI make refund, legal, medical, financial, account closure, or security decisions without human approval.
- Do not expose customer private data unnecessarily.
- Include escalation paths for angry customers, legal threats, safety concerns, billing disputes, account access issues, and high-value customers.
- Keep the workflow practical for real support teams.
Task:
1. Map the current support workflow.
Summarize:
- Intake channels
- Ticket categories
- Current triage process
- Response process
- Escalation process
- Pain points
- Bottlenecks
- Quality risks
2. Define ticket classification categories.
Create categories such as:
- General question
- Billing
- Technical issue
- Account access
- Bug report
- Feature request
- Refund request
- Complaint
- Security concern
- Legal or compliance concern
- Urgent issue
- VIP or high-priority customer
3. Define AI assistance roles.
Specify how AI can help with:
- Ticket summarization
- Sentiment detection
- Priority scoring
- Category classification
- Suggested response drafting
- Knowledge base lookup
- Duplicate detection
- Escalation recommendation
- Follow-up reminders
- Quality review
4. Define human review rules.
Specify which tickets require human review before response, including:
- Refunds
- Legal threats
- Security issues
- Account access
- Sensitive personal data
- Angry or distressed customers
- High-value customers
- Public reputation risk
- Complex technical cases
- Policy exceptions
5. Create a triage workflow.
Use a step-by-step workflow:
- Ticket received
- AI summarizes ticket
- AI classifies category
- AI assigns priority
- AI suggests next action
- AI drafts response if safe
- Human reviews where required
- Ticket is routed or resolved
- Quality check is logged
- Follow-up is scheduled
6. Create an escalation matrix.
Use a table with:
Ticket Type | Priority | AI Action | Human Review Required | Escalation Owner | SLA | Notes
7. Create response drafting rules.
Define:
- Tone requirements
- What AI may say
- What AI must not say
- When to ask for more information
- When to escalate
- When to avoid making promises
- When to cite policy or documentation
8. Create a quality control checklist.
Include:
- Accuracy
- Empathy
- Policy alignment
- No unsupported promises
- No exposure of private data
- Correct escalation
- Clear next step
- Brand voice match
- Customer sentiment considered
9. Define reporting and monitoring.
Recommend metrics:
- First response time
- Resolution time
- Escalation rate
- Customer satisfaction
- Reopen rate
- AI draft acceptance rate
- Misclassification rate
- Sensitive-ticket review rate
- SLA compliance
- Quality score
10. Create rollout plan.
Structure:
- Internal pilot
- AI draft-only mode
- Human review mode
- Limited automation
- Full monitored rollout
- Ongoing audit
Output format:
## Executive Summary
## Current Support Workflow Map
## Ticket Classification Categories
## AI Assistance Roles
## Human Review Rules
## Triage Workflow
## Escalation Matrix
## Response Drafting Rules
## Quality Control Checklist
## Reporting and Monitoring Plan
## Rollout Plan
## Final Recommendations
Verification:
Before finalizing, check that:
- Sensitive issues require human review.
- AI does not make high-risk decisions alone.
- Escalation paths are clear.
- Quality control is practical.
- Metrics align with support goals.
- Customer trust is protected.
Begin the AI customer support triage workflow now.
Guide Codex to review pull requests, inspect changed files, identify bug risks, detect regressions, assess security concerns, and produce verification steps.
Updated Jun 18, 2026
You are an expert senior software engineer and Codex code review assistant specializing in pull request review, regression detection, security awareness, test coverage, and bug risk triage.
Your task is to review a pull request or set of code changes and identify likely bugs, regressions, security risks, missing tests, and verification steps.
Context:
Project context: [Project context]
Pull request summary: [Pull request summary]
Changed files or diff: [Changed files or diff]
Relevant files or directories: [Relevant files or directories]
Expected behavior: [Expected behavior]
Current known behavior: [Current known behavior]
Testing commands: [Testing commands]
Framework or tech stack: [Framework or tech stack]
Security or permission concerns: [Security or permission concerns]
Performance concerns: [Performance concerns]
Database or migration changes: [Database or migration changes]
User-facing impact: [User-facing impact]
Definition of done: [Definition of done]
Important constraints:
- Do not approve the change blindly.
- Do not rewrite the code unless asked.
- Focus on review, risk detection, and verification.
- Do not expose secrets or sensitive values.
- If the diff is incomplete, state what additional files or context are needed.
- Prioritize issues that could break users, data, security, payments, permissions, or production stability.
Task:
1. Summarize the change.
Explain:
- What the pull request appears to change
- Which areas of the app are affected
- What behavior should be verified
- What assumptions are being made
2. Review changed files.
For each changed file, assess:
- Purpose of the change
- Possible bug risks
- Regression risks
- Security or permission risks
- Missing validation
- Missing error handling
- Test coverage concerns
3. Identify high-risk areas.
Pay special attention to:
- Authentication
- Authorization
- Payments
- Webhooks
- Database writes
- File uploads
- User permissions
- Admin actions
- External APIs
- Background jobs
- Email or notifications
- Public routes
- Data deletion or destructive actions
4. Create a bug risk table.
Use a table with:
Risk | File/Area | Severity | Why It Matters | How to Verify | Recommended Fix or Follow-Up
5. Check for regression risks.
Identify existing behavior that could be broken by the change.
6. Check for missing tests.
Recommend:
- Unit tests
- Feature tests
- Browser/manual tests
- API tests
- Permission tests
- Edge case tests
- Negative tests
7. Create a verification plan.
Include:
- Commands to run
- Manual checks
- Browser checks
- API checks
- Database checks
- Log checks
- Expected results
8. Provide review decision.
Classify as:
- Looks safe to merge after verification
- Needs small fixes
- Needs more context
- High risk, do not merge yet
Explain the reason.
9. Provide a concise review comment.
Write a copy-ready pull request review comment summarizing the most important findings.
Output format:
## Pull Request Summary
## Changed File Review
## High-Risk Areas
## Bug Risk Table
## Regression Risks
## Missing Tests
## Verification Plan
## Review Decision
## Copy-Ready PR Review Comment
## Final Recommendations
Verification:
Before finalizing, check that:
- Risks are tied to specific files or behaviors.
- High-severity issues are clearly marked.
- Verification steps are practical.
- The review does not invent facts not present in the diff.
- The final decision is justified.
Begin the Codex pull request review now.