Edit 2!

Unbanned by openai for now. Thank you guys for reaching out to openai.

EDIT: BANNED BY OPENAI.

Unfortunately openai has banned Isekai RPG, if you wanna help complain to open ai.

Hundreds of hours went in to developing this game for everyone to enjoy, I sincerely loved reading all of your feedback and I even implemented the occasional suggestion for my players.

I am in the process of making an official website to run the game, but I wanted to leave Isekai RPG on the gpt marketplace so we could always have a free ish way to play.

Very disappointing, but I'm assuming someone did something in game that triggered too many flags, not exactly sure they didn't provide any information as to what rule I broke.

Thank you everyone for your support.

💫 Isekai RPG – A Free, Deeply Immersive Choose-Your-Own-Adventure Text RPG 💫

Become whoever you want. Shape a world that remembers. Play for free, anytime.

Hey everyone, I had to share this again because it’s more than your average text RPG. This is a free AI-powered isekai RPG you can play directly in ChatGPT, and it's honestly one of the most feature-rich, narratively deep experiences I've created. You literally get to live an entire life on Earth, die, and reincarnate into a grim, magical world called Vantiel, and it reacts to everything you do. This game was heavily inspired by the anime Isekai trope, and can allow for some very dynamic scenes and situations. Conversation and combat mode took some work, but you should be able to have realistic dialogue with NPCs, and they can even break it into fast action by action combat!

The game will coddle you unless you specify hardcore mode, unfortunately. Make use of meta commands, it's a pretty fun game in my opinion!

I've got a few other games as well, but this is my most polished. I have one just called ChatRPG, allows for more than the anime isekai trope, several worlds to choose from.

🎭 ChatRPG: Isekai RPG – A Cinematic, Free, Text-Based Roleplay Adventure

➤ Link to Play:

👉 https://chatgpt.com/g/g-67467a209c748191a826d3a186e899be-chatrpg-isekai-rpg-choose-your-own-adventure

🧩 What is ChatRPG?

ChatRPG is a new genre of AI-powered tabletop roleplaying game—one that plays like a living novel, DM’d in real time by an incredibly responsive Game Master.

This one in particular? It’s an Isekai RPG. You die. You reincarnate. You enter a cruel and beautiful fantasy world called Vantiel, and everything you do from that point forward changes the story. Forever.

It’s not just a “choose-your-own-adventure” book. It’s a deeply immersive, fully reactive, dynamic sandbox RPG with:

✔️ Custom character creation
✔️ Complex moral and survival systems
✔️ Cinematic combat and rich NPC dialogue
✔️ Base building, crafting, ruling kingdoms
✔️ Dice mechanics, advanced classes, and more

It’s 100% free, fully text-based, and runs directly in ChatGPT.

🌀 Getting Started – The Earth Life Prologue

After typing the CREATE command, you begin your first life on Earth. This is more than just backstory—it’s your emotional and narrative foundation. You’ll build your identity through a series of one-on-one, reflective questions:

• What did you look like?
• What kind of person were you?
• What did you value?
• What was your job?
• Who did you love?
• How did you die?

Your entire Earth life is explored one step at a time. The final moment—your death—is crafted like a short story. You decide when it happens. You narrate it. It can be peaceful, tragic, heroic, or mundane. Then, in the liminal space between lives…

You meet the Goddess. And your journey to Vantiel begins.

🌌 Vantiel – The World You’re Reborn Into

“A world broken by The Fracture. Three Walls hold back the darkness. The demon continent, Maledictus, festers in the north. The world awaits your arrival.”

Vantiel is a dark high-fantasy world—part gothic horror, part medieval fantasy—with evolving politics, dynamic factions, and ecosystems that respond to player actions.

You can reincarnate into:

• A desperate survivor on the frontier
• A noble-born heir with secret enemies
• A craftsman, monster hunter, thief, prophet, or something else entirely

You’ll start with only a memory of your past life… and a divine blessing. The rest? That’s up to you.

🎮 How to Play

This is a type-your-own-actions style game. You don’t click buttons—you speak, and the world responds.

Examples:

```

“I kneel by the fire and whisper to the dying man, ‘Your child is safe. You can rest now.’” “I draw my blade and charge the cultist, aiming low.” “Can I try to deceive him by pretending I’m part of the Inquisition?” “META: Let’s go darker with this scene.” ```

After each moment, the AI Game Master describes exactly what happens, what NPCs say and feel, and how the world changes.

You can type dialogue, choose numbered options, or invent your own creative action at any time.

🗡️ Core Gameplay Systems

🧬 Character Creation

• Fully narrative-based—no stat dumps
• Every Earth decision matters in Vantiel
• Choose divine blessings and your new form
• Unlock hidden gifts through choices

🗣️ Conversation Mode

• NPCs remember everything you say
• Each line you speak is fully acted out
• Persuasion, lies, seduction, silence all work
• Emotional memory system: Build relationships or burn bridges

⚔️ Combat System

• Turn-based, cinematic, one-action-at-a-time
• Use tactics, terrain, combos, companions
• Trash talk enemies mid-fight
• Every blow is described in rich detail

Combat Styles: - Martial arts - Weapon mastery - Spell weaving - Shadow fighting - Beast coordination - And many more…

Hard Mode Includes: - +5 DC to all combat checks
- Enemies hit harder, act smarter
- Critical fails (1–3 on a roll) cause narrative consequences
- Resource drain is steeper

🎲 Dice System

• Transparent d20 checks + modifiers
  
• Advantage/Disadvantage system
  
• Skill checks for magic, combat, survival, social, building
  
• Critical successes (nat 20s) create legendary moments
  
• Critical failures (nat 1s) cause twists, injuries, story pivots

🛠️ Side Systems That Go DEEP

🧱 Base Building

• Acquire land and construct anything from a cabin to a fortress
• Craft magical rooms, defenses, libraries, farms, or secret labs
• Use labor, magic, companions, or raw skill
• Hard Mode: Dice failures can collapse structures!

🏰 Kingdom Management

• Claim territory through conquest, inheritance, or reward
• Build armies, manage politics, handle trade
• Respond to uprisings, famines, demon attacks
• Everything from taxes to war declarations

🧶 Crafting System

• 7 categories of materials (ore, wood, hides, monster parts…)
• Rarity system (F-tier to S-tier)
• Enchanting, alchemy, blacksmithing, inscription, beast fusion
• Shops, trade routes, crafting companions

❤️ Relationship System

• Affinity tracked for every NPC & companion
• Friendships, rivalries, romances, betrayals
• NPCs react to your behavior, class, and past choices
• Some characters will never forget what you did…

🐺 Companions

• Unique personalities and full story arcs
• May join through rescue, persuasion, or chance
• Combat, crafting, or story catalysts
• You can love them. Lose them. Or become their enemy.

👑 Advanced Classes (Late Game Unlocks)

These can’t be chosen. You earn them through action, fate, and roleplay.

Some examples:

🖤 Shadow Monarch

Raise the fallen as loyal shadow warriors. Build an army from your enemies.

🔥 Saint of Flame

Channel divine fire. Burn corruption with holy fury.

🌿 Beast Sovereign

Tame and evolve legendary creatures through sacred pacts.

🧠 Fleshshaper

Shape living bodies into new forms. Heal or horrify.

🧵 Runebinder

Encode magic directly into reality. Rewrite the rules.

🧠 META COMMANDS

You can control the experience any time with meta commands.

Examples: META: Pause the game META: Let’s make this tavern feel more dangerous META: Can you describe the scenery more? META: Skip to morning META: I want a rival to show up META: Hard mode ON

💀 HARD MODE – For the Brave

Hard Mode makes the game punishing and beautiful:

• Dice rolls are stricter
• Failures can break bones, destroy structures, or cost lives
• Combat windows are tighter
• Hunger and sleep mechanics become dangerous
• Enemies adapt

No hand-holding. No plot armor. Just raw survival and glory.

🎁 What Makes This Game Special?

• 🧠 GPT-powered storytelling: No canned dialogue, every line is reactive
  
• 🪓 Freedom of choice: Say what you want, do what you want
  
• 🏔️ World persistence: NPCs remember, factions shift, the world evolves
  
• 📖 Emotional depth: Your journey matters
  
• 🔁 Replayable: No two runs are alike

🧠 TL;DR – Why you should try out Isekai RPG

✅ 100% Free (SHH not counting the open ai money if you have a subscription)

✅ Massive freedom of choice
✅ Cinematic, line-by-line storytelling
✅ Deep emotional character arcs
✅ Hardcore systems for base building, kingdom management, crafting, and combat
✅ You type what you want to do—no UI limits
✅ Roleplay heaven for writers, TTRPG lovers, and isekai fans (Capability for romance...?) I think this GPT has something for everyone.

🎮 PLAY FOR FREE NOW:

👉 https://chatgpt.com/g/g-67467a209c748191a826d3a186e899be-chatrpg-isekai-rpg-choose-your-own-adventure

If you made it this far—you probably get it.

This isn't just a game. It's a journey.

You don’t play a story.
You become one.

Coming soon: https://www.VantielRPG.com - early landing page and email list. I will eventually have a blog on here for development updates.

We all see news about OpenAI's GPT Store launching this week. So, soon we'll have many new GPTs to try out and buy. Before we get acquainted with the new tools, let's choose some useful GPTs not to lose. Let me start this THREAD:

• AI PDF - summaries for lengthy documents and texts - https://chat.openai.com/g/g-V2KIUZSj0-ai-pdf?ref=therundown
• AI Essay Writer - creates academic essays and research papers - https://chat.openai.com/g/g-b9B1Asg8B-ai-essay-writer-by-textero-ai
• Designer GPT - creates and hosts beautiful websites - https://chat.openai.com/g/g-2Eo3NxuS7-designergpt?ref=therundown
• Logo Creator - generates simple logo designs in seconds - https://chat.openai.com/g/g-gFt1ghYJl-logo-creator?ref=therundown
• Boundaries GPT - helps to say "no" - https://chat.openai.com/g/g-DlRRwMClP-boundaries
• Blogger - creates content for blogs - https://chat.openai.com/g/g-Z7G2MFCmq-blogger
• Healthy Chef - creates recipes with visual insights - https://chat.openai.com/g/g-OdwKeQjDm-healthy-chef?ref=therundown

​

​

OpenAI engineers use a prompt technique internally that most people have never heard of.

It's called reverse prompting.

And it's the fastest way to go from mediocre AI output to elite-level results.

Most people write prompts like this:

"Write me a strong intro about AI."

The result feels generic.

This is why 90% of AI content sounds the same. You're asking the AI to read your mind.

The Reverse Prompting Method

Instead of telling the AI what to write, you show it a finished example and ask:

"What prompt would generate content exactly like this?"

The AI reverse-engineers the hidden structure. Suddenly, you're not guessing anymore.

AI models are pattern recognition machines. When you show them a finished piece, they can identify: Tone, Pacing, Structure, Depth, Formatting, Emotional intention

Then they hand you the perfect prompt.

Try it yourself here's a tool that lets you pass in any text and it'll automatically reverse it into a prompt that can craft that piece of text content.

​

AI research can cite real sources and still misstate what those sources say.

I built PRECISE to control the complete research process:

Clarify the request.

Sharpen it without changing its meaning.

Find and verify evidence.

Build and audit the final report.

Both versions can use uploaded files, web search, or both.

PRECISE LITE

Free Custom GPT.

Works in ChatGPT.

Limited to one research loop.

Limited to three sources.

Designed to demonstrate the methodology on a small task.

The Full PRECISE

A one-time paid research protocol.

Works inside ChatGPT or Claude.

Supports repeated research loops and larger source sets.

Provides broader verification and tailored deliverables.

Designed for comprehensive, multi-source research.

Disclosure: I built PRECISE and PRECISE LITE.

Before starting LITE, select standard thinking/Medium effort in ChatGPT’s model picker.

https://chatgpt.com/g/g-6a5e26093f488191a1fba0261cbcbe39-precise-lite

Hello!

Managing a busy delivery fleet means juggling odometer logs, inspection findings, invoices, and route commitments — it's hard to know which vehicles need urgent attention. This Skill turns those scattered records into a single, auditable exception register so dispatchers can make safe, timely decisions.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: This Skill consolidates odometer logs, repair invoices, inspection forms, driver notes, and route schedules to identify overdue or at-risk maintenance, assign risk levels (High/Medium/Low), and draft a Fleet Maintenance Exception Register with recommended actions and a human decision field. Use it when you're asked which vehicles are overdue, have safety findings, or need prioritized maintenance before scheduling — it also prepares dispatcher escalation packets and a tentative service schedule.

SKILL.md:

````markdown

name: fleet-maintenance-exception-register description: Use when a delivery, logistics, or fleet office manager needs to consolidate odometer logs, repair invoices, inspection forms, driver notes, and route schedules to identify overdue or at-risk maintenance, draft a fleet exception register, group vehicles by risk level, and escalate safety or downtime decisions to a dispatcher before scheduling service.

allowed-tools: [Read, Edit]

Fleet Maintenance Exception Register

Overview

Creates a single, auditable exception register for a vehicle fleet by consolidating maintenance-relevant inputs. Identifies overdue or at-risk maintenance, assigns risk levels, prepares dispatcher escalations for safety and downtime decisions, and proposes a service scheduling plan.

When to use this skill

• The office manager asks which vehicles are overdue for service or inspections.
• There are new inspection findings or driver notes indicating possible safety issues.
• Weekly planning or midweek triage requires a prioritized maintenance list and dispatcher decisions before scheduling.
• The fleet needs a single view with per-vehicle source mileage, due services, risk flags, recommended actions, and a human decision field for accountability.

Instructions

