Check out our digest of AI Skills from the month of May, as well as bonus skills that we haven't featured in the daily newsletter yet.
Every day, The Neuron's newsletter teaches 700,000+ readers one new AI skill they can use immediately. This is your weekly collection.
We publish these digests so you never have to dig through your inbox to find that one tip you half-remember from Thursday. Here's every skill from this week in one place, with expanded context and the full prompts so you can try each one yourself.
Have a specific skill you want to learn? Request it here.
Every skill below works because of how the request is built, not how cleverly it's worded. Define what success looks like up front, force the model to stress-test or atomicize its own output, set up your AI tool as an agent-management cockpit, and the model carries the load. Even Anthropic and OpenAI's new prompting guides this week (skill below) explicitly punish vague phrasing while rewarding structure. The pattern shows up six times in eight days.
New skills drop in the newsletter every day and get added here within 24 hours. Bookmark this page or subscribe to The Neuron if you want them delivered straight to your inbox.
Previous skill digests: AI Skill — April 2026 (Week 1) | AI Skill — March 2026 (Part 3) | AI Skill — March 2026 (Part 2)
AI Skill of the Day Digests:
Prompt Tip of the Day Digests:
Standalone Guides:
Want Codex to stop acting like a helpful intern and start acting like a tiny project manager with a caffeine problem?
Try this trick from @meta_alchemist: before using Codex’s /goal feature, ask Codex to write the goal for you. /goal is an experimental Codex CLI feature, meaning it’s currently for the terminal version of Codex. OpenAI says it’s built for long-running work where Codex keeps going toward a clear stopping condition.
First, paste this:
read this session and repo, analyze deeply the exact intent and goals we are looking to achieve here then write me the /goal prompt for this. make sure to dig into history & docs we have to be 100% clearif you are not sure about certain parts or wanna ask me a few questions to clarify certain goals further don't hesitate
Then copy Codex’s answer, change the first part to /goal, and run it. Codex will keep working against that durable objective instead of stopping after one normal turn. OpenAI recommends goals that define the objective, files/docs to read, proof of progress, checkpoints, and the stopping condition.
Outside Codex, use the same trick for knowledge work: ask ChatGPT or Claude to read your notes, docs, transcripts, or brief, infer the real goal, then write the “goal prompt”, or mission brief, before it starts the mission.
Codex users do this with /goal, but the trick works for almost any knowledge work task: strategy docs, research projects, sales decks, meeting follow-ups, spreadsheet cleanup, hiring scorecards, launch plans, whatever pile of context is quietly judging you from twelve tabs.
Here’s the move:
In this case, you aren't asking AI to “do the thing” first. Ask it to define the thing clearly enough that the next run can’t wander off into productivity cosplay.
Read this full session, project context, and any available notes, docs, files, or history. Analyze deeply what I am actually trying to accomplish here.Identify:1. the real goal,2. the intended final deliverable,3. the constraints and preferences already stated,4. the important context from history/docs,5. any ambiguities or questions that would change the outcome.Then write me the best possible goal prompt to use for this task. Make it specific, action-oriented, and complete enough that an AI agent could keep working until the deliverable is finished.If anything is unclear, ask me a few targeted clarification questions before writing the final prompt.
For the first time, we have public benchmarks on how long it takes a newly published page to show up as a citation inside ChatGPT or Claude. Josh Blyskal combed through billions of logs plus ~900 freshly published marketing pages and found:
That gives every content and marketing team a real clock. If you're past day 37 without a citation, the problem is almost certainly your setup (robots.txt blocks, missing sitemap entries, page buried too deep), not patience. If you hit a citation in under a week, you're ahead of the curve and should keep doing whatever's working.
You are an AEO auditor (answer engine optimization for ChatGPT, Claude, and Perplexity).I'll paste a URL. For that page, return:1. Likelihood of getting cited by ChatGPT or Claude within 7 days (high / medium / low) and why, using web search for the top AEO best practices as of today’s data.2. The 3 specific fixes most likely to improve citation speed.3. The 5 query patterns this page should win as a citation in.Be specific. Don't restate the page's content; analyze whether it's structured for retrieval.URL: [paste here]
Use this prompt to figure out where a specific page stands
Microsoft just quietly shipped something much bigger: Copilot Cowork, an agent that can take a complex goal, build a plan, schedule meetings, draft documents, and execute across your entire Microsoft 365 account while you're doing something else. In this tutorial from Kevin Stratvert's YouTube channel, host Nick Brazzi walks through exactly how it works.
Think of it less like a chatbot and more like delegating a project to a very capable assistant who has access to your calendar, email, files, and company directory.
Here's how to get started (note: currently requires a Microsoft 365 Business or Enterprise subscription plus the Copilot add-on; Cowork is in early access via Microsoft's "Frontier" program):
Try this prompt to start:
Help me plan our team's [event/project name]. Find anyone who was involved last time, assign responsibilities, find a date that works for everyone in [month], schedule the planning meetings we need, and create a kickoff presentation and any supporting documents.
If you've run a long AI session, you know the moment: two hours in, the model is finally good, and then you hit the context limit. Most people copy a "where I left off" note into a fresh session manually. It works; it's lossy and tedious.
Matt Pocock built and open-sourced a /handoff skill that automates this. It's a SKILL.md (a reusable instruction set you attach to a Claude project) that compacts the session into a clean handoff doc: context, goals, artifacts produced, suggested next steps. A fresh agent or human picks up exactly where you left off.
How to use it:
/handoffCompact this session into a clean handoff document. Include:- Current goal and sub-goals- Context that took us multiple turns to establish- Artifacts produced so far (with links/paths)- Decisions made and why- What's blocking, if anything- Suggested next steps for whoever picks this up
Works for any long task, not just coding: research, writing, strategy. Anywhere value compounds across turns and you don't want to lose it.
From: CJ Zafir on X (May 7)
Most AI models are way too agreeable. Ask Claude, ChatGPT, or Codex "is this a good plan?" and you'll get back something that sounds suspiciously like "yes, that's a great plan!" even when it isn't. This is called sycophancy (the model is trained to please you), and it kills the value of using AI for serious decision-making, especially the kinds of decisions where you most need a sharp second opinion.
CJ Zafir shared a one-line prompt loop that fights it. Instead of asking "is this good?", you ask the model directly whether it's 100% confident. That phrasing flips the model into a self-audit mode where it'll actually go find the holes in its own work; CJ claims 2-3 cycles patches strategy weaknesses where less rigorous models would just nod along.
The interesting wrinkle: not all models respond to this equally. CJ ran the same prompt against Codex (running GPT-5.5) and Opus 4.7. Opus 4.7, which has been measured as more sycophantic than its predecessor in some evals, tended to just agree on the first pass. Codex went hunting and produced specific structural critiques. The lesson: pair this prompt with a reasoning model that has the chops to actually find loopholes when you give it permission.
How to do it:
Are you 100% confident in this strategy? If not, find all possible loopholes, suggest proper fixes, and run this loop until you are factually 100% confident.
Our favorite part: the word factually is the key. Without it, the model vibe-checks itself and says it's confident. "Factually confident" forces it to ground the answer in verifiable reasoning the way it would for a fact-check. One word's worth of editing on the prompt, totally different output.
From: Austin Tedesco's Codex Camp livestream with Dan Shipper (May 6, ~60 min)
You probably use Codex or Claude Code for code. Austin Tedesco, head of growth at Every, spends roughly 80% of his working day inside Codex doing go-to-market plans, recruiting outreach, KPI tracking, and emails. His Codex Camp livestream with Dan Shipper was a 60-minute walkthrough of the exact setup; here's the short version.
The trick is treating the desktop app (not the CLI; Codex's command-line version) as an "agent management interface" for everything you do. Austin's setup:
Go take a look at the things I use the most (@Notion, @Slack, and @Gmail) and think of some automations that would help me with my work. For each one, explain what it does, when it should run, and which tool it touches. Ask me which ones look good before you build any of them.
The @ signs refer to apps, so they require you to connect those apps as Plugins; replace those with whatever tools you use.
Other plays Austin demoed live: synthesize meeting transcripts and Slack threads into a draft go-to-market plan, build a live KPI tracker in Notion that other agents can read, and find alums of a specific company who later got into AI (he used this exact play to surface a perfect L&D hire candidate in under a minute).
Our favorite part: the "external app for final review" rule. Most people never set that boundary, and the failure mode is shipping AI-generated work without re-reading it in the app where the recipient will see it. Austin's rule turns Codex into the cockpit and Slack/Gmail into the cockpit's dashboard.
From: @EXM7777 on X (May 4)
An X user shared a four-line prompt that turns any pile of raw notes into a structured second brain. No vector databases (specialized storage that lets AI search through your text), no RAG (a system that fetches relevant chunks of your notes for the model), no $20/month app.
The skill is atomicizing: turning one blob of text into many small, single-concept files with [[wikilinks]] (clickable backlinks between related notes) so you end up with a browsable knowledge graph. LLMs are excellent at this. It's the manual labor Obsidian users normally hate.
This is also exactly what Andrej Karpathy was hinting at in his recent Sequoia AI Ascent thread (our breakdown). His point: LLM-built knowledge bases were fundamentally impossible with classical code, since computation over unstructured data was the missing piece. Now that piece exists and is essentially free.
How to do it:
Dissect this raw note into atomic Obsidian markdown files. Each file = one concept. Use [[wikilinks]] between any concept that references another. Output as separate code blocks with filenames.
The four-line prompt is doing four jobs at once: identifying distinct concepts in your text, naming each one (filename), connecting concepts to each other (wikilinks), and outputting in a format Obsidian can ingest directly. None of those four jobs is hard for an LLM individually; bundling them into one command is the move.
Our favorite part: "atomic Obsidian markdown files." Two words, atomic and Obsidian, are doing all the work. Atomic tells the model to break the input into single-concept chunks (one of the actual practices in the Zettelkasten note-taking method). Obsidian triggers the model's training data on [[wikilinks]] syntax. Strip those two words out and you'd get a flat summary instead.
From: Inspired by the Harvard study on OpenAI's o1 (May 3, Science paper)
This week's Harvard study showed o1 (an older generation reasoning model from OpenAI) beating ER attendings most decisively in the first minutes of triage; when information is sparse and pressure is high. Most workplace decisions look exactly like that: contract negotiations, hiring calls, architectural choices, budget approvals. You make the call with limited information, gut feel doing a lot of the work, and the cost of getting it wrong is high.
The skill is feeding a reasoning model your conclusion plus your reasoning, then asking it to find what you missed. The structure matters: you're not asking the model "what should I do?", you're asking the model to stress-test a position you've already taken. That's a different (and more rigorous) workflow.
How to do it:
Drop this into GPT-5.5 with reasoning on, Claude Opus 4.7, or Gemini 3.1 Pro:
I've concluded [DECISION] based on the following reasoning: [YOUR REASONING].Before I commit, I want a structured second opinion. Please:1. Identify the strongest argument against my conclusion.2. Generate three alternative hypotheses I may have missed.3. List the specific evidence or scenarios that would shift your assessment in either direction.4. Flag any assumptions in my reasoning that look load-bearing but aren't actually supported.Be direct. I'm looking for the version of this analysis I'd get from a sharp colleague who isn't trying to spare my feelings.
The trick is forcing yourself to write out your reasoning before pasting. Half the value is in that step alone; the model just stress-tests the rest.
Our favorite part: "the version of this analysis I'd get from a sharp colleague who isn't trying to spare my feelings." That sentence in the prompt is doing the work that the CJ Zafir prompt (May 8) does in a different way. Both fight sycophancy. Different mechanism, same outcome: the model knows it's been given permission to push back, so it does.
From: Paul J. Lipsky on YouTube (May 3)
YouTuber Paul J. Lipsky walked through something worth knowing: Gemini can now generate full files; Google Docs, Sheets, Slides, Excel, CSV, PDF, even Markdown directly from a prompt, no copy-pasting required. This is one of those updates Google shipped quietly that meaningfully changes what "ask Gemini to do something" means.
A few things you can do right now:
One caveat Lipsky flagged: when you ask Gemini to edit an existing Drive file, it duplicates it instead of editing in place. Not ideal, but workable; just budget the extra second to delete the original.
Why this matters: the gap between "AI gave me text" and "AI gave me a file I can ship" used to require copy-paste, formatting, export, and one more cleanup pass. Eliminating that gap means Gemini becomes useful for things you'd otherwise punt on; turning a Voice Memo into a doc, turning a folder of receipts into an expense report, turning research into a deliverable that lands in Drive ready to share.
Gemini, look up [TOPIC] and create a Google Doc with the findings.Use clear headers, include 3-5 sources with hyperlinks, and end with a "Next steps" section pulling out anything I should follow up on. Save it to my Drive in the [FOLDER NAME] folder.
Our favorite part: feed it a folder of receipts, get a clean expense report ready for export. Saves an embarrassing amount of time, especially if you've been doing this manually month after month.
From: Alex Prompter on X catching the difference between Anthropic's Claude prompting guide and OpenAI's GPT-5.5 prompting guide (April 28-30)
Quick gut-check: still prompting the way you did six months ago? Anthropic and OpenAI both quietly published new prompting guides this month (Claude, GPT-5.5 guidance, GPT-5.5 migration), and Alex Prompter caught the awkward part: the same vague-prompting habit now gets penalized by both, from opposite directions.
Claude 4.7 went literal. It does exactly what you type and no longer compensates for fuzzy intent, so vague instructions that worked on 4.6 now produce narrow, literal, sometimes worse output. The model didn't regress; the prompts did.
GPT-5.5 went autonomous. OpenAI's guide tells you to drop the step-by-step process scripts older models needed; on 5.5 that detail now creates noise and produces mechanical answers. Describe the outcome; let the model pick the path.
Shared lesson: spend two minutes writing down what success looks like before you open the chat. For GPT-5.5, OpenAI literally hands you the structure to pin to your most-used assistant. Try this:
Role: [what the model is and the job to be done]# Goal[user-visible outcome]# Success criteria[what must be true before the final answer]# Constraints[policy, safety, business, and evidence limits]# Output[length, sections, tone]# Stop rules[when to retry, fall back, abstain, ask, or stop]
For Claude 4.7, same thinking, opposite implementation: be surgically specific about every variable in your task. The model won't infer for you anymore.
Our favorite part: the Stop rules line in OpenAI's template. Most people never tell the model when to not answer, when to ask for clarification, when to abstain. Telling the model "if you don't have enough info, ask before guessing" is the single biggest hallucination reducer most people aren't using.
Below are our extra AI Skills of the Day that couldn't make it into the main newsletter.
From: OpenAI Codex for Chrome (May 7)
You've probably hit this wall: an AI agent that can browse the open web is useful, but it can't reach the half of the internet that actually has your stuff in it. Your CRM, your admin console, your gated databases, your internal wikis. The agent gets to the login screen and stops.
OpenAI Codex for Chrome flips that. Codex now drives background tabs in Chrome on Mac and Windows from inside a session you're already logged into, which means it can do three things that previously required a person: deep research inside subscription/paywalled sites, large-scale data transfer into your CRM or CMS, and repetitive admin-console workflows. It opens tab groups, does the work, and cleans up after itself without taking over your browser. You can keep working in your other tabs while Codex churns.
The catch: it's currently unavailable in the EU and UK. And it requires a Codex subscription. But for anyone in the supported regions, this collapses a category of "can AI do this for me?" tasks that used to require browser-extension hacks or RPA tools.
Three workflows worth trying first:
You're driving Chrome on my behalf. Open the tabs needed for [task description]. Work entirely inside [target site] where I'm already logged in. For each step, tell me what you found before clicking anything that writes data. When done, close the tabs you opened and summarize what you did.
Our favorite part: Codex doesn't take over your active browser. It opens a separate tab group, does the work, and cleans up. You can keep using Chrome for everything else while the agent runs.
From: Matt Pocock's /handoff skill (May 7)
Anyone who's had a long AI session knows the moment: you've spent two hours building context, the model is finally getting good, and then you hit the context limit. Or the agent crashes. Or you just want to come back tomorrow without re-explaining everything. Most people manually copy a "where I left off" note into a fresh session. It works, but it's lossy and tedious.
Matt Pocock built and open-sourced a /handoff skill that does this for you. It's a SKILL.md (a reusable instruction set you can attach to a Claude project) that compacts the current session into a clean Markdown handoff document — context, goals, artifacts already produced, and suggested next skills. A fresh agent or a human collaborator can pick up exactly where you left off without losing anything.
This is most obviously useful for coding sessions, but the pattern works for any long-running AI task: research projects, content drafting, strategy work, anything where the value compounds across many turns and you don't want to lose it.
How to use it:
/handoff./handoff
Compact this session into a clean handoff document. Include:
- Current goal and sub-goals
- Context that took us multiple turns to establish
- Artifacts produced so far (with links/paths)
- Decisions made and why
- What's blocking, if anything
- Suggested next steps for whoever picks this up
Our favorite part: the format is opinionated enough that the next session — agent or human — actually has what it needs without the handoff doc becoming a wall of text.
/goal to make AI keep working on multi-hour tasksFrom: Peter Steinberger's GPT-5.5 + /goal demo ([May 7])
Most AI coding sessions break down on long tasks. The model does great work for 20-30 minutes, then drifts, forgets what it was doing, or stops short of finishing. The persistent-goal pattern fixes this: you give the agent a goal explicitly, and it keeps that goal as its north star even across crashes, restarts, or context resets.
Peter Steinberger demonstrated this with GPT-5.5 + Codex's /goal command on an extensive multi-hour code refactor — including end-to-end tests at the end. The agent stayed on task through the whole thing, didn't drift, and produced verifiable output (passing tests). That's a different category of result from the typical "the AI did 70% of it and gave up."
When this is the right tool:
How to do it in Codex:
/goal followed by a clear, verifiable goal statement./goal Refactor [target] from [old approach] to [new approach].
Done means: (1) all existing tests still pass, (2) no behavioral changes,
(3) [specific structural criterion], (4) end-to-end test added that
proves [the thing the refactor was supposed to enable].
Our favorite part: the goal statement forces you to define "done" up front. Half the value of /goal is that you can't use it lazily — you have to commit to what success means before you start.
From: Ryan Carson's DevinAI smoke-test loop ([May 7])
Edge-case bugs in your product's onboarding flow are expensive precisely because they're hard to spot — the happy path works, the obvious failure modes are caught, and what gets through is the weird stuff that only triggers under specific account states or timing. Manual QA misses these. Automated end-to-end tests catch the cases you wrote them for, not the ones you didn't.
Ryan Carson runs daily automated smoke tests of his product's full 28-step / 99-minute customer onboarding flow using DevinAI for ~$33/day. Fresh accounts every time, every tool exercised, video recordings, PASS/FAIL email reports. He's uncovering edge-case bugs weekly.
The math: $33/day × 30 days = $990/month. For most SaaS products that's cheaper than one engineer-hour of manual QA, and you get continuous coverage instead of a snapshot. The loop catches drift in third-party integrations, auth flow regressions, and timing-dependent failures that only show up in real environments.
How to set this up:
You're running a daily smoke test of [product name]'s [flow name].
Setup:
- Use a fresh email address (format: smoke-test-YYYYMMDD@[your-domain]).
- Sign up via [signup URL].
- Walk through every step of [flow], including [list of integrations to exercise].
Verification at each step:
- Take a screenshot.
- Confirm [expected behavior].
- If anything fails, capture the error state and continue (don't abort).
Output:
- A PASS/FAIL summary email with screenshots inline.
- A short note for any step that PASSED but felt slow (>5s loading time, etc.).
Our favorite part: continuous, not periodic. Most teams smoke-test before a release. Ryan's loop catches the bugs introduced by third-party API changes, auth provider drift, and timing weirdness — the stuff that breaks between releases.
From: n8n's Production AI Playbook by Elvis Saravia (May 7)
You shipped an AI workflow that worked great in testing. A week later something silently changed — maybe the model provider updated weights, maybe an upstream API started returning new fields, maybe your prompts started hitting an edge case nobody anticipated — and now your workflow is producing subtly worse output. Nobody flags it because the workflow still runs. This is silent drift, and it's the most expensive failure mode for AI in production.
n8n's Production AI Playbook by Elvis Saravia lays out a continuous evaluation pattern for catching drift before it costs you customers. The core idea: production AI workflows need monitoring the way production code needs monitoring, but the metrics are different.
The four layers of evaluation:
How to apply this in n8n (or anywhere):
You're a quality judge for an AI production workflow.
Workflow purpose: [describe what the production AI is supposed to do]
Input: [the input that was given]
Output: [the output that was produced]
Expected schema/format: [if applicable]
Score 1-10 on:
- Accuracy (does the output match what's actually true given the input?)
- Completeness (does the output cover everything the prompt asked for?)
- Format adherence (does the output match the expected schema/format?)
- Tool-use sanity (if tools were called, were the inputs reasonable?)
For any score below 8, explain what's wrong and what would need to change.
Our favorite part: structural checks. They're so much cheaper than LLM-as-judge and they catch most regressions; teams default to expensive evals when 80% of their drift would be caught by checking that the output has the fields it's supposed to have.
From: Trevin Chow's CLI principles ([May 2-3])
If you ship any kind of command-line tool — for a SaaS product, an internal tool, an open-source library — there's a real chance an AI agent is going to call it before a human does. Most CLIs were designed for humans typing at a terminal: interactive prompts, ANSI colors, text formatting, friendly error messages. All of that is friction for an agent.
Trevin Chow (drawing from Cloudflare and HeyGen's CLI design) outlined 10 principles for building CLIs that work for both humans AND agents.
Table-stakes (must-haves):
--json flag that emits machine-parseable output. Always.Advanced (separates good CLIs from great):
list, get, create, update, delete. Same verbs everywhere. Agents pattern-match; surprise verbs break the pattern.--wait support for async operations. If an operation kicks off a background job, the CLI should be able to block until it's done (with timeout) so agents don't have to poll.--help.The audit: run your CLI through this checklist. The fastest way to do it is to ask an agent to use your CLI for a multi-step task without human intervention. Wherever it gets stuck or has to ask for help is a place your CLI is failing the agent test.
You're auditing the [CLI name] CLI for agent-friendliness.
Walk through this 10-principle checklist for the CLI. For each principle,
check: does the CLI satisfy it? If yes, give an example command that
demonstrates it. If no, describe what would need to change.
[paste Trevin's 10 principles list here]
End with a prioritized list of the 3 highest-impact changes the CLI team
should make to improve agent compatibility.
Our favorite part: the "agent test" idea. The fastest way to find your CLI's weaknesses is to give an agent a multi-step task that uses it and watch where the agent gets stuck. That's almost always a design flaw, not an agent flaw.
More coming as the month progresses. Check back, or catch each one in your daily Neuron newsletter.
Have a specific skill you want to learn? Request it here.
Grant Harvey is the Lead Writer of The Neuron, where he continues to lead the publication's daily coverage of AI news, tools, and trends.
Don't fall behind on AI. Get the AI trends & tools you need to know. Join 700,000+ professionals from top companies like Microsoft, Apple, Salesforce and more.
Property of TechnologyAdvice. © 2026 TechnologyAdvice. All Rights Reserved
Advertiser Disclosure: Some of the products that appear on this site are from companies from which TechnologyAdvice receives compensation. This compensation may impact how and where products appear on this site including, for example, the order in which they appear. TechnologyAdvice does not include all companies or all types of products available in the marketplace.