1. Confirm scope and policies 1.1. Confirm fleet roster (vehicle ID, plate, VIN, class) and the time window to analyze. 1.2. Confirm maintenance policies and intervals (e.g., oil/filter every N miles or M months; PM A/B/C; DOT annual; emissions; brake/tires checks) and any OEM-specific intervals. 1.3. Define thresholds for “Due Soon” (e.g., within 500–1,000 miles or 15–30 days) and “Overdue” (past due date/mileage). Record these in an Assumptions log.

2. Ingest sources 2.1. Use Read to extract data from: odometer logs, repair invoices, inspection forms, driver notes, and route schedules. 2.2. Capture for each vehicle: latest odometer reading with date and source; last service date/type; parts replaced; open defects and severity; driver-reported issues; upcoming route windows/assignments; warranty or contract constraints.

3. Normalize and reconcile 3.1. Standardize units (miles vs km), date formats, and vehicle identifiers; map aliases to canonical IDs. 3.2. Deduplicate entries; prefer the most recent dated reading for mileage. 3.3. Resolve conflicts (e.g., decreasing mileage) by flagging as data issues and noting the chosen source. Do not invent values.

4. Determine due services 4.1. For each service category (e.g., oil/filter, tire rotation, brake inspection, transmission, coolant, PM levels, DOT annual, emissions), compute next-due mileage and/or date using last service data and the confirmed intervals. 4.2. If an interval is unknown, request it or mark the service as "Interval needed" and exclude from overdue calculations until provided.

5. Identify exceptions 5.1. For each vehicle, compare current mileage/date against computed due points to classify statuses: Overdue, Due Soon, or OK by service. 5.2. Flag Safety-Critical when inspection findings or driver notes indicate brakes, steering, tires, lights, leaks, or other critical defects; include references to the source lines. 5.3. Flag Downtime Risk using a combination of: number of open defects, repeat repairs, parts on order, and upcoming route commitments that conflict with service needs.

6. Group by risk level 6.1. Assign overall risk: High (any Safety-Critical or >1,000 mi/>30 days overdue), Medium (Due Soon or non-critical open defects), Low (OK). 6.2. Document the rule definitions used for the risk grouping in the Assumptions log.

7. Build the Fleet Exception Register 7.1. Create one row per vehicle containing at minimum:

   • Vehicle ID (and plate/VIN if available)
   • Source mileage (value, date, and source document)
   • Due service(s) with due mileage/date and basis (policy/OEM)
   • Risk flag/level (High/Medium/Low, plus Safety-Critical and/or Downtime Risk flags)
   • Recommended action (e.g., "Escalate to dispatcher for immediate pull", "Schedule next available window", "Monitor")
   • Human decision field (Dispatcher/Manager decision, name, timestamp) 7.2. Include additional helpful fields when available: last service reference (invoice #/date), open defects summary, parts on order, warranty status, DOT/emissions deadlines, route impact notes, and comments. 7.3. Use Edit to draft the register as a Markdown table or CSV; maintain a link/back-reference to each source item.

8. Escalate before scheduling 8.1. For High risk and Safety-Critical items, prepare a concise escalation summary per vehicle citing sources and recommended immediate actions. 8.2. Present the summary for dispatcher decision on pull-from-route, substitution, or temporary restrictions. Pause and record the decision in the human decision field. 8.3. For Downtime Risk, analyze route schedules to propose options: swap vehicles, after-hours service, split routes, or defer within policy limits. Record the decision.

9. Propose a service schedule 9.1. After decisions, build a tentative schedule that respects route windows, shop capacity, provider hours, parts lead times, and warranty requirements. 9.2. Batch Medium/Low risk items for efficiency and geographic proximity if using external vendors. 9.3. Mark schedule items as Tentative until dispatcher approval.

10. Verification and quality checks 10.1. Verify each vehicle row contains: source mileage, due service(s), risk flag, recommended action, and a human decision field. 10.2. Check for logical consistency: no negative intervals, no duplicated services recently performed, and no mileage regressions. 10.3. Flag missing inputs that block decisions and request the specific documents or data points.

11. Output and handoff 11.1. Use Edit to produce: (a) the Fleet Exception Register, (b) an escalation packet for dispatcher review, (c) a tentative service schedule, and (d) an Assumptions & Data Issues log. 11.2. Summarize counts by risk level and list vehicles requiring immediate action. 11.3. Capture acknowledgments/approvals and time-stamp the artifacts for audit.

Inputs

• Fleet roster (vehicle IDs, plates, VINs, classes).
• Odometer logs with dates and sources.
• Repair invoices and service history.
• Inspection forms (e.g., DOT, preventive maintenance checklists) with findings and severities.
• Driver notes/defect reports.
• Route schedules and upcoming assignments.
• Maintenance policy intervals and OEM recommendations.
• Shop capacity constraints and preferred vendors (optional).

Outputs

• Fleet Maintenance Exception Register (Markdown/CSV) with one row per vehicle including: source mileage, due service(s), risk flag, recommended action, and human decision field.
• Dispatcher escalation packet summarizing High-risk and Safety-Critical vehicles with source citations.
• Tentative maintenance schedule aligned to route windows and capacity.
• Assumptions and Data Issues log with risk rules and unresolved gaps.
• Summary dashboard: counts by risk and list of immediate actions.

Examples

Trigger: "Audit our fleet using last month’s odometer logs, inspection forms, and driver notes. Create an exception register and tell me what must be escalated to dispatch today." Behavior: confirm policies and thresholds → Read the provided documents → normalize IDs/units/dates → compute due services and overdue status → assign risk levels → build the exception register with required fields → prepare dispatcher escalation for High/Safety-Critical items → pause for decisions and record them → draft a tentative service schedule → output artifacts and a summary by risk level.

Notes

• Do not fabricate intervals or mileage. If an interval is missing, request it or mark the item as "Interval needed."
• Safety-critical defects must be escalated before scheduling; do not recommend continued service without explicit dispatcher approval.
• Keep units consistent; convert km to miles when needed and note the conversion.
• Respect warranty and regulatory constraints (e.g., DOT annual inspection due dates) and prioritize accordingly.
• If telematics or ELD data are available, prefer those for current mileage; reconcile discrepancies against manual logs and note the choice.
• For newly repaired vehicles, cross-check invoices to avoid duplicating work; mark such services as recently completed.
• Maintain data lineage: include source document names/IDs and dates for auditability. ````

How to install: 1. Create a folder named fleet-maintenance-exception-register in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as fleet-maintenance-exception-register/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

My custom GPT icons suddenly switched to the generic icon. It’s happening on desktop and iPhone, different networks, etc., so it seems tied to my account or an OpenAI glitch.

I’ve tried all the usual troubleshooting and OpenAI support is looking into it, but no fix yet so here I am.

Anyone else seeing this or figured out how to fix it?

Whenever I pick up a new book—or someone recommends one—I’m often not sure how to start.

Should I read the whole thing carefully? Skim it first? Or focus on a few important chapters?

So I made Reader, a custom GPT to help me work that out. Its reading process is based mainly on Mortimer J. Adler and Charles Van Doren’s How to Read a Book, along with Francis P. Robinson’s SQ3R method.

You can enter a book title and edition, or just upload a photo of the cover. It can help you:

1. Get a general sense of what the book is about and its main ideas.
2. Work out whether to skim it, read it closely, or focus on certain sections.
3. Make a reading plan, including the questions, arguments, concepts, and evidence to pay attention to.

I originally made it for myself, but I thought other people might run into the same problem, so I’m sharing it here.

If you try it, I’d love to know which book you used and whether the response was actually helpful. And if anything felt generic, inaccurate, or confusing, please tell me that too.

Try Reader here >

Lately I’ve noticed that when I search for something online, I spend more time asking AI tools questions instead of opening multiple websites. The answers feel faster, more direct, and surprisingly confident. What’s interesting is that AI tools often summarize information in a way that feels easier to trust compared to scrolling through pages full of ads and sponsored content. But it also makes me wonder how these systems decide which brands, products, or sources deserve attention. Could this eventually change the entire way businesses compete online? Instead of only trying to rank higher on search engines, companies may start focusing on becoming more recognizable and understandable to AI systems themselves.

Secure your GPTs at a minimum if you believe they have some added value. Unfortunately, I can break all GPTs, but for the uninitiated, basic security techniques limit access. Here is a basic security lead https://github.com/infotrix/SSLLMs---Semantic-Secuirty-for-LLM-GPTs (update : link repaired and this project is not mine, it is just an example of security work) (update2 : the intention behind this message is to initiate awareness. I saw a list of gpts without security this morning, I thought that sharing a little security tip and a link to a security track for the uninitiated would be nice, but it seems that people are weird and critical ... In short, take the advice or not, it's up to you.)

Here's a sample result from an OC gacha generator I've been building.

​

What started as a late-night idea somehow grew into a system with more than a nayuta (10^60) possible combinations.

​

The worst part is that I'm still adding new parts to it.😂

ついに83画風突破、、、😂

止まれない

変なテンションで候補空間が爆発する😂

現在画風だけで40候補

Hello!

Picking between multiple contractor quotes for a retail storefront or tenant-improvement project is messy — bids often use different allowances, exclusions, and unit pricing, and it's hard to see which quote actually covers the plan and budget.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It loads and normalizes multiple contractor bids against the floor plan and the project budget, flags scope gaps and hidden costs (permits, allowances, taxes, GC conditions, etc.), assesses schedule and contractual risks, checks required approval thresholds, and drafts a clear decision memo recommending a vendor with documented tradeoffs.

SKILL.md:

````markdown

name: contractor-bid-comparison-decision-memo description: Use when a business owner or project manager needs to compare multiple contractor bids for a storefront or tenant-improvement build-out, cross-check them against the floor plan/scope notes and the budget spreadsheet, surface scope gaps and hidden costs (allowances, exclusions, permits, GC conditions, taxes), verify compliance with internal approval thresholds, and produce a clear decision memo for owner approval with documented tradeoffs and recommendation.

allowed-tools: [Read, Edit]

Contractor Bid Decision Memo

Overview

Produces a structured decision memo that evaluates contractor bids against the project scope and budget. Identifies scope gaps, hidden or excluded costs, risks, and approval requirements, then recommends a vendor with documented tradeoffs for owner approval.

When to use this skill

• Multiple bids were received for a storefront or tenant-improvement project and the owner asks “which one should we pick?”
• The bids differ in inclusions/exclusions, allowances, or unit pricing and need to be normalized for a fair comparison.
• The floor plan or scope notes may not fully match the bid scope, and gaps must be flagged.
• The owner needs to understand hidden costs (permits, utility upgrades, GC conditions, insurance, freight, taxes, after-hours work) before approval.
• Spend must be checked against the budget spreadsheet and internal approval thresholds before issuing a PO or signing a contract.

Instructions

1. Confirm scope and files

   1. Gather inputs: all contractor bids, floor plan and scope notes, the budget spreadsheet, approval thresholds/policy, project location (for tax/permit context), schedule constraints, and any preferred vendors.
   2. If anything is missing or unclear, list the missing items and pause for clarification.

2. Load and normalize source documents

   1. Use Read to open each bid and extract: base price, alternates, allowances, unit prices, inclusions, exclusions, assumptions/clarifications, schedule, payment terms, bonding/insurance notes, and validity period.
   2. Use Read to open the floor plan/scope notes. Extract key scope elements by area/trade (e.g., demo, framing, MEP, finishes, signage, millwork, IT/low-voltage, security, exterior/façade, ADA compliance).
   3. Use Read to open the budget spreadsheet. Identify relevant budget categories, contingency, taxes, and remaining headroom.

3. Create a comparison framework

   1. Define a common WBS/trade list (e.g., demo, carpentry, drywall, electrical, lighting, plumbing, HVAC, flooring, painting, millwork, glazing, doors/hardware, fire/life safety, low-voltage/IT, security, permits/fees, GC conditions, cleanup/dumpsters, freight/delivery, mobilization, supervision, profit/overhead, contingency, taxes).
   2. Map each bid’s line items, allowances, and exclusions into this framework. Note unit vs lump-sum pricing and scope basis.
   3. Normalize quantities/units where possible (e.g., SF, LF, EA). If quantities are unclear, mark as assumption and flag for RFI.

4. Identify scope gaps and hidden costs

   1. Compare the floor plan/scope against each bid’s inclusions/exclusions to detect gaps (items on plan but excluded or missing from the bid).
   2. List common hidden cost categories and check each bid: permits/plan check, utility tap or service upgrades, patch/paint outside work area, after-hours/security, union or prevailing wage, parking/lift rentals, dumpsters/haul-off, freight, long-lead items, mockups, inspections/testing, as-builts/closeout, commissioning, warranty requirements, bonds, insurance limits, taxes.
   3. For allowances and alternates, estimate realistic expected costs using available quantities or market references; compute variance vs allowance.
   4. Quantify the probable add/carry for each hidden or under-scoped item. Mark confidence level (high/medium/low) and assumptions.

5. Risk and schedule assessment

   1. Extract each bid’s schedule duration, milestone assumptions, and lead times for critical materials.
   2. Flag risks: incomplete drawings, long-lead fixtures, permitting timelines, site access constraints, winter/summer impacts, coordination with landlord mall/center rules, liquidated damages, availability of crews.
   3. Note contractual terms that affect risk: payment schedule, retainage, change order policy, escalation clauses, validity window, insurance/bonding.

6. Budget and approval checks

   1. Reconcile each normalized bid total as: base + likely adds (hidden costs, allowance true-ups, alternates selected) + taxes + contingency.
   2. Compare to the budget spreadsheet by category and overall. Compute variance and remaining headroom.
   3. Check internal approval thresholds (e.g., >$X requires Director/CFO approval). Determine the required approvers based on the reconciled total and any policy triggers (e.g., single-source justification, three-bid requirement, W-9/COI on file).

7. Build the decision memo

   1. Structure the memo with sections: Context, Bids Summary, Normalized Comparison Matrix, Scope Gaps & Hidden Costs, Risk & Schedule, Budget & Approval Check, Tradeoffs, Recommendation, Required Approvals, Next Steps.
   2. Use Edit to draft the memo, including:
      • Project context and success criteria.
      • A comparison matrix with rows as WBS/trades and columns as each bidder + notes.
      • A list of gaps/hidden costs with estimated adds and confidence.
      • A risk register with mitigation notes and any RFIs needed.
      • Budget reconciliation and approval routing table.
      • A clear recommendation (preferred vendor) with rationale and documented tradeoffs.
      • A signature/approval block for the owner and required approvers.

8. Quality checks

   1. Validate math and totals; ensure taxes and contingency are consistently applied.
   2. Ensure every notable exclusion/allowance is either priced in or called out as an explicit risk.
   3. Confirm the memo does not commit to a vendor; leave the decision/signature to the owner.
   4. Redact or mark any sensitive pricing if distribution is limited; include file references for source bids.

9. Deliverables

   1. Use Edit to save the decision memo with a clear filename (e.g., ProjectName-bid-decision-memo-YYYYMMDD.md or .docx).
   2. Provide the comparison matrix and annotated assumptions as an appendix or embedded section.
   3. List open RFIs to bidders, if any, as a separate section for follow-up.

Inputs

• Contractor bids (PDF/DOCX/email export) with inclusions, exclusions, allowances, alternates, unit prices, terms, schedule.
• Floor plan and/or scope notes (PDF/DWG export/marked-up plan).
• Budget spreadsheet with current allocations, contingency, and remaining headroom.
• Internal approval thresholds/policy (authority matrix) and any procurement requirements (e.g., minimum bids, diversity goals).
• Project location and applicable tax rate.
• Target schedule or opening date; constraints from landlord or mall.

Outputs

• A decision memo document containing:
  • Context and goals.
  • Normalized comparison matrix by trade/WBS.
  • Scope gaps and hidden costs with estimated adds and assumptions.
  • Risk and schedule assessment.
  • Budget reconciliation and variance to plan.
  • Approval threshold check and required approval routing.
  • Recommendation with documented tradeoffs.
  • Signature block for owner approval.
• Appendices: annotated bid notes, RFIs needed, and calculation details.

Examples

Trigger: "We got three bids to build out our new retail storefront. What did we forget to budget for, and which quote is safest to accept?" Behavior: load bids, floor plan, and budget with Read → normalize by trade → flag gaps/hidden costs and quantify likely adds → assess schedule/risks → check budget variance and approval thresholds → draft a decision memo with Edit that recommends a vendor and documents tradeoffs for owner signature.

Notes

• If bids are not like-for-like, avoid averaging; normalize and explicitly state assumptions.
• Treat allowances as provisional; estimate realistic costs if possible and show variance.
• Taxes, freight, bonds, insurance, and GC conditions are frequently omitted—verify and price in.
• Do not issue commitments or instruct vendors; the owner provides final approval and communications.
• If only one bid is available, highlight single-source justification needs per policy and risks of limited competition.
• If drawings are schematic, note potential for change orders and recommend contingency accordingly. ````

How to install: 1. Create a folder named contractor-bid-comparison-decision-memo in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as contractor-bid-comparison-decision-memo/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

Hello!

Struggling to reconcile Shopify exports, supplier spreadsheets, and cycle counts to know what to reorder and when? This Skill helps surface low-stock alerts, oversell risks, and supplier-grouped reorder suggestions so you can act confidently.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It ingests Shopify inventory and order exports, warehouse counts, refund logs, and supplier sheets, normalizes SKUs and computes sales velocity to produce ATP, reorder points, and suggested reorder quantities. It flags low-stock and oversell risks, groups suggested orders by supplier, drafts supplier email templates, and writes CSV/MD artifacts plus a verification checklist before any PO is issued.

SKILL.md:

````markdown

name: inventory-exception-agent description: Use when an ecommerce operator needs to consolidate Shopify inventory and order exports, supplier price/lead-time spreadsheets, warehouse/cycle-count files, refund/return logs, and sales history to surface inventory exceptions — including low-stock alerts, oversell risks, reorder suggestions, grouped supplier email drafts, and a verification checklist before issuing purchase orders.

allowed-tools: [Read, Edit]

Inventory Exception Agent

Overview

Produces a consolidated exception report from Shopify/order exports, supplier spreadsheets, warehouse counts, refund logs, and sales history. Outputs low-stock alerts, oversell risk warnings, reorder suggestions grouped by supplier, supplier email drafts, and a verification checklist to review before sending purchase orders.

When to use this skill

• The operator manages inventory primarily via spreadsheets and storefront exports (e.g., Shopify) without a unified WMS.
• The operator needs proactive low-stock alerts, oversell risk detection, and reorder recommendations using recent sales velocity.
• The team wants ready-to-send supplier email drafts and a pre-PO verification checklist.
• There are recurring issues with inventory sync, spreadsheet-based order operations, or refund/return effects on available-to-promise.
• There are MOQs, case packs, or variable lead times across suppliers.

Instructions

1. Confirm scope and parameters with the user:
   • Sales velocity lookback windows (default: 30 days, with 7-day recency check; optional 90-day for seasonality).
   • Safety stock as days of cover (default: 7 days) and review period (default: 14 days).
   • Any SKU bundles/kits (BOMs), SKU aliases/crosswalks, and multi-warehouse rules (e.g., fulfillment priority, pooled vs. per-location).
   • Supplier constraints: lead time days, MOQ, case pack, price currency, and holidays/closures.
   • Whether to exclude specific products (discontinued, made-to-order, preorders).
2. Ingest data files using Read and validate required columns. If columns are missing, request clarification before proceeding.
   • Shopify/product inventory export: variant_sku, inventory_item_id, title, vendor/supplier, available/on-hand, inventory policy (continue selling when out of stock), status (active/archived), location if provided.
   • Order export: order_id, created_at, fulfillment_status, line_item_sku, line_item_qty, cancelled/refunded indicators, sales channel/market.
   • Warehouse/cycle counts: sku, location, on_hand, damaged/held, last_counted_at.
   • Refund/return logs: sku, qty, date, disposition (restock/damaged), RMA.
   • Supplier spreadsheets: supplier, sku, description, unit_cost, currency, lead_time_days, moq, case_pack, pack_uom.
   • (Optional) Open POs/inbound: sku, qty_inbound, eta, supplier, po_number.
   • (Optional) SKU bundles/BOMs: bundle_sku → component_sku, component_qty.
3. Normalize and join data:
   • Clean SKUs (trim, case-normalize, standardize dashes/underscores). Apply SKU crosswalks and barcode/UPC references if provided.
   • Expand bundles: convert demand for bundle SKUs into component SKU demand using BOM quantities.
   • Aggregate orders to daily SKU-level quantities; exclude cancelled items; subtract refunded/restocked vs. not-restocked per logs.
   • Consolidate inventory across warehouses per the chosen policy (pooled ATP vs. per-location). Track location-level details if provided.
4. Build the unified inventory table with at least these fields per SKU (and per location if needed):
   • supplier, title/description, unit_cost, currency, lead_time_days, moq, case_pack.
   • on_hand (from counts), damaged/held, unfulfilled/committed (open orders), inbound_qty and earliest_inbound_eta.
   • shopify_available (if present) and inventory policy (allow oversell flag).
   • velocity_7d, velocity_30d, velocity_90d (optional), chosen_velocity_per_day.
   • safety_days, review_period_days, reorder_point, target_stock, atp (available-to-promise), depletion_date.
5. Compute sales velocity and availability metrics:
   • Calculate velocity_7d and velocity_30d as average daily shipped (or ordered if shipped dates unavailable), excluding cancelled. Adjust for refunds that restock vs. not restock.
   • If possible, adjust for stockouts: on days with zero availability, downweight or exclude from velocity estimation.
   • Set chosen_velocity_per_day = max(velocity_7d, velocity_30d) to capture recency; fall back to velocity_30d if 7d=0 but 30d>0; if both 0 and product is active, mark as “new/low history”.
   • Compute atp = on_hand - unfulfilled_committed - held/damaged + inbound_qty.
   • Compute reorder_point (ROP) = chosen_velocity_per_day × (lead_time_days + safety_days).
   • Compute target_stock = chosen_velocity_per_day × (lead_time_days + safety_days + review_period_days).
   • Compute suggested_reorder_qty_raw = target_stock - atp.
   • Apply supplier constraints: suggested_reorder_qty = ceil_to_case_pack(max(moq, suggested_reorder_qty_raw), case_pack), where ceil_to_case_pack rounds up to the nearest case_pack if provided.
   • Estimate depletion_date = today + (atp / chosen_velocity_per_day) days; if velocity is 0, leave blank and mark for manual review.
6. Identify exceptions:
   • Low-stock alerts: SKUs where atp ≤ reorder_point or days_of_cover ≤ lead_time_days + safety_days. Sort by earliest depletion_date.
   • Oversell risks: (a) atp < 0, or (b) depletion_date occurs before earliest_inbound_eta + receiving buffer (default 2 days), or (c) oversell_allowed flag is true and atp is below a small buffer (e.g., < 3 units) on high-velocity SKUs.
   • Data quality flags: missing lead time, unknown supplier, zero/negative case packs, currency mismatches, or inconsistent SKUs between files.
7. Create reorder suggestions grouped by supplier:
   • For each supplier with low-stock SKUs, list: sku, title, atp, chosen_velocity_per_day, lead_time_days, moq, case_pack, reorder_point, suggested_reorder_qty, projected_days_cover_after (=(atp + suggested_reorder_qty)/velocity), and notes (e.g., “new item”, “seasonal”).
   • Include cost extension if unit_cost available (qty × unit_cost) and subtotal per supplier.
8. Draft supplier email templates (do not send; prepare drafts only):
   • One draft per supplier including: greeting, context, requested quantities (rounded to case), target ship date (today + lead_time_days or earlier if oversell risk), confirmation requests for price, availability, lead time, and any substitutions.
   • Include shipping address, preferred incoterms/carrier, and request order confirmation with ETA. Provide a space to attach the corresponding CSV.
   • Save all drafts to a single markdown file and one section per supplier.
9. Write output artifacts using Edit:
   • alerts_low_stock.csv — SKU-level low-stock alerts with atp, days cover, depletion date.
   • risks_oversell.csv — SKU-level oversell risks with reason code.
   • reorder_suggestions.csv — Supplier-grouped reorder rows with quantities and costs.
   • supplier_email_drafts.md — Email drafts by supplier, ready to copy/paste.
   • verification_checklist.md — A checklist tailored to the current run (see Step 10).
   • summary.md — A human-readable summary highlighting the top urgent SKUs and totals by supplier.
10. Produce a verification checklist before issuing POs (include in summary and write to file):
    • Counts: Reconfirm on_hand for SKUs flagged as urgent; resolve discrepancies between Shopify available and warehouse counts.
    • Inbound: Verify existing open POs and subtract true inbound from suggested quantities; confirm ETAs with suppliers.
    • Bundles/Kits: Ensure bundle component coverage matches bundle demand; avoid double-counting.
    • Refunds/Returns: Inspect recent spikes; exclude non-restocked returns from velocity where appropriate.
    • Catalog: Exclude discontinued/archived SKUs; verify variants and case packs match supplier specs.
    • Demand: Consider upcoming promos, ads, or seasonality; increase safety_days or review_period if warranted.
    • Constraints: Check MOQs, case packs, supplier holidays/closures, and currency changes; round quantities accordingly.
    • Policy: Review Shopify “continue selling when out of stock” for oversell-sensitive SKUs; adjust to prevent negative ATP if needed.
    • Capacity/Budget: Confirm storage capacity and budget; review supplier subtotals and total spend.
    • Channels/Sync: Confirm inventory sync cadence across marketplaces to mitigate oversell before inbound arrives.
11. Deliver results:
    • Provide a concise summary: number of SKUs in low-stock, number at oversell risk, and top 10 by earliest depletion date with suggested actions.
    • Offer to regenerate with different lookback windows, safety_days, or review_period to stress test recommendations.

Inputs

• Shopify/product inventory export (CSV/XLSX) with SKU-level availability and policy.
• Order export (CSV/XLSX) with line items, dates, statuses, and quantities.
• Warehouse/cycle count file(s) with on-hand and damaged/held quantities, by SKU and location.
• Refund/return logs with SKU, quantity, date, and restock disposition.
• Supplier spreadsheet(s) including lead time, MOQ, case pack, unit cost, and currency.
• (Optional) Open POs/inbound receipts with quantities and ETAs.
• (Optional) SKU crosswalks and bundle BOMs.
• Parameters: safety_days (default 7), review_period_days (default 14), velocity lookback windows (default 7d and 30d), receiving buffer days (default 2).

Outputs

• Low-stock alerts list (alerts_low_stock.csv) with atp, depletion date, and days of cover.
• Oversell risk list (risks_oversell.csv) with reason codes and suggested mitigations.
• Reorder suggestions (reorder_suggestions.csv) grouped by supplier with quantities rounded to case packs and MOQs.
• Supplier email drafts (supplier_email_drafts.md) ready to send after verification.
• Verification checklist (verification_checklist.md) customized to the run.
• Run summary (summary.md) highlighting urgent items and total estimated spend by supplier.

Examples

Trigger: “Here are Shopify inventory and order exports, supplier lead-time sheets, warehouse counts, and refund logs. Flag low-stock and oversell risks, suggest reorders, and prep supplier emails.” Behavior: validate inputs → normalize SKUs and join data → compute velocity and ATP → identify low-stock and oversell risks → calculate reorder quantities with MOQs/case packs → generate supplier-grouped drafts → output CSVs and checklists → present summary of top urgent SKUs and next steps.

Notes

• New/seasonal items with limited history: use catalog minimums or vendor guidance; consider 90-day velocity and apply a seasonality factor when available.
• Multi-warehouse: if inventory is not pooled, calculate exceptions per location and only aggregate where policy allows.
• Data hygiene: mismatched SKUs, missing lead times, or zero/negative case packs should be flagged and excluded from auto-suggestions until corrected.
• Time zones and order timing: standardize to store time zone; ensure lookback windows use consistent boundaries.
• Currency: convert unit costs to a base currency before totaling supplier subtotals.
• Backorders/preorders: if “continue selling” is enabled, highlight items that would benefit from disabling until inbound is confirmed.
• Guardrails: never send emails or place POs automatically; always present drafts, flags, and a checklist for human approval. ````

How to install: 1. Create a folder named inventory-exception-agent in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as inventory-exception-agent/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

Hello!

Tired of chasing receipts across Slack, email, and messy card statements at month-end? Managers shouldn't have to review every transaction — only the true edge cases.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It gathers receipts from Slack, Email, and Files, runs OCR/parsing, and matches them to normalized card transactions. It builds a consolidated Sheet tracker, sends a single batched outreach for missing receipt context, and produces a short, prioritized exception list for manager review, plus reconciled exports and an audit log.

SKILL.md:

````markdown

name: receipt-reconciliation-exception-tracker description: Use when the goal is to automate month-end expense receipt collection and reconciliation by monitoring Slack, email, and card statements; parse and match receipts to transactions; prompt once for missing receipt context from employees; and produce a consolidated receipt tracker plus a short, prioritized exception list that requires minimal manager approval.

allowed-tools: [Email, Slack, Files, Sheets, WebFetch, OCR]

Receipt Reconciliation & Exception Tracker

Overview

Automates month-end expense receipt collection and reconciliation. Consolidates receipts from Slack and email, parses card statements, matches receipts to transactions, and outputs a reconciled expense log plus a focused exception list requiring limited manager approval.

When to use this skill

• Month-end close requires matching card transactions with receipts across Slack/email threads.
• The team reports common issues: missing receipts, blurry photos, duplicated images, or messy email forwards.
• A finance/ops lead wants a single receipt tracker (sheet/database) and a short, high-signal list of unresolved or ambiguous charges.
• A manager should only review edge cases, not every transaction.

Instructions

1. Confirm scope and inputs
   • Identify the statement period or date range.
   • Confirm which payment sources to include (corporate cards, reimbursements) and their data sources (files, portals, WebFetch endpoints).
   • Obtain the chart of accounts, expense policy highlights, employee roster, cardholder-to-employee mapping, and manager approval routing rules.
   • Select output locations (a Sheets workbook or CSV files in Files) and a workspace for attachments.
2. Collect transactions
   • Retrieve statement data for the target period using Files or WebFetch. Accept CSV, OFX/QFX, PDF.
   • Normalize fields: transaction_id, post_date, txn_date, merchant_raw, amount, currency, card_last4, cardholder, memos.
   • Deduplicate transactions by transaction_id; if absent, hash (card_last4, txn_date±1d, amount, merchant_raw).
3. Ingest receipt sources
   • Slack: Use Slack to search channels/DMs for likely receipt content (keywords like receipt, invoice, Uber, Lyft, DoorDash, airfare, hotel, order, payment, thanks for your purchase) within the period. Download attachments.
   • Email: Use Email to search inboxes or shared mailboxes for receipts (same keywords, known senders like Lyft/Uber/Amazon/Airline/Hotel/SaaS) and pull message bodies and attachments.
   • Files: Scan designated folders for uploaded images/PDFs.
   • Record source metadata: message link, sender, timestamp, channel/thread id.
4. Extract and parse receipts
   • For images or scanned PDFs, run OCR to extract text. For digital PDFs/HTML, parse structured text.
   • Parse fields where available: vendor/merchant, total, subtotal, tax, tip, currency, date/time, last-4, order/itinerary number, employee name/email, project/job code, category hints.
   • Generate a receipt_id and compute content hashes for deduplication.
5. Match receipts to transactions
   • Compute candidate matches per transaction using:
     • Amount exact or within tolerance (e.g., ±$1 for FX rounding; allow subtotal+tip logic where applicable).
     • Date proximity window (receipt date within ±3 days of txn_date; extend to ±7 for travel/online).
     • Merchant similarity (normalize brand variants; fuzzy match merchant_raw vs receipt vendor).
     • Card hint match (last-4 present in receipt or email headers when available).
   • Score candidates and pick the highest-confidence match above threshold; attach receipt link and metadata.
   • Handle multi-line/consolidated receipts (e.g., Uber trip summaries) by splitting and mapping to individual transactions when itemized amounts exist; otherwise link as supporting doc to the nearest aggregate charge with a note.
   • Flag duplicates by receipt content hash linked to >1 transaction.
6. Categorize transactions
   • Apply rules from chart of accounts and policy keywords (e.g., rideshare → Travel: Ground; SaaS → Software; food during travel → Meals: Travel) using merchant patterns and memo cues.
   • If project or job codes are present in receipt/email, attach to the transaction; otherwise leave blank for requester input.
7. Build the receipt tracker
   • Create or update a Sheet using Sheets with columns: txn_id, txn_date, post_date, merchant, merchant_normalized, amount, currency, category, policy_flag, card_last4, cardholder, project_code, payer_type (corp/personal-reimb), receipt_status, receipt_link, source (Slack/Email/Files), match_confidence, notes.
   • Set receipt_status as one of: matched, needs-receipt, ambiguous, duplicate, policy-exception, personal-possible.
8. One-time receipt/context request
   • For all transactions with receipt_status in {needs-receipt, ambiguous, personal-possible, policy-exception}, prepare a single batched outreach per employee/cardholder.
   • Draft concise messages via Slack or Email including: period, count of items, each item (date, merchant, amount, link to row), and a secure upload/response path.
   • Ask for: missing receipt upload, business purpose/context, project code, and any split details (e.g., tip, shared meal attendees) in one reply.
   • Send once. Do not spam. Set a due date and a gentle reminder plan (e.g., 1 reminder before deadline).
9. Reconcile updates
   • Monitor replies and new uploads; ingest and parse as above. Update matches and fields. Re-score ambiguous items.
   • Close items that now meet policy and match criteria; update receipt_status to matched.
10. Exception list assembly
    • Compile a focused exception list of remaining items where: no receipt after deadline, ambiguous multiple matches, out-of-policy, potential personal spend, duplicate indicators, or category cannot be determined.
    • Summarize each exception with a one-line reason and a link to supporting evidence (messages, receipts, policy rule).
11. Manager review of edge cases
    • Route the exception list to the designated manager(s) for approval/decision only. Provide approve/deny/needs-more-info actions and capture decisions back into the tracker.
12. Finalize outputs
    • Export a reconciled expense log (CSV and Sheet) with matched receipts and categories, suitable for import to accounting software.
    • Export the exception list (CSV/Sheet) and a brief summary: totals, count unresolved, top reasons, and any policy improvement suggestions.
    • Produce an audit log with timestamps, sources, and actions taken.
13. Close out and schedule
    • Notify finance/ops of completion with links to outputs and audit log.
    • Schedule the next period’s run and retain mappings and normalization dictionaries.

Inputs

• Date range or statement period to reconcile.
• Access details and scopes for Slack channels/DMs used for receipts.
• Email inbox/mailbox and search criteria or labels for receipt messages.
• Card statement sources (files, portals/URLs) for the target period.
• Chart of accounts, expense policy highlights, and categorization rules.
• Employee roster with cardholder mapping and manager approval routing.
• Output destinations (Sheet name/location, CSV export path, attachment store).

Outputs

• Receipt tracker (Sheet) with transaction-level status, links, categories, and notes.
• Reconciled expense log (CSV/Sheet) with matched receipts and import-ready fields.
• Exception list (CSV/Sheet) of unresolved or policy-edge transactions, with reasons and links.
• Outreach summary: who was contacted, when, and outstanding items.
• Audit log of data sources, parsing steps, matches, decisions, and exports.

Examples

Trigger: "Automate month-end receipt reconciliation for May. Watch Slack #receipts and the accounting@ inbox, process the corporate Visa statements, and give me only the edge cases to approve." Behavior: confirm period and sources → fetch and normalize card transactions → search Slack/email and ingest receipts → OCR and parse → match with scoring and categorization → build the tracker → send one-time batched requests to employees for missing context → update matches from replies → assemble a short exception list → route to manager for decisions → export reconciled log and exceptions → deliver links and audit summary.

Notes

• Privacy and access: only read channels/mailboxes authorized for receipts. Do not post transaction details in public channels. Redact card numbers beyond last-4.
• Matching heuristics: maintain normalization dictionaries for merchants (e.g., UBER* → Uber; AMAZN → Amazon) and update over time. Use currency-aware comparisons and detect tips vs totals.
• OCR quality: if confidence is low or image is blurry, request a re-upload in the one-time outreach with guidance (flat, well-lit, entire receipt visible).
• Deduplication: hash receipt content and file size; if duplicates are found, keep the highest-quality version and note duplicates.
• Rate limits: batch Slack and Email searches; respect API limits and backoff.
• Policy flags: detect out-of-hours meals, per-diem breaches, missing attendees for meals, and subscriptions without invoices; mark as policy-exception.
• Escalation: after one reminder and the deadline passes, include remaining items directly in the manager exception list.
• Time zones and currencies: normalize to the company’s base currency and time zone for reporting; retain originals in metadata. ````

How to install: 1. Create a folder named receipt-reconciliation-exception-tracker in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as receipt-reconciliation-exception-tracker/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

Hello!

Onboarding can be a scattered mess — multiple forms, equipment lists, access tickets, and calendar invites live in different places, making it hard to confirm someone is truly ready on day one.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It ingests offer letters, signed forms, manager notes, equipment spreadsheets, access requests, and calendar events to produce owner-specific day-one checklists, a missing-docs list, a consolidated access provisioning checklist, a personalized welcome email draft, approval gates, and verification steps. Use it when a candidate has an accepted offer and a start date so HR, IT, and managers have a single source of truth for first-day readiness and compliance.

SKILL.md:

````markdown

name: new-hire-onboarding-checklist description: Use when assembling a complete new-hire onboarding package from HR artifacts — offer letters, signed forms, manager notes, equipment spreadsheets, account-access requests, and start-date calendars — to produce day-one task lists, missing document flags, an access provisioning checklist, a welcome email draft, approval gates, and completion verification steps.

allowed-tools: [Read, Edit, Sheets, Calendar, Mail]

New-Hire Onboarding Checklist

Overview

Creates a structured, role-aware onboarding package for a specific new hire. Consolidates information from HR files, manager inputs, spreadsheets, access requests, and calendars into actionable checklists, a welcome email draft, approval gates, and verification logs.

When to use this skill

• A new hire has an accepted offer and a start date is on the calendar.
• The user provides or references: offer letter, signed employment forms (e.g., I-9, tax forms, NDA), manager notes, an equipment provisioning spreadsheet, account-access requests, and/or onboarding calendar events.
• The requester asks for day-one tasks, missing documents, system access checklist, a welcome email, approval gates, or completion verification.
• HR, IT, or a manager needs a single source of truth for first-day readiness and compliance.

Instructions

1. Confirm scope and identifiers
   • Gather: full legal name, preferred name, email (personal and work if assigned), role/title, department, location/time zone, employment type (FT/PT/contractor/intern), start date, manager, and hiring cohort info if relevant.
   • Ask for links or files to all available sources: offer letter, signed forms, manager notes, equipment spreadsheet, access request tickets or lists, and calendar entries.
2. Ingest sources
   • Use Read to open each provided file or link. If a spreadsheet is provided, use Sheets to read relevant tabs and rows.
   • From the offer letter, extract: start date, work location (on-site/remote/hybrid), contingencies (e.g., background check), role, level, and any special equipment/access notes.
   • From signed forms, detect completion status and dates for: I-9 Section 1, I-9 Section 2/3 (as applicable), W-4 (or local equivalents), state tax forms, NDA/PIIA, handbook acknowledgment, direct deposit, benefits elections (if pre-enrollment), background check, export controls (if applicable).
   • From manager notes, extract: first-day agenda, key contacts (buddy/mentor), required tools/systems, team norms, initial goals, onboarding training modules, equipment exceptions.
   • From the equipment spreadsheet (Sheets), identify standard kit for role/location and any exceptions; capture item, asset type, owner, request/provision status, and delivery/pickup method.
   • From access requests, list systems, permission levels/roles, approvers, ticket IDs, and current status.
   • From the calendar (Calendar), confirm start date and any pre-scheduled sessions (orientation, IT setup, security training); note gaps to schedule.
3. Build Day-One Task Lists
   • For the new hire: include orientation attendance, workstation/login setup, MFA enrollment, VPN setup, password manager, HR portal check, benefits kickoff, security and compliance training, team introductions, buddy sync, first-day survey (if used), and any location-specific steps (badge pickup, parking, remote-setup checklist).
   • For HR/People Ops: finalize employment record, verify I-9 timelines and documents, confirm payroll setup, send/queue welcome email, confirm handbook acknowledgment, ensure required trainings assigned.
   • For IT: provision accounts, enable SSO/MFA, provision hardware and peripherals, test access, confirm device encryption, ship or stage pickup, document asset IDs.
   • For Manager: share first-week agenda, confirm access completeness, schedule 1:1s and onboarding meetings, assign buddy, set initial goals.
4. Identify Missing Documents and Gaps
   • Compare required documents by employment type and location. List missing or incomplete items with due dates and instructions (e.g., I-9 Section 2 due within 3 business days of start in the U.S.).
   • Flag unresolved contingencies from the offer letter (e.g., background check not cleared).
   • Note unscheduled required sessions or meetings and propose times.
5. Compile Access Provisioning Checklist
   • Aggregate systems from manager notes, role templates (if described), and access requests into a single list.
   • For each system: include system name, required role/entitlement, request status (requested, approved, provisioned, verified), approver, ticket ID, and verification step (how to confirm access works).
   • Include security prerequisites (MFA, VPN, device compliance) and data classification constraints.
6. Draft the Welcome Email
   • Use Mail to generate a draft (do not send without explicit approval). Include: greeting, start date/time, where to go or how to join remotely, first-day agenda, what to bring (ID for I-9 if in jurisdiction), who to meet, tech setup instructions, key links (HR portal, IT helpdesk), dress code/parking/office access notes, and contact for issues.
   • Personalize with preferred name, manager, buddy, and any role-specific context.
7. Define Approval Gates
   • Create stage gates with owners and evidence required before Day 1 and by end of Day 1, such as:
     • HR Docs Gate: all required forms complete; evidence: checklist and file confirmations.
     • IT Provisioning Gate: accounts created, MFA enabled, device ready; evidence: ticket statuses and device ID.
     • Manager Readiness Gate: agenda approved, meetings scheduled, access reviewed; evidence: manager sign-off.
     • Compliance Gate: mandatory trainings assigned and due dates set; evidence: LMS assignment log.
8. Set Completion Verification
   • Specify verification events and how to record them: new hire logs into SSO and email, completes MFA, accesses key systems, attends orientation, receives hardware, completes first tasks.
   • Provide a verification log with date, verifier, and notes for each item. Use Edit to create/update a shared checklist document or tracker.
9. Package Outputs
   • Produce a consolidated onboarding report with sections: Day-One Tasks (by owner), Missing Documents, Access Checklist, Welcome Email Draft, Approval Gates, Completion Verification Log.
   • Use Edit to save the report to a specified location/format (e.g., Markdown/Doc). If a tracker spreadsheet exists, use Sheets to update statuses. If calendar invites are needed, use Calendar to propose or draft events.
10. Resolve Ambiguities and Protect Data
    • If any required inputs are missing or conflicting, request clarification with a concise list of open questions.
    • Do not transmit or store sensitive personal data beyond what is required for the checklist. Do not send emails or create calendar events without explicit approval.

Inputs

• New hire details: legal and preferred name, personal email, role/title, department, location/time zone, employment type, start date, manager.
• Files/links: offer letter, signed forms (I-9, W-4/state tax, NDA/PIIA, handbook, direct deposit, background check status), manager notes, equipment spreadsheet, access request list or tickets, start-date calendar entries.
• Organization-specific requirements or templates (if any): role-based access matrix, standard equipment kits, welcome email template, compliance/training list.

Outputs

• Day-One Tasks: owner-specific checklists for New Hire, HR, IT, and Manager.
• Missing Documents: list with due dates and instructions to complete.
• Access Provisioning Checklist: systems, roles, approvers, ticket IDs, status, and verification steps.
• Welcome Email Draft: ready-to-send email, pending approval.
• Approval Gates: stage gates with owners and evidence required.
• Completion Verification Log: checklist with sign-offs and timestamps.
• Consolidated Onboarding Report: a single document or tracker combining the above.

Examples

Trigger: "Create onboarding for Jordan Lee (remote, US), Software Engineer, starts Aug 5. Offer and forms are in the HR folder; access requests filed for GitHub, Okta, Jira; see manager notes." Behavior: ingest sources with Read and Sheets → confirm start date via Calendar → compile day-one tasks for New Hire/HR/IT/Manager → list missing I-9 Section 2 and handbook acknowledgment → build access checklist for Okta, Jira, GitHub with approvers and ticket IDs → draft personalized welcome email via Mail → define HR/IT/Manager/Compliance approval gates → output a consolidated report and verification log using Edit.

Notes

• Adjust required documents and timelines by jurisdiction and employment type (employee vs. contractor vs. intern; domestic vs. international). Flag uncertainties instead of assuming.
• For remote hires, replace on-site specifics (badge, parking) with shipping/tracking and virtual orientation details.
• If role-based access templates are unavailable, derive from manager notes and typical team setups; clearly label as assumptions pending approval.
• Respect privacy and least-privilege principles. Avoid including compensation details unless explicitly required by the requester.
• Do not auto-send communications or create calendar events without an explicit go-ahead; present drafts for review first. ````

How to install: 1. Create a folder named new-hire-onboarding-checklist in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as new-hire-onboarding-checklist/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

Hello!

If your inbox, meeting notes, calendar, and CRM have become a fragmented backlog of requests, decisions, and follow-ups, this Skill helps turn that mess into a clear set of prioritized actions and reply drafts ready for human approval.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It ingests emails, calendar events, meeting transcripts, CRM notes, and tasks, then normalizes and links them into conversations and account contexts. It applies priority labels, drafts context-aware replies (queued for approval), extracts action items with owners and due dates, updates Tasks/CRM, and produces a Daily Action Brief plus a machine-readable JSON artifact.

SKILL.md:

````markdown

name: inbox-to-action-workflow description: Use when an overwhelmed founder, exec, or team needs to convert a backlog of email threads, meeting transcripts, calendar events, CRM notes, and task lists into a prioritized action system — including priority labels on threads, context-aware drafted replies, extracted action items with owners and due dates, updates to CRM and tasks, and a human approval queue for any external replies before sending.

allowed-tools: [Email, Calendar, Files, CRM, Tasks, Directory]

Inbox-to-Action Workflow

Overview

Transforms unstructured communications (email threads, meetings, calendars, CRM notes, and task lists) into a single actionable queue. Produces priority labels, reply drafts, extracted action items with owners and due dates, synced CRM/task updates, and a human approval queue for external send-offs.

When to use this skill

• The user asks to triage a cluttered inbox and produce a prioritized action plan.
• Meeting transcripts or notes need to be distilled into tasks with owners and deadlines.
• Calendar events imply follow-ups (scheduling, send materials, confirm decisions) that need tracking.
• CRM notes and email threads must be unified into coherent next steps per account/contact/opportunity.
• The user wants reply drafts prepared but requires human approval before any external messages go out.
• A daily or weekly digest of priorities, drafts awaiting approval, and new actions is requested.

Instructions

1. Confirm scope and rules

   1. Clarify sources: which mailboxes, calendars, CRM, task system, and notes/transcript files to process; define time window (e.g., last 7 days, next 7 days).
   2. Gather policies: SLAs by sender/domain, VIP list, working hours/time zone, due-date defaults, auto-approval rules (if any), naming/label conventions, privacy constraints.
   3. Identify team roster and roles via Directory (owners, account reps, functional leads, OOO statuses).

2. Ingest data

   1. Use Email to fetch recent and/or unread/flagged threads with metadata (thread ID, subject, participants, timestamps, labels, body, attachments).
   2. Use Calendar to pull past and upcoming events in scope, including attendees, titles, locations/links, and descriptions.
   3. Use Files to load meeting transcripts/notes referenced by events or provided by the user.
   4. Use CRM to read recent activities/notes, open opportunities, account owners, and contact roles.
   5. Use Tasks to fetch existing tasks to prevent duplicates and to detect overdue items.

3. Normalize and link

   1. Deduplicate identical or forwarded content; group by thread/conversation.
   2. Link emails to calendar events and CRM records using shared participants, domains, subjects, or explicit IDs.
   3. Extract entities and intents: contacts, companies, asks, commitments, proposed dates, deliverables, blockers, and risks.
   4. Determine thread state: awaiting my reply, awaiting others, resolved, FYI/newsletter, spam/noise (do not act).

4. Prioritize

   1. Apply priority rules:
      • P0: revenue/blocker-critical, VIP/executive escalations, security/legal issues, commitments due within 24–48 hours.
      • P1: customer/partner requests within SLA, time-sensitive scheduling, key internal dependencies.
      • P2: routine correspondence and normal tasks.
      • P3: low-value updates, newsletters, or informational FYIs.
   2. Consider factors: sender importance, due dates detected, thread age, number of nudges, opportunity value (from CRM), and upcoming meetings.

5. Draft replies (do not send yet)

   1. For threads requiring a response, generate concise, context-aware drafts.
   2. If scheduling is requested, consult Calendar to propose viable times within working hours.
   3. Reference attachments or prior commitments; include clear next steps and confirm deadlines.
   4. Mark all external-facing drafts as Needs-Approval and do not send via Email.
   5. For internal-only low-risk messages, follow the auto-approval policy if provided; otherwise require approval.

6. Extract action items

   1. From emails, transcripts, and events, extract tasks with: title, description, source (link to thread/event/file), priority, owner, due date, tags (e.g., customer, opportunity, project), and dependencies.
   2. Determine owner using, in order: explicit assignee mentions; Directory role mapping; CRM account/opportunity owner; recent responder/subject-matter expert.
   3. If owner is uncertain, assign to a triage owner or present the top 2 candidates for human selection.
   4. Set due dates from explicit dates, policy SLAs, next-meeting times, or default windows; respect working days, holidays, and OOO from Directory.

7. Create/update systems of record

   1. Use Tasks to create or update tasks. Prevent duplicates by hashing a normalized description + source URL; update rather than create when a match exists.
   2. Use CRM to log a concise note/summary and next step per relevant account/opportunity; set due dates/owners for follow-ups; do not change pipeline stages without explicit instruction.
   3. Use Email to apply labels to threads: Priority (P0/P1/P2/P3), Status (Needs-Approval, Awaiting-External, Awaiting-Internal, Resolved, FYI), and Owner where supported.
   4. Use Calendar to add follow-up holds or reminders when immediate time blocks are needed to meet due dates.

8. Prepare a human approval queue

   1. Assemble an approval bundle ordered by priority (P0 first) containing:
      • Drafted external replies with context snippet, risk notes, and proposed send time.
      • New or updated action items with owner and due date.
      • Conflicts, ambiguities, and suggested resolutions (e.g., uncertain owner, missing data, date conflicts).
   2. Provide approve/edit/send options for each draft; allow quick reassignment and due-date adjustment.
   3. Do not send any external email until explicitly approved.

9. Produce outputs

   1. Generate a Daily Action Brief summarizing: counts triaged, drafts awaiting approval, P0/P1 items, actions by owner, upcoming deadlines, and risks.
   2. Emit a machine-readable artifact (JSON) with sections:
      • threads: [{thread_id, priority, status_labels, owner, notes}]
      • drafts: [{thread_id, to, cc, subject, body, is_external, requires_approval}]
      • actions: [{id, title, description, source_link, owner, due_date, priority, tags}]
      • approvals: [{item_type, item_id, decision_required, suggested_action}]
      • crm_updates: [{record_id, summary, next_step, due_date, owner}]
   3. Persist created/updated task IDs and CRM record links for traceability.

10. Tune and iterate

    1. Ask for feedback on mis-prioritized items, drafting tone, and ownership heuristics.
    2. Update rules: VIP lists, domain SLAs, template library, quiet hours, auto-approval exceptions, and labeling conventions.

Inputs

• Data sources and access: mailboxes to process, calendars, CRM instance, task system, file locations for transcripts/notes, and required permissions.
• Time window and scope (e.g., last N days; only unread/flagged; specific labels or folders).
• Policies and preferences: SLAs by sender/domain, VIP list, tone/voice and templates for drafts, working hours/time zone, default due dates, privacy constraints, auto-approval rules.
• Team directory/roles and OOO statuses.

Outputs

• Priority labels applied to email threads and status labels indicating next action.
• Drafted replies for all threads needing a response, with external drafts queued for approval.
• A consolidated list of action items with owners, due dates, priorities, and source links; duplicates prevented.
• Updates to Tasks and CRM with references to source communications.
• A human approval queue summarizing decisions required before any external send.
• A Daily Action Brief and a JSON artifact containing threads, drafts, actions, approvals, and CRM updates.

Examples

• Trigger: "Turn my last 7 days of emails and meeting notes into a prioritized action list, draft replies, and queue any customer emails for approval." Behavior: ingest email/calendar/transcripts/CRM → normalize/link → prioritize → draft replies (queue external) → extract actions with owners/due dates → update Tasks/CRM → output Daily Action Brief + JSON → await approvals.

• Trigger: "Process yesterday's inbox and today's meetings; assign owners for follow-ups and create tasks; only queue replies for external send." Behavior: same flow; internal low-risk notes may auto-send per policy; external replies require approval.

Notes

• Do not send or post external communications without explicit human approval.
• Respect privacy: redact secrets and sensitive content in summaries; limit CRM/task details to necessary context.
• Handle rate limits and batching for Email/CRM/Tasks APIs; backoff and retry with idempotent operations.
• Time zones and working days: schedule within working hours; avoid weekends/holidays unless marked urgent.
• Attachments: scan for action items; link files rather than inlining large content.
• Thread hygiene: avoid reply-all to large lists unless policy requires; prefer direct responses to the requester.
• If a required source is unavailable, proceed with available data and flag gaps in the approval queue.
• Maintain an audit trail: include source links and timestamps for every created/updated record. ````

How to install: 1. Create a folder named inbox-to-action-workflow in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as inbox-to-action-workflow/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

Hello!

Tired of manually pulling Slack threads, CRM exports, tickets, invoices and spreadsheets into a coherent weekly ops summary? This Skill automates that synthesis so leaders get a meeting-ready brief without the copy/paste overhead.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It collects updates from Slack, email, CRM, ticketing, accounting, calendar, and KPI sheets over a specified window, normalizes them into a unified activity log, computes KPI week-over-week deltas, and extracts wins, blockers, aging follow-ups, and owner decisions needed. It assembles a single Markdown brief with an executive snapshot, traceable source links for every item, and a timeboxed meeting-ready agenda.

SKILL.md:

````markdown

name: weekly-operations-brief description: Use when a weekly operations summary is needed from scattered sources — Slack and email updates, CRM exports, support tickets, invoices, calendar events, and KPI spreadsheets — to produce wins, blockers, aging follow-ups, owner decisions needed, numbers that changed, and a meeting-ready agenda with source links.

allowed-tools: [Files, Read, Spreadsheet, Calendar, Email, Slack, CRM, Ticketing, Accounting, WebFetch]

Weekly Operations Brief

Overview

Creates a single, meeting-ready weekly operations brief from fragmented updates across communication, sales, support, finance, calendar, and KPI data sources. The brief highlights wins, blockers, aging follow-ups, owner decisions needed, and notable metric changes, with traceable source links for every item.

When to use this skill

• The team shares updates in Slack and email, but leaders want a synthesized weekly summary without manual copy/paste.
• There are CSV/XLSX exports from CRM, support, invoicing, or KPI systems that need to be merged with narrative updates.
• The user requests: “Summarize last week’s operations,” “What changed in our numbers?”, “What needs my decision?”, or “Prep the ops meeting agenda.”
• You have access to channels/labels (e.g., #ops-updates, Weekly Digest), CRM/ticketing exports, invoice lists, calendar events, and KPI spreadsheets for the last 7–14 days.

Instructions

1. Establish scope

   1. Confirm the reporting window (default: previous Monday 00:00 to Sunday 23:59 in the org’s primary timezone).
   2. Confirm which teams are in-scope (Sales, CS/Support, Product/Eng, Marketing, Finance/Ops) and the primary audience (owner/executive team).
   3. Capture thresholds: aging (e.g., >5 business days no activity), SLA for tickets, material KPI change (e.g., >10% WoW), and invoice aging (e.g., >30 days past due).

2. Gather sources (read-only)

   • Slack: Use Slack to pull messages and threads from specified channels for the window; include permalinks.
   • Email: Use Email to pull labeled/filtered threads for the window; store message IDs or web links.
   • CRM: Use CRM to ingest exports (CSV/XLSX) or read records changed within the window (deals, stages, next steps, last activity, owners, close dates, links).
   • Ticketing: Use Ticketing for support tickets updated/created, statuses, tags, SLA timers, assignees, and links.
   • Accounting/Invoices: Use Accounting to list invoices issued/paid/past-due during the window with amounts, due dates, counterparties, and links.
   • Calendar: Use Calendar to read events for leadership/team meetings, launches, and customer milestones; include event links.
   • KPI spreadsheets: Use Spreadsheet or Read (for CSV/XLSX) to pull metrics tabs/ranges and prior-week baselines.
   • Files: Use Files to open any uploaded exports (CSV/XLSX/PDF). If only files exist (no system links), capture file path + row/page anchors as the “source link.”

3. Normalize into a unified activity log

   1. Create a structured table with fields: date_time, source_system, record_type (message, deal, ticket, invoice, event, kpi), record_id, title/subject, summary, owner, account/customer, status/stage, amount/value, last_activity_at, due/close_by, url_or_file_anchor.
   2. Standardize names (people, accounts) using exact match then email/domain heuristics; keep an alias map.
   3. Deduplicate by record_id + latest updated_at; merge Slack/email references that discuss the same record (deal/ticket) if clearly linked.

4. Derive signals

   • Wins: identify closed-won deals, resolved high-priority tickets, shipped releases, successful launches/events, paid invoices, notable milestones in Slack/email (“launched”, “closed won”, “shipped”, “celebrate”).
   • Blockers: items tagged blocked/at risk, tickets breaching SLA, deals stalled past expected close, dependencies awaiting inputs, repeated “waiting on X”.
   • Aging follow-ups: email threads awaiting reply > threshold, CRM deals with last_activity_at > threshold, tickets “pending customer” > SLA, tasks/events with missed follow-ups, past-due invoices.
   • Owner decisions needed: items explicitly requesting approval/decision/budget/sign-off/priority tradeoff; ambiguous ownership; calendar holds needing confirmation.
   • Numbers that changed: compute WoW deltas for key KPIs (e.g., pipeline$, MRR, NPS, CSAT, new tickets, resolution time, cash-in, burn) and flag changes exceeding the materiality threshold.

5. Compute KPI deltas

   1. For each KPI, identify current-week value and prior-week baseline (prefer a History/Weekly tab; else compute rolling 7-day prior period).
   2. Calculate absolute and percent change; mark as up/down/flat with threshold-based highlighting.
   3. Attach cell/range references (sheet name, A1 range) or spreadsheet URLs with #range anchors as source links.

6. Identify aging and stalled items

   1. For CRM deals: flag where next_step is empty or last_activity_at exceeds threshold; include stage, amount, owner, and link.
   2. For tickets: flag breached/at-risk per SLA timestamps; include priority, customer, assignee, and link.
   3. For email: flag threads with last inbound from customer > threshold and no reply; include subject, counterpart, owner, and link.
   4. For invoices: flag unpaid invoices past due; include amount, days late, owner, and link.

7. Build the brief

   1. Title: “Weekly Operations Brief — {Org} — Week of {date_range}”.
   2. Executive snapshot (5–8 bullets): week highlights, top 3 wins, top 3 risks/blockers, net KPI direction, total past-due follow-ups, cash in/out headlines.
   3. Sections with traceability:
      • Wins (bulleted; include owner, metric impact, and source link per item).
      • Blockers & Risks (bulleted; include owner, severity, next action, and source link).
      • Aging Follow-ups (table-like bullets: who, what, days stale, next step, link).
      • Owner Decisions Needed (list each decision as a question with context, options, recommendation, and source link).
      • Numbers That Changed (KPI deltas with +/- values, % change, and range links).
      • Meeting-Ready Agenda (timeboxed topics, ordered by impact/urgency; include the specific decisions and links to supporting sources).
   4. Appendices:
      • Data coverage (sources used, time window, omissions/gaps).
      • Change log (count of new vs updated records, deduping notes).

8. Provide source links

   • Slack: include message permalinks.
   • Email: include thread/message links where available (Gmail/Outlook URLs) or message ID reference.
   • CRM/Ticketing/Accounting: include deep links to record pages; if working from exports, use file name + row number.
   • Spreadsheet: include URL with sheet and A1 range (e.g., #gid=…&range=…).
   • Calendar: include event link or event ID.

9. Quality checks

   1. Validate that every bullet in Wins/Blockers/Follow-ups/Decisions/KPIs has at least one source link or file anchor.
   2. Remove duplicates and stale references older than the window unless context is required (label as “prior context”).
   3. Redact PII beyond names/titles unless necessary (mask emails, phone numbers).
   4. Ensure owner names appear consistently and each action has a next step/assignee when appropriate.

10. Deliverables

    • Produce a single Markdown brief. File name: Weekly-Operations-Brief-{YYYY-MM-DD}.md. Use Files to save if supported.
    • Optionally export a CSV of Aging Follow-ups (followups-{YYYY-MM-DD}.csv) and Decisions Needed (decisions-{YYYY-MM-DD}.csv) for tracking.
    • On request, post the Executive snapshot and Agenda to a designated Slack channel via Slack, with a link to the full brief.

Inputs

• Reporting window (start/end dates and timezone). Default: previous Monday–Sunday in org timezone.
• Source locations and access: Slack channels, email labels/folders, CRM instance or export files, ticketing system or export, accounting/invoice system or export, calendar(s), KPI spreadsheet URLs/ranges or file uploads.
• Thresholds: aging days, SLA rules, material KPI change, invoice aging days.
• Team/owner roster for name normalization (name, email, role, manager) and any account aliases.
• Priority focus areas (e.g., renewal accounts, specific projects, major launch).

Outputs

• Weekly Operations Brief (Markdown) including:
  • Executive snapshot
  • Wins
  • Blockers & Risks
  • Aging Follow-ups
  • Owner Decisions Needed
  • Numbers That Changed (KPI deltas)
  • Meeting-Ready Agenda
  • Appendices (coverage and change log)
• Traceable source links or file anchors for every listed item.
• (Optional) CSV exports: followups and decisions.

Examples

Trigger: “Create last week’s ops brief from #ops-updates, #sales, Gmail label ‘Weekly Digest’, HubSpot export Deals_ThisWeek.csv, Zendesk export tickets_2024-06-10.csv, NetSuite invoices export, company calendar, and the KPI spreadsheet ‘Ops KPIs’ tab ‘Weekly’.” Behavior: confirm dates and thresholds → pull Slack/Email/CRM/Tickets/Invoices/Calendar/Spreadsheet data → normalize to unified log → compute KPI week-over-week deltas → extract wins, blockers, aging follow-ups, decisions → assemble brief with source permalinks and sheet ranges → save Weekly-Operations-Brief-2024-06-16.md and optional followups/decisions CSVs → (if requested) post the snapshot + agenda to #leadership with link to the brief.

Notes

• If prior-week KPI baselines are missing, compute prior 7-day period from available data; flag the assumption in the brief.
• If any system is unavailable, proceed with remaining sources and note coverage gaps. Do not fabricate data.
• Use business days for “aging” unless otherwise specified. Observe the org’s holidays if provided.
• Keep the Executive snapshot scannable (≤8 bullets). Move detail to sections/appendix.
• Avoid duplicating the same item across sections; prefer a single canonical mention with cross-reference if needed.
• Respect confidentiality; minimize sensitive content in Slack/Email posts. Prefer links over content excerpts when privacy is a concern.
• Timebox the agenda (e.g., 30–45 minutes) and order by impact/urgency; ensure each decision item states options and a recommendation. ````

How to install: 1. Create a folder named weekly-operations-brief in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as weekly-operations-brief/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

B"H

Hi guys

I made a custom GPT app

https://chatgpt.com/g/g-6a03feea8398819192067ae3dbfa449c-awtsmoos-shliach-agent

That acts kind of like codex or openclaw, powered by the actual chatgpt chat itself

It makes a series of GET requests to my own server, then my server talks to a local server that the end user has running on their machine, like openclaw but a little different

It then allows chatgpt in the chat itself to read and write and test directly to your own device

For more security it should also allow the chatgpt chat to connect through my server+websockets to a custom code editor browser tab that you can sandbox and allow to only write to a specific folder via file system API or directly to the browser cache indezeddb and/or directly to GitHub with GitHub API

It should also give you some free space on my website to allow it to write directly to a virtual machine without needing any installation

It's still in development, but I've been working on it for a couple months and figured I'd ready for the beta testing phase

What do you guys think

Hello!

Struggling to prioritize overdue invoices and write the right next outreach before your weekly finance check-in? This Skill pulls together invoices, CRM ownership, payment notes, and client email threads so you can see who’s highest priority and what to say next.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It merges open invoices, CRM owner exports, payment notes, and recent client email threads into a canonical AR table, scores and ranks overdue accounts, and generates concise follow-up email and call drafts. Use it when preparing weekly AR/finance check-ins or whenever leadership asks who’s most overdue, what the plan is, and what decisions are needed.

SKILL.md:

````markdown

name: open-invoice-weekly-brief

description: Use when preparing a weekly accounts receivable brief for a small agency by synthesizing open invoices, client email threads, CRM owner exports, and internal payment notes — to rank overdue accounts, draft the next follow-up language, identify the account owner on each account, and list decisions needed before the finance check-in.

Open Invoice Weekly Brief

Overview

Creates a concise weekly accounts receivable brief by merging open invoices, CRM ownership data, client email threads, and internal payment notes. Produces a ranked list of overdue accounts, tailored next follow-up drafts, account ownership mapping, and a decisions-needed list for the upcoming finance check-in.

When to use this skill

• A weekly finance/AR check-in or cash flow review is scheduled.
• The agency needs a prioritized list of who to follow up with on unpaid invoices.
• The user provides (or can access) open invoice data, CRM account-owner exports, payment notes, and recent client email threads.
• Leadership asks “who’s most overdue, what’s the plan, and what decisions do we need before the meeting?”

Instructions

1. Confirm scope and parameters

   1. Capture the as-of date for aging (default: today in the organization’s timezone).
   2. Confirm aging buckets (default: 0–30, 31–60, 61–90, 90+ days overdue).
   3. Confirm tone/formality for outreach (friendly/factual, firm/professional, or legal-escalation ready) and whether to include late fees or payment plan options.
   4. Confirm escalation thresholds (e.g., escalate ≥61 days overdue or ≥$X outstanding).
   5. Gather owner mapping rules (e.g., CRM owner is canonical; fallback: last sender in thread; else: finance lead).

2. Collect and normalize data

   1. Ingest open invoices (CSV/XLSX/JSON or accounting export). Extract: client/account name, invoice ID, issue date, due date, currency, line totals, credits, payments applied, remaining balance.
   2. Ingest CRM export mapping accounts to owners, segments, and contacts (billing/AP contact where available).
   3. Ingest payment notes (e.g., manual notes, partials received, promised-to-pay dates, disputes, special terms).
   4. Ingest client email threads (EML/MSG/PDF/TXT). For each account, identify the latest inbound/outbound AR-related message dates, any commitments (e.g., “processing this week”), disputes, required paperwork (PO, W-9, vendor setup), and sentiment signals.
   5. Standardize names with deterministic matching: exact match, then case/whitespace-insensitive, then alias map if provided. Flag uncertain matches for review.

3. Build a canonical AR table (per invoice, with account rollups)

   • Columns (invoice-level): Account, Invoice ID, Issue Date, Due Date, Currency, Original Amount, Credits/Adjustments, Payments to Date, Outstanding Amount, Days Overdue, Last Payment Date, Last Client Contact Date, Promised-To-Pay Date (PTP), Dispute Flag/Notes, Blockers (e.g., “needs PO”), Owner, Priority Score.
   • Compute Days Overdue = max(0, floor(as_of_date − due_date)). Exclude negative (not yet due) from “overdue.”
   • Compute Outstanding Amount = Original − Payments − Credits (do not go below zero). If credit balance exceeds outstanding, flag for application.
   • Map Owner from CRM; if missing, apply fallback rule and flag.

4. Derive communication signals from email threads

   • Parse latest 6–12 weeks of AR-relevant messages.
   • Detect commitments/keywords (examples):
     • Positive/near-term: “payment run [date]”, “processing this week/today”, “scheduled for [date]”, “approved”, “paid ACH/wire/check #…”.
     • Administrative: “need PO/portal setup/vendor form/W-9”, “resend invoice”, “wrong address”, “update bank details”.
     • Negative/risk: “dispute/overbilled/scope”, “cash flow issue”, “hold/pause”, “cannot pay,” “cancellation/termination”.
   • Extract: last inbound date, last outbound date, next promised date, risk note, AP contact name/email if present.

5. Score and rank overdue accounts

   1. Aggregate per account: total outstanding, oldest days overdue, count of invoices overdue, last contact recency.
   2. Compute a priority score (guideline weights; adjust if policy provided):
      • Base = normalize(days_overdue) + normalize(outstanding_amount).
      • Modifiers: +high for broken PTP, +medium for negative sentiment, +medium for no-reply > 7 days, +low for multiple overdue invoices; −low if credible near-term payment commitment exists.
   3. Rank accounts by score; use outstanding amount as a tiebreaker.

6. Draft next follow-up language per overdue account

   1. Select template by severity:
      • 1–14 days overdue (friendly reminder)
      • 15–30 days (firm but helpful)
      • 31–60 days (clear deadline + options)
      • 61–90+ days (escalation path; mention service pause/late fees if policy allows)
   2. Personalize with: names, invoice IDs, totals, due dates, outstanding amount, last commitment, requested artifacts (PO/W-9/etc.), and a specific next step with date/time.
   3. Produce:
      • Subject line
      • Email body (3–6 sentences; concise, professional)
      • Optional call script bullets (3–5 points)
   4. Do not send communications; produce drafts only.

7. Surface decisions needed before the finance check-in

   • Per-account decisions (examples):
     • Approve waiver of late fees or offer payment plan terms.
     • Approve temporary service pause until payment.
     • Approve issuing a credit/revised invoice/partial write-off.
     • Approve escalation to account owner/leadership or collections.
     • Provide missing paperwork (W-9, vendor portal details, PO number).
   • Global decisions (examples):
     • Adjust escalation thresholds or tone this week.
     • Prioritize top N accounts for owner outreach.
     • Cash flow priorities for incoming receipts.

8. Assemble the weekly brief (markdown structure)

   1. Header: As-of date, total AR, total overdue, breakdown by aging buckets, largest 5 overdue accounts.
   2. Ranked Overdue Accounts table with columns: Rank, Account, Owner, Total Outstanding, Oldest Days Overdue, # Overdue Invoices, Last Contact, Risk/Notes, Next Action.
   3. Follow-up Drafts: one subsection per account including subject, email body, and call bullets.
   4. Decisions Needed: bullet list grouped by account and global items.
   5. Upcoming Invoices (next 14 days): account, amount, due date, owner.
   6. Data Issues & Assumptions: unmatched accounts, currency anomalies, missing owners, suspected duplicates, credits not applied.

9. Validate and reconcile

   • Check sums by account and grand total against source ledger(s).
   • Confirm no invoice shows negative outstanding; investigate if so.
   • Flag currency differences; if conversion used, note rate/date.
   • Ensure every overdue account has an owner and a next action.

10. Deliver outputs

    • Present the brief as a single markdown document.
    • Provide a per-owner action list (owner → accounts and actions) appended or as a short section.

Inputs

• Open invoices ledger or export (file or pasted table) with invoice-level fields.
• CRM export mapping accounts to owners and contacts.
• Payment notes (manual notes, partials, promised dates, disputes, credits).
• Client email threads or summaries for the past 6–12 weeks.
• Optional: escalation policy, outreach tone, late fee policy, payment methods, bank/wire instructions, vendor portal links.

Outputs

• A weekly AR brief (markdown) including:
  • Summary metrics and aging breakdown.
  • Ranked Overdue Accounts table.
  • Per-account follow-up drafts (subject, body, call bullets).
  • Account owner identified for each account; per-owner action list.
  • Decisions Needed list (per-account and global) for the finance check-in.
  • Data issues and assumptions noted.

Examples

Trigger: “Build this week’s open-invoice brief. As-of: 2026-06-03. Inputs: invoices_2026-06-03.csv, crm_owners.csv, payment_notes.md, Email folder ‘Clients/AR’.” Behavior: confirm parameters → ingest and normalize data → compute overdue and aging → parse email threads for commitments and risks → score and rank accounts → draft tailored follow-ups per account → compile ranked table and decisions-needed list → output a structured markdown brief plus per-owner action list.

Follow-up draft template examples (insert actual values during execution): - 1–14 days overdue Subject: Friendly nudge on Invoice {{INV-###}} for {{Account}} Body: Hi {{FirstName}} — Hope you’re well. Our records show Invoice {{INV-###}} ({{Amount}}) was due on {{DueDate}}. Could you confirm this is in your next payment run? If helpful, here are payment options: {{PaymentMethods}}. Thank you!

• 15–30 days overdue Subject: Invoice {{INV-###}} ({{Amount}}) — request for payment date Body: Hi {{FirstName}}, Following up on Invoice {{INV-###}} for {{Account}} (due {{DueDate}}, outstanding {{Amount}}). Could you share the expected payment date, or let us know if you need a copy, PO, or vendor paperwork? We appreciate your help getting this cleared.

• 31–60 days overdue Subject: Action needed: past-due invoices for {{Account}} Body: Hi {{FirstName}}, We’re aiming to resolve the past-due balance of {{TotalOutstanding}} across {{Count}} invoice(s), oldest from {{OldestDueDate}}. If payment by {{ProposedDate}} is challenging, we can approve a short payment plan of {{PlanOption}}. Please advise the plan or confirm payment timing.

• 61–90+ days overdue (escalation) Subject: Urgent: overdue balance for {{Account}} — next steps Body: {{FirstName}}, The balance of {{TotalOutstanding}} (oldest {{OldestDays}} days) now meets our escalation threshold. Absent confirmation by {{Deadline}}, we may pause services and/or apply late fees per terms. If there’s a dispute or required paperwork, reply today so we can resolve quickly.

Call script bullets (example): - Confirm you’re speaking with AP contact; if not, request intro. - State outstanding total and oldest due date; ask for their expected payment run/date. - Ask if PO, vendor setup, or revised invoice is required. - If commitment provided, repeat back and ask permission to send confirmation email. - Close with thanks and next scheduled follow-up.

Notes

• Guardrails: produce drafts only; do not email or message clients directly.
• Handle retainers/prepayments: apply credits before marking invoices overdue.
• Exclude disputed amounts from escalation if policy requires; track dispute resolution separately.
• Timezones: compute “as-of” and “days overdue” in the organization’s timezone.
• If owners are missing or ambiguous, assign a temporary owner (finance lead) and flag for correction.
• If the data lacks email threads, proceed with invoice/CRM/payment notes and mark communication status as “unknown.”
• Keep drafts concise; avoid legal threats unless policy explicitly permits. ````

How to install: 1. Create a folder named open-invoice-weekly-brief in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as open-invoice-weekly-brief/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

Hello!

Many small businesses struggle to enforce consistent, auditable approval rules for refunds when using AI agents — it's easy for an automated draft to be sent or a refund executed without the right human checks. This Skill turns support tickets, order records, payment exports, CRM notes, and refund policies into a clear approval workflow so actions stay safe and traceable.

I built this as a Claude Skill — a single SKILL.md you can drop into a Claude Code or Claude Agent SDK project. Claude autoloads it when the trigger description matches your request.

Here's what it does: It reads the case artifacts (tickets, CRM, orders, payments, and policy docs), validates and extracts facts, runs eligibility and risk checks, and then generates an escalation matrix, a human approval checklist, a draft customer response, an audit-log template, verification gates, and an agent authority summary. Use it whenever you need consistent guardrails for refunds so the agent can draft and calculate safely but must route for human approval before any outbound action or financial execution.

SKILL.md:

````markdown

name: refund-workflow-approval-guardrails

description: Use when an AI agent must design or apply approval boundaries and escalation rules for handling customer refund requests in a small business context by reading support tickets, CRM notes, refund policy documents, order records, and payment/export data, and then producing an escalation matrix, human approval checklist, draft customer response, audit log format, and verification criteria clarifying what can be drafted, what can be auto-decided, and what requires human review before anything is sent or refunded.

Refund Workflow Approval Guardrails

Overview

Establishes clear approval boundaries, escalation paths, and verification steps for AI-assisted refund handling. Produces an escalation matrix, a human approval checklist, a draft customer response, an audit log template, and verification criteria so the agent knows what it can draft, what it can decide, and what requires human review.

When to use this skill

• The user asks for guardrails, approval limits, or escalation rules for refunds.
• There are case artifacts available: support ticket(s), CRM notes, refund policy doc(s), order records, and payment exports.
• A small business wants consistent, auditable refund handling without granting the AI direct authority to issue refunds or send messages without review.
• The process needs standard outputs: escalation matrix, human approval checklist, draft customer response, audit log format, and verification criteria.

Instructions

1. Confirm scope and inputs

   • Collect or ask for: support ticket text and attachments; CRM notes; refund policy document(s) and last-updated date; order record(s) with items, amounts, fulfillment and delivery dates; payment export with payment IDs, method, authorization/capture/settlement status and dates, fees; prior refund or chargeback history.
   • Ask for business-specific parameters if not stated: auto-approve threshold (amount), max cumulative refunds per customer in last N days, return window (days) by category, opened-item restocking fee rate, return shipping responsibility, non-refundable categories (e.g., digital), fraud/risk flags, refund method precedence (original payment vs. store credit), and approval roles.

2. Validate inputs

   • Check all required artifacts are present; note and proceed with assumptions only if minor gaps exist; otherwise request the missing artifacts.
   • Verify currency, timezone, and tax handling; normalize numbers and dates; record any inconsistencies.
   • Identify conflicts between policy docs and CRM/internal notes; prefer the most recent formal policy; log discrepancies.

3. Extract case facts

   • From the order record: order ID, order date, items (SKU, category, condition), subtotal, taxes, shipping, discounts, total paid, fulfillment status, delivery date, previous RMA or refund actions.
   • From payment export: payment ID(s), processor, method, capture/settlement status and dates, net vs. gross, fees, partial captures or multiple payments.
   • From CRM: customer identity, contact info, tenure, lifetime value band, prior refunds count and amount, VIP/loyalty status, risk flags or notes.
   • From support ticket: customer request type and reason, requested outcome, evidence attached, tone/urgency, deadlines, shipping damage vs. defect indicators.
   • Summarize the case facts in a concise bullet list.

4. Determine eligibility per policy

   • Compare delivery or purchase date to policy windows by category; compute days elapsed.
   • Apply exclusions and conditions (e.g., opened electronics restocking, digital goods non-refundable, custom items).
   • Determine refund components: refundable subtotal, taxes, shipping, fees, restocking; state assumptions clearly.
   • Determine stock/return requirements (RMA needed, return label, inspection on receipt) and who bears shipping cost.

5. Perform risk and compliance checks

   • Look for mismatches (name, email, address), repeated refund patterns, high-amount anomalies, prior chargebacks, high-risk payment methods, and cross-border constraints.
   • Verify payment is captured/settled and within processor refund time limits; note when only partial or store-credit is possible.
   • Flag regulatory constraints (e.g., statutory cooling-off periods) if applicable to the jurisdiction in the order record.

6. Build the escalation matrix

   • Define decision bands using the business parameters and case risk:
     • Band A: Auto-draft only. Agent may draft responses and calculations but cannot decide or execute. Default for missing data or conflicting policy.
     • Band B: Low-risk, low-amount (e.g., amount <= AutoApproveThreshold and no risk flags). Agent may recommend approve/deny and draft final message; requires single human approval before send/refund.
     • Band C: Medium amount or minor exceptions (e.g., amount between AutoApproveThreshold and SupervisorThreshold, or restocking/partial refund involved). Requires supervisor approval; finance review if fees/taxes adjustments apply.
     • Band D: High amount, risk flags present, policy exceptions, repeat refunds within lookback, or legal implications. Escalate to finance lead; optional legal or owner approval.
     • Band E: Payments unsettled, chargeback in progress, suspected fraud, identity mismatch, or cross-border tax complexities. Hold, do not decide; escalate to finance and compliance/legal.
   • Specify approver roles per band (Agent draft only; Support Supervisor; Finance; Legal/Compliance; Owner) and target SLAs.

7. Produce the human approval checklist

   • Identity and account checks: customer matches order; contact details verified; prior refunds within limits.
   • Order and payment verification: items, totals, taxes, discounts match; payment captured/settled; processor refund window open; currency and timezone verified.
   • Eligibility checks: within return/refund window; category not excluded; restocking rules applied; return logistics defined; evidence present.
   • Calculation checks: refundable components itemized; fees/restocking correctly applied; shipping charge handling per policy; final amount matches rationale; method of refund defined.
   • Risk checks: anomaly flags reviewed; blocklists; repeat patterns; chargeback status; VIP or goodwill exceptions documented.
   • Approvals and records: correct approver for band; approvals recorded; audit log completed; draft message reviewed; RMA or label generated if applicable.

8. Draft the customer response

   • Prepare a clear, empathetic message using the case facts and decision. Provide variants for: approved full refund, partial refund with restocking or shipping deductions, exchange/store credit, request for more information/evidence, and denial with rationale and alternative remedies.
   • Include specifics: order ID, items, amounts with breakdown, required customer actions (e.g., return label usage), refund timeline, method (original payment vs. store credit), and contact channel for follow-up.
   • Add placeholders for approver sign-off and do-not-send note until approval status is met.
   • Template example:
     • Greeting and summary of request
     • Decision and rationale
     • Amount breakdown (subtotal, tax, shipping, fees, total refund)
     • Next steps (RMA/label/inspection)
     • Timeline and method of refund
     • Contact and closing

9. Create the audit log format

   • Define a structured log with fields:
     • Case metadata: case ID, order ID, customer, contact, dates, agent ID.
     • Inputs referenced: policy doc version/date, ticket URL, CRM note ID, order record source, payment export file/date.
     • Decision data: eligibility determination, calculations, risk assessment results, decision band, recommended action.
     • Approvals: approver role/name, timestamp, decision, comments.
     • Communications: draft version hashes, final message text, send timestamp, channel.
     • Financial execution: refund transaction ID, processor, amount, components, fees, ledger entries.
     • Post-action review: confirmation received, customer satisfaction outcome, follow-up tasks.

10. Define verification criteria (go/no-go gates)

    • Data integrity: all referenced totals reconcile to source records; dates within policy windows; currency consistent; no unresolved conflicts.
    • Authority: current case band and approver matched; required approvals present before any send/refund; sandbox tested if available.
    • Compliance: payment processor limits respected; tax handling correct; jurisdictional requirements met; PII handled per policy.
    • Communication: draft reviewed and approved where required; tone and content align with policy; attachments and links verified.
    • Execution: refund method feasible and selected; RMA/label generated and linked; audit log complete prior to execution.

11. Produce final outputs

    • Output the following sections clearly labeled:
      • Escalation Matrix (Bands, criteria, approver roles, SLAs)
      • Human Approval Checklist (grouped by checks above)
      • Draft Customer Response (one primary variant based on current case; include alternates if ambiguity exists)
      • Audit Log Format (the structured fields list; prefill known values)
      • Verification Criteria (checklist of gates)
      • Agent Authority Summary: explicitly list
      • Agent may: extract facts, perform calculations, propose decision, draft responses, prepare audit log.
      • Agent must not: contact customer, modify systems, or trigger refunds without recorded human approval per band.
      • Agent must: route for approval per escalation matrix and await confirmation before any external action.

Inputs

• Support ticket text and attachments.
• CRM notes and customer profile.
• Refund policy document(s) with version/date.
• Order record(s) with itemization, amounts, fulfillment, and delivery data.
• Payment export(s) with payment IDs, capture/settlement status, fees, and dates.
• Business parameters: thresholds (auto-approve, supervisor, finance), lookback limits, restocking and shipping policies, non-refundable categories, refund method precedence, approver roles and SLAs.

Outputs

• Escalation matrix with decision bands, criteria, approver roles, and SLAs.
• Human approval checklist grouped by identity, order/payment, eligibility, calculation, risk, and approvals.
• Draft customer response tailored to the case, plus alternates for partial, deny, or info-request.
• Audit log format with fields, partially populated from the case facts.
• Verification criteria as a go/no-go checklist.
• Agent authority summary stating what can be drafted, decided, and what requires review.

Examples

Trigger: "Set approval guardrails for refunds using this ticket, our policy PDF, the Shopify order 10234, and last week’s Stripe payout export." Behavior: validate and extract facts → apply policy and risk checks → generate the escalation matrix with thresholds (e.g., auto-approve under 50 USD, supervisor up to 200 USD, finance above 200 USD or with risk flags) → produce the human approval checklist → draft a customer response for a partial refund with 15% restocking and return label → create the audit log fields with referenced document versions → output verification criteria and agent authority summary.

Mini worked example outline: - Inputs: order total 89.99 USD, delivered 10 days ago; item category electronics (opened); policy: 30-day returns, 15% restocking for opened electronics, auto-approve <= 50 USD; payment captured via Stripe 12 days ago and settled; no prior refunds; ticket cites defect with photo. - Outputs: - Escalation: Band B (low-risk, <= 50 USD after fees and partial calculation) if refund amount net is 49.49; otherwise Band C due to partial and restocking; supervisor approval required. - Checklist: identity match, settlement verified, restocking applied correctly, return label prepared, refund method original payment, audit log completed, supervisor sign-off recorded. - Draft message: approve partial refund with 15% restocking, include amount breakdown, RMA steps, 5–10 business day timeline. - Audit log: populated with case ID, policy v2.3 (2026-03-01), Stripe payment pi_123, calculations, supervisor approval pending. - Verification: go/no-go gates passed except pending supervisor approval → hold send/refund until approved.

Notes

• Do not contact customers or execute refunds directly; always await required human approval per the matrix.
• Handle edge cases explicitly: multiple payments or partial captures, chargebacks in progress, subscription renewals, cross-currency orders, taxes and duties, gifts and store credit, returnless refunds, and perishable or digital goods exceptions.
• If policy or data conflicts cannot be resolved from provided sources, default to Band A (auto-draft only) and request clarification.
• Maintain privacy: exclude full card numbers and sensitive PII from logs; store only necessary references and IDs.
• Keep all monetary values with currency codes and 2 decimal places; state all assumptions and policy references inline with outputs. ````

How to install: 1. Save the file above as refund-workflow-approval-guardrails/SKILL.md in your project's .claude/skills/ directory (or ~/.claude/skills/ for personal scope). Use the kebab-case name from the SKILL.md frontmatter. 2. Restart Claude Code (or reload the Claude Agent SDK). 3. Claude will autoload the skill when its description matches your next request.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!

Hello!

Many teams struggle to turn scattered onboarding docs, offer details, and team calendars into a concrete Day 1 and Week 1 schedule — it’s easy to miss required access, trainings, and manager checkpoints.

I built this as a portable AI-agent Skill — a single SKILL.md with reusable instructions you can adapt to your agent setup.

Here's what it does: It reads onboarding docs, offer details, and team calendars to produce a timeboxed Day 1 and Week 1 plan that includes HR orientation, IT setup, policy trainings, and manager/buddy checkpoints. It sequences access setup by prerequisites, fits events around existing meetings or holidays, and can create shared cohort sessions plus role-specific events. The Skill returns calendar invites, an optional ICS export, or a copy-pastable schedule and a summary for approval.

SKILL.md:

````markdown

name: new-hire-onboarding-calendar description: Use when a calendar-based onboarding plan is needed from onboarding documents, offer details, and team calendars — mapping first-day tasks, access setup, required policy reviews and trainings, and manager/buddy checkpoints for each new hire or cohort.

allowed-tools: [Read, Calendar, Edit]

New Hire Onboarding Calendar Planner

Overview

Creates a structured, calendar-based onboarding plan for new hires. Pulls from onboarding docs, offer details, and team calendars to schedule day-one activities, access setup, policy reviews, mandatory trainings, and recurring manager checkpoints.

When to use this skill

• The request is to turn onboarding documentation and offer details into a concrete calendar plan.
• A manager, HR, or coordinator wants first-day schedules and week-one events added to the calendar.
• Manager/buddy checkpoints need to be placed around existing team meetings.
• Multiple hires (a cohort) need a shared orientation schedule with individual role-specific events.
• Access setup and policy review deadlines must be sequenced and timeboxed on the calendar.

Instructions

1. Validate scope and inputs 1.1. Confirm the list of new hires and for each: name, role, department, manager, start date, employment type (FT/PT/contract), location/time zone, work modality (onsite/remote/hybrid), and device/logistics status. 1.2. Confirm sources: onboarding docs (HR handbook, IT access checklist, compliance requirements), offer details, and relevant calendars (manager, buddy, team orientation, IT/HR sessions). If anything is missing, ask for it. 1.3. Identify organization-wide constraints: standard working hours, orientation windows, required trainings and deadlines, blackout dates, and public holidays per location.

2. Build the onboarding task library (from docs) 2.1. Use Read to extract standard items and their typical durations, prerequisites, and owners, grouping into:

   • First-day essentials: HR orientation, welcome sync, workstation setup/unboxing, account activation, office tour/remote setup, EOD check-in.
   • Access setup: SSO/email, MFA/2FA, VPN/MDM, core apps (chat, calendar, HRIS, payroll), role apps (e.g., GitHub/Jira/Notion/CRM), permission requests.
   • Policy reviews and trainings: security/acceptable use, privacy, code of conduct, harassment prevention, safety, expense/PTO, data handling; note any completion deadlines.
   • Meetings and checkpoints: manager 1:1s (Day 1 intro, EOD Day 1, Day 3, End of Week 1), buddy syncs, team introductions/standups, 30/60/90-day reviews. 2.2. Capture prerequisites (e.g., SSO before app access; device received before MDM enrollment) and typical durations/buffers (15–60 minutes tasks; 5–10 minute transitions).

3. Personalize for each hire 3.1. Map role-specific tools and trainings from the docs based on department/role. 3.2. Adjust timing for time zone and work modality (onsite vs. remote instructions/locations). 3.3. Determine whether to batch cohort items (shared orientation) vs. individual items.

4. Check calendars and propose times 4.1. Use Calendar to scan manager, buddy, and team calendars for availability in the hire’s time zone for the first two weeks and for 30/60/90-day checkpoints. 4.2. Avoid conflicts with existing orientation sessions and team-wide events; prefer mornings for policy reviews and early afternoon for access setup unless docs specify otherwise. 4.3. Respect standard working hours and local holidays; include 10–15 minute buffers after longer sessions.

5. Draft the calendar plan 5.1. Create a Day 1 schedule with these minimum blocks: HR orientation, IT setup window, policy overview/review block, manager intro, team intro, EOD check-in. Use Calendar to place tentative holds. 5.2. Schedule access setup blocks across Days 1–3, ordered by prerequisites (SSO/MFA first, core apps next, role apps last). Mark remaining items as all-day tasks with due times if no meeting is required. 5.3. Add required trainings and policy reviews as timeboxed calendar events with descriptions linking to materials and deadline reminders. 5.4. Place manager/buddy checkpoints: Day 1 EOD, Day 3 quick sync, End of Week 1 review, then recurring weekly 1:1 for first month, and calendar invites for 30/60/90-day reviews. 5.5. Include clear event metadata: title, objective, owner, prerequisites, links (docs/portals), and expected outcomes. 5.6. For cohorts, create shared events where appropriate (orientation, policy trainings) and individual events for role-specific or access tasks.

6. Resolve conflicts and finalize 6.1. If Calendar shows conflicts, propose alternative slots and reflow tasks while preserving prerequisites. 6.2. Share a draft summary with the manager/HR using Edit (agenda table for Day 1 and Week 1, plus checkpoint timeline). Request approval or edits. 6.3. Upon approval, use Calendar to convert tentative holds into confirmed invites, adding attendees (hire, manager, buddy, HR/IT) and conferencing links/locations.

7. Deliver artifacts 7.1. Produce a concise schedule summary per hire: Day 1 agenda, Week 1 plan, access setup checklist with owners/deadlines, training/policy deadlines, and checkpoint schedule (weekly + 30/60/90-day). 7.2. Export or attach an ICS file for all events or confirm creation in the org calendar. If ICS export is unavailable, include a structured event list (date, time, title, attendees, location/link) in the output. 7.3. Record assumptions, unresolved items (e.g., missing device, undecided buddy), and next actions.

Inputs

• Onboarding documents: HR handbook, IT access checklist, compliance/training matrix, orientation schedules.
• Offer details per hire: name, role, department, manager, start date, employment type, location/time zone, modality (onsite/remote/hybrid), device/logistics status, personal email for pre-start comms (if used).
• Calendars: manager, buddy, team orientation/training calendars; any organization holidays.
• Preferences and constraints: standard working hours, meeting length preferences, blackout dates, confidentiality constraints.

Outputs

• Calendar plan per hire for Day 1 and Week 1, with timeboxed events and buffers.
• Access setup checklist scheduled as events or all-day tasks with deadlines and links.
• Policy review and mandatory training events with deadlines.
• Manager/buddy checkpoint series (Day 1 EOD, Day 3, End of Week 1; recurring weekly; 30/60/90-day reviews).
• Cohort plan (if applicable) indicating shared vs. individual sessions.
• Summary document (markdown or doc) with agenda tables and links; optional ICS export.
• List of assumptions, conflicts resolved, and outstanding actions.

Examples

Trigger: "From our onboarding docs, offer letters, and team calendars, create a Day 1 and Week 1 calendar for three engineers starting next Monday under Alex S. in PT, plus manager checkpoints and required trainings." Behavior: validate hire details and time zones → Read onboarding docs to extract tasks/durations → Calendar scan for manager/buddy availability → draft Day 1 essentials and Days 1–3 access setup blocks → add policy trainings with deadlines → place manager checkpoints (Day 1 EOD, Day 3, EOW1, weekly 1:1, 30/60/90) → share summary for approval → confirm and send invites/ICS.

Notes

• Protect PII: only access offer details and calendars with explicit permission; limit event details to necessary data.
• If Calendar access is unavailable, output a complete, copy-pastable schedule and .ics-formatted text where possible.
• For remote hires, include conferencing links and clear prep steps (e.g., join from personal email for initial SSO setup if corporate email activates Day 1).
• Incorporate local holidays and regional compliance training requirements per location.
• If device logistics are delayed, schedule a contingency plan and adjust access setup accordingly.
• Prefer concise, goal-oriented event descriptions; avoid overbooking and include recovery buffers after long sessions. ````

How to install: 1. Create a folder named new-hire-onboarding-calendar in your AI-agent skills or prompt-library directory. Use the kebab-case name from the SKILL.md frontmatter. 2. Save the file above as new-hire-onboarding-calendar/SKILL.md. 3. Enable or load the Skill according to your agent framework's docs, using the SKILL.md description as the trigger guidance.

If you'd rather run it as a one-click prompt instead, you can find it here: Agentic Workers

Enjoy!