Our Guide to AI Skills, Projects, Custom GPTs, Agents, Plugins, Connectors, Loops, and Codex Workflows

If you’ve opened ChatGPT, Claude, or Gemini lately and felt like every company invented three new words for “custom AI thing,” this episode is for you. If you don't even know where to start, or you're still using a CustomGPT for all your one-off tasks, this one's for you.

The livestream started with the phrase that probably belongs on the whole category: “the alphabet soup of terminology”. Projects, Gems, GPTs, Skills, Agents, subagents, plugins, connectors, loops, goals, Codex, Claude Code, Cowork... the words multiply faster than most people can use the tools.

Here's a useful primer for what each is:

• Projects are places to organize ongoing work.
• Gems and Custom GPTs are reusable custom assistants.
• Skills are reusable instructions, workflows, and resources.
• Agents are AI systems that can take action across steps and tools.
• Plugins and connectors give agents access to outside apps.
• Loops and goals let agents keep checking, improving, and trying again.
• Subagents are specialist helpers inside a larger agent workflow.

That last batch gets more advanced. Start with the first four.

The full stream is two hours long because, well, it is us. This guide gives you the guided tour: the most useful moments, demos, definitions, analogies, and “go try this” ideas, linked to the exact spot in the episode.

P.S: Grant here. Not sure what happened to my audio here, but something happened. I'll try to fix it and re-upload, but for now, work with this.

P.P.S: If you're an absolute AI beginner, read this guide first before you continue below. And if you want to read our companion guide to AI agents before this one, click here.

The Key Moments:

• (00:00:16) Grant says this episode is about the "alphabet soup" of AI terminology users now need to learn, even before getting into technical ML terms like VAEs, GPUs, and transformers.
• (00:02:53) Corey frames the live show as Grant and Corey chronicling their own learning journey, not pretending they already mastered every new tool before the audience sees it.
• (00:04:42) Corey states the core promise: explain the difference between skills, projects, custom GPTs, and Gemini Gems, then show which use cases each one fits because “every task is best suited for just about one of them.”
• (00:06:05) Corey says he taught a three-hour AI skills class to roughly 60 company leaders and saw “light bulbs go off” once people understood how skills make AI click.
• (00:07:38) Grant expands the agenda beyond projects, custom GPTs, Gems, and skills to include agents, subagents, plugins, and loops in the more advanced back half.
• (00:09:38) Grant defines projects as workspaces that keep chats, files, instructions, and context together for one ongoing effort.
• (00:10:41) Grant explains that projects can be broad or granular: a launch, a hiring process, Q3 strategy, or The Neuron’s daily newsletter workflow.
• (00:12:18) Corey says a project differs from a custom GPT because a project is generally “yours,” closer to a folder for work on a specific effort than a general assistant.
• (00:12:46) Corey compares projects to Google Drive or Microsoft 365 folders, where past work, instructions, priorities, and relevant resources stay together.
• (00:14:03) Corey gives practical project examples: a sales report project might include billing process SOPs, while an HR project might include the employee handbook so AI can check alignment.
• (00:15:30) Grant says custom GPTs and Gems differ from projects because they can be shared with other people, while projects are more personal workspaces.
• (00:16:34) Corey says custom GPTs still have workplace value when you need a shared process where teammates can use the assistant but only designated editors can change the prompt.
• (00:17:35) Grant shows Gemini Gems as Google’s version of custom GPTs, with names, descriptions, instructions, uploaded knowledge, and model/tool choices.
• (00:18:55) Grant warns that Gemini image workflows can be inconsistent, using his Neuron header image Gem as an example where the system over-added text and thought bubbles.
• (00:19:56) Grant says a custom GPT is best for a very specific, dialed-in one-off task, especially one you want to share with a team.
• (00:20:41) Grant notes that custom GPTs can include instructions, conversation starters, shared knowledge, recommended models, capabilities, and actions, but if actions get complex, an agent is probably the better tool.
• (00:21:46) Corey adds that custom GPTs can connect an API input, but some custom GPT capabilities have historically been less reliable than normal ChatGPT, including internet access.
• (00:22:33) Grant says custom GPTs are “basically about to be replaced” by agents, though those agents are mainly available on business-tier accounts at this point in the conversation.
• (00:23:43) Grant describes agents as beefed-up custom GPTs that can include prompts, channels, apps, skills, automations, scheduled runs, and chat-based setup.
• (00:25:39) Grant gives the first decision framework: use a project to organize ongoing work, and use a custom GPT, Gem, or workspace agent for a reusable assistant with a role or task.
• (00:26:37) Corey defines a skill as a “saved workflow” that can be used anywhere, can call multiple tools, can search the internet, and knows the expected output format.
• (00:27:31) Corey emphasizes skill portability: skills use standard MD/YAML-style files, can be downloaded as zips, and can move between ChatGPT, Claude, and other tools that support skills.
• (00:28:17) Grant formalizes the definition: a skill stores the process, structure, quality bar, must-haves, and things to avoid for a reusable workflow.
• (00:28:59) Corey’s example use case: if he periodically needs an executive report and does not want to remember the format every time, a skill can remember “how Corey likes those.”
• (00:29:11) Grant says skills can save formatting, constraints, avoid-lists, and Python scripts for deterministic steps, so the AI runs a known sequence instead of improvising.
• (00:29:48) Corey says skills exist in Claude, agent tools, and ChatGPT business accounts, are not yet in standard ChatGPT Plus, and also work in Codex.
• (00:30:34) Grant notes that Gemini has skills at least through Gemma, and Grok had also launched skills, making the pattern broader than one vendor.
• (00:32:07) Grant answers whether skills are like Cowork: Cowork is more like an agent with access to your computer, and it can call a skill to perform a workflow.
• (00:32:07) Grant’s concrete example: Cowork could use a Neuron AI Skill of the Day creator skill to research, understand the assignment, read docs, and write in the exact Neuron format.
• (00:33:29) Grant says skills are “probably the biggest unlock” in AI use right now because you no longer need to memorize and rewrite prompts; you can just invoke the workflow.
• (00:33:39) Corey advises viewers to use the AI tool they already understand if it works, because differences between frontier models are often small and flip-flop week to week.
• (00:34:46) Grant challenges ChatGPT-only users to try Codex because it is more powerful than the ChatGPT app and may eventually merge into the same broader product experience.
• (00:35:32) Corey says it is a “real bummer” that Anthropic and OpenAI put “code” in these tool names because non-engineers may miss how useful Codex and Claude Code are for regular work.
• (00:37:24) Corey demonstrates that Codex can be used like a normal chat tool, but with automations, sites, plugins, skills, and local-computer workflows that often work better for work tasks.
• (00:38:22) Corey shows Codex’s setup choice between “code” and “everyday work,” where everyday work keeps the same power with less technical detail.
• (00:38:52) Corey highlights Codex features ChatGPT lacks, including reading level controls and a fast mode running on Cerebras chips, while noting fast mode is expensive.
• (00:39:22) Corey shares a mobile Codex anecdote: an app he built failed in a morning report, so he opened Codex on his phone at a coffee shop, asked it to fix the issue, and it updated his desktop work before he got home.
• (00:40:28) Grant says portability is exactly why they recommend focusing on reusable skills, since skill files can move across platforms while project context can also live in a local folder.
• (00:41:43) Corey says all major models have reached a point where they are good enough for many jobs, and the practical difference depends heavily on the task, such as electrical engineering versus bookkeeping.
• (00:42:46) Corey begins a skill-creation demo by taking an image style he uses for YouTube Shorts B-roll sketches and asking ChatGPT to turn that recurring task into a skill.
• (00:44:29) Grant explains that ChatGPT business and Codex include a built-in skill creator skill that can produce a one-click executable skill file; Claude can do this too.
• (00:45:02) Corey’s B-roll sketch skill prompt packages trigger words, style rules, vertical format, and a prompt template so future requests do not need the full image-generation instructions.
• (00:46:07) Corey installs the new B-roll sketch skill and shows that it can be tried immediately in a new chat.
• (00:47:37) Corey shows that skill invocation can be informal; “use your b-roll skill” is enough for ChatGPT to load the correct skill and apply its stored instructions.
• (00:49:23) Grant points out a limitation: AI tools are weak at moving and organizing reference images inside skill files, so reference images may need to be manually placed in the skill folder or handled through Codex.
• (00:51:10) Corey shows where skills live in ChatGPT settings: installed skills, personal skills, and company-shared skills, adding that sometimes the best answer is checking whether someone else already made the skill.
• (00:52:06) Corey says his preferred skill-building process is to get the result right in a normal chat, then say, “Okay, that’s the one, make that a skill.”
• (00:52:24) Grant gives the rule of thumb from Corey’s internal training: if you do something more than twice, it is worth making a skill.
• (00:52:43) Corey adds that even “I might need this again someday” can justify a skill because old chat history becomes impossible to find later.
• (00:53:02) Grant shows Claude’s skill interface: customize, create new skills, browse Anthropic-provided skills, or upload skills created elsewhere.
• (00:54:13) Grant explains the skill-versus-agent distinction: the skill is the prompt, project structure, instructions, and intent packaged for a recurring task the agent can use.
• (00:55:11) Grant recommends versioning skills, such as “skill creator 1.2” or “1.3,” so individuals and teams know which skill version is current.
• (00:56:28) Corey says Google does not broadly have skills yet, but skills are becoming a standard pattern because they are already used across coding agents.
• (00:56:51) Corey says an agent requires elements a skill does not: a trigger, tool use, maybe verification, and the ability to combine those pieces to perform a task.
• (00:57:18) Corey’s practical difference: use a skill when you want hands-on help, and use an agent when you want something to happen automatically, like a report appearing in your inbox each morning.
• (00:57:18) Corey describes his YouTube research agent: every day at 5:30 a.m. Central, it calls the YouTube API, gathers data from selected channels, analyzes it, saves a PDF, and emails the report.
• (00:59:32) Grant says agents can use skills, but skills cannot use agents, except in more complex agentic engineering involving subagents.
• (01:00:23) Grant defines an agent as an AI that can take actions toward a goal using instructions, tools, browsing, clicking, file reads, code execution, and multi-step work.
• (01:00:42) Grant gives agent examples: research a topic and build a spreadsheet, review files and draft updates, or fix a coding issue and prepare a PR for review.
• (01:02:06) Grant demonstrates creating a skill for funny Facebook responses, specifying short direct comments, slang, pop-culture references, web search, ridiculous claims, questions, and “crack Gen Z brain.”
• (01:03:45) Grant critiques the generated Facebook-response skill as “trying too hard and doing too much,” then instructs it to be punchier and include typos.
• (01:04:09) Corey answers whether Codex is an agent or harness: the product is an agent, and the Codex harness is the implementation layer that makes the agent work.
• (01:05:27) Grant shows the Claude skill output: it turns his notes into a skill file that can be saved, managed, downloaded, edited, and reuploaded.
• (01:06:23) Grant says skills should be iterated in normal language, for example telling the Facebook response skill that it repeats an annoying trend or needs to vary ideas more.
• (01:08:37) Grant lands the auto-shop analogy: the user is the customer, the agent is the mechanic deciding how to act, and the skill is the toolbelt or learned way of doing specific work.
• (01:09:16) Grant simplifies skills again: a skill is a recurring task you can run on demand in any chat, and you can give an agent access to it.
• (01:09:41) Grant defines a plugin as a package containing multiple pieces, such as skills, agents, connectors, hooks, and tools, so a team can install one reusable bundle.
• (01:09:41) Grant approves the audience analogy: if skills are the tools, a plugin is the toolbox.
• (01:10:43) Grant describes his recurring adoption pattern: Anthropic often releases a new concept, he initially thinks it is only for engineers, then weeks later it clicks and he changes his workflows around it.
• (01:11:30) Corey says transferring a ChatGPT project to Codex is possible manually but not plug-and-play; Codex can point to a desktop folder containing the context.
• (01:13:41) Grant says project instructions also need to be transferred manually, likely by saving them as a local file for Codex to reference.
• (01:15:35) Grant shows Codex plugins, using a data analytics plugin as an example that contains many apps or MCP servers/connectors and can install the needed tools together.
• (01:16:30) Corey compares plugins to Claude releases that shook legal and data-tool markets, arguing that bundled plugins can replace work people previously needed dashboard or BI tools for, depending on the company.
• (01:17:02) Grant shows Claude’s plugin browser and legal plugin examples, including legal risk assessment, meeting briefs, contract review, NDA triage, and vendor checks.
• (01:17:39) Grant says a plugin is what you create when you have multiple skills and connectors around a project and want to package that setup for yourself, your team, or a marketplace.
• (01:19:10) Corey says skills can unlock major productivity: his sales-team skills session produced about 100 ideas and an estimated 1,000+ hours saved per year in that meeting alone.
• (01:19:39) Corey says skills are useful in personal life too, such as a dinner-decision skill that knows the restaurants and foods you like.
• (01:20:21) Grant shows the Build iOS Apps plugin in Codex, which bundles about nine skills plus the Xcode build MCP so users can build iOS apps without assembling the workflow themselves.
• (01:20:21) Grant defines connectors as outside app connections that let AI talk to tools like Gmail, Google Drive, Linear, and Slack.
• (01:22:44) Grant highlights Claude’s connector permissions, separating read-only tools from write/delete tools so users can allow safe reads and require approval for risky actions.
• (01:23:47) Grant says both major tools appear to have plugin creators, letting users bundle their skills together; Corey jokes that whichever company has a useful idea first, the other will have it in four weeks.
• (01:25:13) Grant gives the full decision tree: project for ongoing work, custom GPT/Gem/agent for reusable assistants, skill for repeatable process, agent for actions across tools, connector/MCP for app access, plugin for packaged setup, loop for checking/fixing/retrying.
• (01:27:50) Grant suggests taking messy notes from chat, dropping them into a chatbot, and asking it to clean them up or turn them into a graphic.
• (01:28:39) Grant defines a loop as a repeated process where AI checks state, acts, verifies whether it achieved the goal, improves, and tries again until a stopping point.
• (01:28:39) Grant says the new “/goal” feature is a way to set up a repeatable loop so AI keeps working toward a goal instead of stopping after one response.
• (01:29:29) Corey explains prompt versus loop: a prompt is ask-once-answer-once, while a loop does the work, validates the result, receives recommendations, and keeps going until told to stop.
• (01:29:59) Corey warns that loops have problems and recommends telling them to run a fixed number of passes, especially for code cleanup or reviews.
• (01:30:21) Grant introduces subagents as specialist workers inside a larger task, such as one agent mapping files, one writing a fix, one reviewing security holes, and one checking against docs.
• (01:31:26) Corey says he uses a “product team” of subagents: UI designer, product manager, UX specialist, and backend specialist that return a combined report before he tells the main agent to build.
• (01:32:07) Grant says a strong subagent setup needs at least two roles: one writer and one verifier, because the agent that wrote the work will tend to think its own output is correct.
• (01:32:34) Grant says using Claude to verify ChatGPT and Gemini to verify Claude is a good manual version of subagent cross-checking, while Codex and Cowork can also do subagents in one chat.
• (01:33:27) Corey says vibe coding has improved dramatically since December; the app he built the previous night worked from one prompt, and subsequent prompts were feature additions rather than fixes.
• (01:34:05) Grant names the new problem “featuritis”: once you can make anything, the hard part is being reductive and taking features out.
• (01:34:42) Grant tells viewers to create a skill for a daily process the AI can reasonably complete end-to-end when given constraints, goals, format, and code checks if needed.
• (01:35:36) Corey says understanding skills was a pivotal AI unlock for both of them, even though skills are a feature using AI rather than “AI” itself.
• (01:36:09) Corey answers a runaway-loop question by saying long-running loops can be risky because running longer is not automatically better, especially when cost is involved.
• (01:36:38) Corey recommends quantitative exit conditions, such as “do this three times,” so the loop exits predictably instead of chasing a subjective standard forever.
• (01:37:23) Grant says he has not personally had runaway-loop problems because he uses loops manually through Claude goals, and those often under-complete before they overrun.
• (01:38:22) Grant says a goal needs clear exit criteria: define “done looks like this,” often by first creating a plan and saying done means the plan is fully implemented end-to-end.
• (01:39:22) Grant warns API users to be more careful with loops because they are paying per token, so they should set stop conditions like “if you’ve done this more than five times, stop.”
• (01:39:57) Corey adds that if a loop reaches 98% or 99.6%, it should stop instead of fighting for a theoretical perfect score with diminishing returns.
• (01:40:13) Grant recommends adding the human into the loop as a checkpoint, such as sending the work to Slack after three passes for review.
• (01:40:31) Corey surfaces a “killer point” from chat: models can choose which skill to fire once a skill exists, but they cannot yet notice repeated manual work and proactively suggest making it a skill or agent.
• (01:40:56) Corey says he wants tools to say, “you’ve done this like seventeen times, would you like a skill?” and then create it with one click.
• (01:41:28) Grant says the likely reason this meta-layer is missing is that memory systems are imperfect, though tools can search prior chats.
• (01:41:58) Grant proposes a workaround: create a skill that checks prior chats at the start of a request, detects repeated patterns, and suggests making a new skill after a chosen threshold.
• (01:43:28) Grant says Codex automations can help keep chat history cleaner because scheduled automations that run and find no matching criteria can auto-archive.
• (01:45:16) Corey says agents feel intimidating at first, but people familiar with Make or workflow automation will understand them quickly.
• (01:45:40) Corey advises beginners to use natural-language agent construction tools rather than diving straight into advanced tools like n8n.
• (01:46:33) Corey says an OpenAI Drive-like cloud system would be useful for organized project work but complicated because it competes with cloud providers.
• (01:47:41) Corey reads “customer controlled cloud infrastructure for long running agents across software and knowledge work” and says it feels like one piece of that broader project-storage puzzle.
• (01:48:07) Corey says Codex having its own docs, sheets, and slides plugins, alongside Microsoft and Google versions, is part of what organized AI project work will require.
• (01:48:31) Grant says you can automate saving work to external storage by connecting Google Drive and asking the AI to create files there with permission approval.
• (01:50:02) Corey says he wants one shared library across ChatGPT and Codex for every image and document a user uploads, so assets are accessible from both places.
• (01:50:56) Grant says Codex can create local desktop folder hierarchies for project management because it has access to the computer’s file system.
• (01:53:30) Grant starts a live demo of a Claude-built “RuneScape for squirrels” game made with the controversial Fable model.
• (01:55:09) Grant uses “/goal” to ask Claude Code to add camera rotation and zoom to the squirrel game, then writes explicit completion criteria for a usable 360-degree view.
• (01:56:29) Grant clarifies that “/goal” is about the loop heartbeat, not merely the initial prompt; it keeps working until the completion criteria are met.
• (01:57:42) Grant tells viewers to use the high-cost model while it is still available cheaply on subscription plans because it may become more expensive or less available soon.
• (01:59:47) Corey suggests a concrete game improvement: mark the current quest goal on the minimap with an obvious colored dot or arrow.
• (02:01:12) Grant queues a second goal for the game: mark goals on the minimap, make tree-bridge layers walkable underneath like real bridges, and add more trees.
• (02:03:00) Grant reloads the game and confirms the zoom feature works, making the squirrel easier to see.
• (02:04:05) Grant identifies more gameplay feedback while running from enemies: add a limit to how far enemies can chase and reduce how far away they detect the player.
• (02:05:38) Grant says the team will turn the live stream into a helpful written guide so viewers can follow along after the stream.

Start here: the simple map

The episode’s purpose lands at 4:42: Corey explains that Skills, Projects, Custom GPTs, and Gems all arrived at different moments in the AI hype cycle, but they still have specific jobs.

That distinction matters. Most beginners try to use one AI feature for everything, then conclude AI is unreliable when the feature was simply the wrong fit.

The first clean decision rule shows up at 25:39:

• Need a place to organize ongoing work? Use a Project.
• Need a reusable assistant with a role? Use a Custom GPT or Gem.
• Need a repeatable process? Use a Skill.
• Need AI to take actions across tools? Use an Agent.

Grant expands that into the full decision tree at 1:25:13, after connectors, plugins, and loops enter the chat:

• Need ongoing context? Project.
• Need a reusable assistant? GPT, Gem, or workspace agent.
• Need a reusable process? Skill.
• Need actions across tools? Agent.
• Need app access? Connector or MCP.
• Need to package skills and integrations together? Plugin.
• Need the system to keep checking, fixing, and trying again? Loop.

That is the cheat sheet for the whole episode.

What an AI Project is

The Projects section starts at 9:38, when Grant shares his ChatGPT Projects sidebar and describes Projects as workspaces.

That matches OpenAI’s official definition. ChatGPT Projects are smart workspaces that keep chats, files, instructions, tools, and memory together for a long-running effort. Claude Projects work similarly: they create self-contained workspaces with chat histories, uploaded knowledge, and project instructions.

Neuron translation: a Project is a folder for context.

Grant says Projects keep “chats, files, instructions, and context together” for one ongoing effort at 10:41. His examples are practical: a launch, weekly newsletter work, a hiring process, or Q3 strategy.

Corey gives the cleanest beginner analogy at 12:46: think of Projects like folders in Microsoft 365 or Google Drive.

That sounds boring, which is why it is useful. A Project does three jobs regular chat struggles with:

• It keeps related conversations together.
• It stores reference files and examples.
• It gives the AI project-specific instructions.

Corey’s example is a quarterly sales report. If the Project contains past reports, company rules, sales procedure docs, and reporting preferences, you can ask the AI to draft the next report without rebuilding the setup every time.

The more important point comes at 13:41: Projects also solve the “chat history chaos” problem. If you use AI all day, your recent chats become a junk drawer. Projects give the work a home.

Use a Project when the work has a name:

• “My job search”
• “My podcast”
• “My Q3 sales reports”
• “My wedding”
• “My Neuron newsletter workflow”
• “My course notes”

The point is continuity. A normal chat is a single conversation. A Project is the place where related work lives.

What Google Gemini Gems are

The Gem section begins at 17:35, when Grant opens Gemini and describes Gems as Google’s version of Custom GPTs.

Officially, Google’s Gem docs tell users to create a Gem by naming it and writing instructions for it to follow. Google recommends thinking through four parts: persona, task, context, and format.

Neuron translation: a Gem is a reusable Gemini helper for one kind of task.

If a Project is the folder, a Gem is the helper you keep calling back.

Grant shows the basic Gem setup at 18:05: create a new Gem, name it, describe what it should do, and choose how it behaves. Around 18:27, he also points out that Gemini lets you choose the model, such as Flash, Thinking, or Pro, depending on the account and interface.

The concrete example is The Neuron’s header-image workflow. Grant created a Gem to make branded header images in The Neuron’s style, then showed where the tool worked and where it failed. At 18:55, he shows one generated image and immediately says it is “horribly wrong.” Corey adds at 19:12 that image models often add too many words to generated visuals.

That is a useful warning. Gems and GPTs are good at repeatable setup. They do not magically make every output perfect.

Use a Gem when:

• You use Gemini.
• You repeat the same task.
• You want the AI to follow the same role or format.
• You want a saved helper instead of rewriting the same prompt.

Good beginner Gems:

• A “study coach” that explains your course notes.
• A “meal planner” that knows your dietary preferences.
• A “sales email reviewer” that gives feedback in your company’s tone.
• A “YouTube title brainstormer” that follows your channel style.

The fastest way to understand Gems: they save the assistant setup.

What Custom GPTs are

The Custom GPT discussion starts around 15:30, when Grant moves from a Project folder to the GPTs section in ChatGPT.

OpenAI’s GPT builder docs describe GPTs as configurable ChatGPT assistants. You can give them instructions, upload knowledge, enable capabilities like web search or data analysis, connect apps, define actions, and manage versions.

Neuron translation: a Custom GPT is a reusable version of ChatGPT designed for one job.

The workplace use case lands at 16:34. Corey says Custom GPTs still have value when you want other people on your team to do something the same way without changing the prompt.

That is the key difference from personal chat. If you build a GPT for your team, you can lock in the instructions, examples, and output format. People can use the assistant without touching the setup.

Grant’s version at 20:41 is simple: Custom GPTs are good when you have a specific task that needs to be “really dialed in” and you want to hit go.

OpenAI’s docs break a GPT into a few main parts:

• A name and description, so users know what it does.
• Conversation starters, so people know how to begin.
• Instructions, which define behavior, tone, structure, and what to avoid.
• Knowledge files, which provide source material.
• Capabilities, such as web search, image generation, canvas, and data analysis.
• Actions, which let the GPT connect to external APIs.

Grant gives the practical warning at 21:32: if you are using GPT actions to make it do complicated work outside ChatGPT, you may be moving into agent territory.

That is the difference beginners need:

• A Custom GPT is best for reusable behavior.
• An Agent is best for multi-step action.

Use a Custom GPT when:

• You want a reusable assistant inside ChatGPT.
• You want other people to use the same setup.
• You have instructions and reference files.
• The task is repeatable, but does not require heavy automation.

Good beginner GPTs:

• Resume reviewer.
• Brand voice editor.
• Customer support draft assistant.
• Internal policy explainer.
• Sales call prep assistant.
• Research brief generator.

Custom GPTs and Gems are cousins. Gems live in Google’s world. GPTs live in OpenAI’s world. For beginners, the category is the same: reusable custom assistants.

What an AI Skill is

The Skills section starts at 26:28, and this is the part where the episode starts to click.

Corey gives the first beginner definition at 26:37: “A skill is essentially... a saved workflow.”

Anthropic’s official Skills announcement defines Skills as folders that include instructions, scripts, and resources Claude can load when needed. OpenAI’s Codex Skills docs use similar language: a skill packages instructions, resources, and optional scripts so Codex can follow a workflow reliably.

Neuron translation: a Skill is a reusable playbook for how the AI should do a task.

Grant sharpens the definition at 28:17: a Skill stores the process, structure, quality bar, must-haves, and things to avoid related to a workflow.

That “quality bar” part matters. A good skill does more than say “write this.” It says:

• Here is the format.
• Here is the process.
• Here is what good looks like.
• Here is what to avoid.
• Here are examples.
• Here are scripts or tools to use when deterministic behavior matters.

At 29:11, Grant explains that skills can save formatting, constraints, and even Python scripts. Corey’s analogy is perfect: “macros in an AI.” Very fancy macros, but macros.

That makes Skills different from prompts. A prompt is what you type once. A Skill is the saved process the AI can reuse.

The best practical rule appears at 52:24: if you do something more than twice, turn it into a Skill.

Corey adds the lived version at 52:43: if you might need the same process three months from now, you will never find the exact chat where you got it right. Make the skill while the workflow is fresh.

Use a Skill when:

• The task has a repeatable process.
• The output has a specific format.
• You keep correcting the AI the same way.
• You want the workflow to travel across tools.
• You want the AI to load the right process automatically.

Good beginner Skills:

• “Turn a transcript into show notes.”
• “Write my weekly executive report.”
• “Format customer interviews into research notes.”
• “Create YouTube B-roll image prompts in my style.”
• “Convert raw notes into a newsletter draft.”
• “Clean a spreadsheet using this exact process.”

The important distinction: Custom GPTs and Gems define the assistant. Skills define the workflow.

The live Skill demo: making a B-roll sketch generator

The most actionable demo starts at 42:46.

Corey explains that he had started making YouTube Shorts for The Neuron and wanted quick sketch-style B-roll images to pop on screen for a few seconds. Once he had a visual style he liked, he wanted to save it so he could request that same kind of image later.

At 43:46, he gives ChatGPT a natural-language request: create a skill that generates images in this style and orientation when he asks for a “B-roll sketch.”

That is the moment beginners should watch closely. He does not manually write the skill file. He tells the AI what workflow he wants preserved.

Grant explains the behind-the-scenes helper at 44:29: the Skill Creator skill knows how to create the files and package them into something installable.

Corey then installs the new skill at 46:07, tries it in chat, and invokes it at 47:37 with a rough prompt: use the B-roll skill to create a sketch showing the difference between a skill, a project, and a Custom GPT.

The useful lesson is at 48:35: the skill saves him from restating the full image spec every time. He no longer needs to type “make a 9:16 sketch on an off-white background with a little boy with spiky black hair...” He can just say “use the B-roll skill.”

That is the whole point of Skills: reduce repeated instruction friction.

There is also a practical limitation at 49:23. Grant explains that if you want a skill to use reference images consistently, you may need to put those reference files inside the skill folder manually or use a desktop agent like Codex to move them into the right place.

Beginner takeaway: Skills can store far more than prompt text, but the file-management side still gets clunky.

Where to find Skills in ChatGPT and Claude

Corey shows the ChatGPT Skills area at 51:10. In his account, Skills live in Settings. He shows installed skills, personal skills, and skills shared inside the company workspace.

The better creation workflow appears at 52:06: Corey prefers to get the result right in a normal chat first, then say, “Okay, that’s the one, make that a skill.”

That is the right workflow for beginners. Do not create a skill from a vague idea. Create a skill from a working process.

Grant then shows Claude’s version at 53:02. In Claude, you can browse skills, create a new skill, write the instructions directly, or upload a skill you created somewhere else.

The portability discussion starts earlier at 40:28. Grant answers a viewer who asks whether they should avoid dependence on one provider. His answer: yes, and that is why Skills matter. A skill is a portable workflow file you can bring from Claude to ChatGPT or Codex, when the platform supports the same skill format.

That is why Skills may be the most underrated piece of the whole episode. A Project is useful inside one tool. A Skill can become portable process infrastructure.

How Skills differ from Agents

The clearest Skill-versus-Agent distinction starts at 54:13, when Grant answers a viewer question: how is a Skill different from an Agent?

His answer: think of the Skill as the prompt, structure, instructions, and intent you give to the Agent. The Skill is the reusable process. The Agent is the system that can use it.

Corey makes it even plainer at 56:51: an Agent requires a trigger, tool use, verification, and a larger task flow. A Skill is saving a specific workflow.

Then he gives the practical test at 57:18:

• If Corey wants to do something hands-on, he uses a Skill.
• If he wants something to appear in his inbox every morning, he uses an Agent.

His example agent wakes up at 5:30 a.m., calls the YouTube API, gathers information from specific channels, analyzes the data, creates a report, saves it as a PDF, and emails it.

That is not a saved prompt. That is a multi-step automated workflow.

Simple version: Skills know how. Agents go do.

What an AI Agent is

The direct Agent definition lands at 1:00:23: “An agent, you can think of it as an AI that can take actions towards a goal.”

That lines up with OpenAI’s official Agents SDK docs, which define agents as applications that plan, call tools, collaborate across specialists, and keep enough state to complete multi-step work.

Neuron translation: an Agent is AI that can pursue a goal through steps.

Grant’s examples at 1:00:42 include:

• Research a topic and build a spreadsheet.
• Review files and draft updates from a source document.
• Fix a coding issue.
• Review a pull request before shipping it.

An Agent needs more than a prompt. It needs:

• A goal.
• Instructions.
• Tools.
• Permission boundaries.
• State, meaning it can remember what step it is on.
• A way to decide what to do next.
• Often, a human approval point.

The beginner safety rule: give agents tasks you would let an intern start, then review before anything irreversible happens.

Agents are useful because they act. Agents are risky for the same reason.

For more on agents, read our beginners guide to agents here (video).

Codex, Claude Code, and why “code” is an intimidating name

The Codex tangent starts at 34:46, when Grant challenges people who have only used ChatGPT to try Codex.

Corey’s line at 35:09 is the memorable one: “ChatGPT Codex is ChatGPT on the juice.”

The beginner caveat appears at 35:32. Corey says it is a bummer that Anthropic and OpenAI both put “code” in the names of tools that are useful beyond engineering. That word scares off normal people, even though tools like Codex and Claude Code can help with knowledge work, automations, file workflows, and general productivity.

Corey demos Codex at 37:24, showing that you can write prompts just like in ChatGPT. He points out that Codex gives access to automations, sites, plugins, skills, and local computer workflows.

The everyday-work toggle appears at 38:22: Codex can be set to less technical “everyday work” mode so it does not talk like an engineer explaining a haunted vending machine.

One of the most useful anecdotes comes at 39:51. Corey says he opened Codex on his phone while waiting for coffee, told it to fix an app error on his desktop, and came home to the fix already ready on his work machine.

That is the agent shift in one story: the computer becomes something you can delegate to from the coffee line.

What plugins and connectors are

Plugins enter at 1:09:08, after the Skill-versus-Agent section.

Grant defines a plugin at 1:09:41: a plugin packages multiple pieces together, like skills, agents, connectors, hooks, and tools, so you can share the setup with teammates.

OpenAI’s Codex Plugins docs define plugins similarly: they bundle skills, app integrations, and MCP servers into reusable workflows.

Neuron translation: if Skills are tools, a plugin is the toolbox.

Grant shows a Codex plugin at 1:15:35. The example is a data analytics plugin that includes multiple apps. He later shows a “Build iOS Apps” plugin at 1:20:21, which bundles skills and an Xcode build connector.

Connectors are the app-access layer. At 1:21:18, Grant explains connectors as the way to get AI to talk directly to external apps like Gmail, Google Drive, Linear, and Slack.

The permission piece is important. At 1:22:44, Grant shows Claude’s connector permissions separated into read-only tools and write/delete tools. His practical rule: always allow read-only if you trust the connection, but require approval for write and delete.

That is the right mental model for AI permissions. Reading your calendar is one level of risk. Sending an email, deleting a file, or changing a customer record is another.

Use connectors when the AI needs app access.

Use plugins when you want to package several skills, tools, and app connections into one installable workflow.

What loops and goals are

Loops start at 1:28:12, when Grant moves into the advanced section.

A loop is a repeated process. Grant defines it at 1:28:39: the AI checks its state, takes actions, verifies whether the actions achieved the goal, improves, and tries again until it reaches a stopping point.

Corey’s prompt-versus-loop graphic at 1:29:29 is the simplest explanation:

• A prompt is ask once, answer once.
• A loop is do the work, validate it, improve it, repeat.

A “goal” is one way to set that loop in motion. Grant talks about Claude Code’s /goal command at 1:37:23, then explains at 1:38:22 that goal-based work needs an exit condition.

That phrase is load-bearing: define done.

If you tell an agent “improve this,” it can wander. If you tell it “done means the plan is implemented end to end, tests pass, and you stop after three repair attempts,” it has a finish line.

The safety tips land at 1:39:50 and 1:40:13:

• Set a maximum number of attempts.
• Stop when you reach diminishing returns.
• Add a human checkpoint after a few loops.

That last one is the practical version of “human in the loop.” Let the agent work, then make it pause before riskier steps.

What subagents are

Subagents show up around 1:30:21, when Grant references a post about agent loops and specialist workers.

Anthropic’s Claude Code subagents docs define subagents as specialized AI assistants that handle specific types of tasks in their own context, then return the result.

Neuron translation: subagents are specialist workers inside a bigger AI workflow.

Corey gives a great personal example at 1:31:26: he has a product-team suite of subagents, including a UI designer, product manager, user-experience specialist, and backend design specialist. He can run the whole product-management suite and get a combined report.

Grant gives the beginner pattern at 1:32:07: use at least two subagents, one that writes and one that verifies.

Then he gives the human reason at 1:32:34: the agent that writes the thing will often think its own work is great. A verifier gives you a second set of eyes.

This pattern works outside coding too:

• Writer + editor.
• Researcher + fact-checker.
• Planner + risk reviewer.
• Designer + accessibility reviewer.
• Sales drafter + compliance reviewer.

Subagents are how agent systems start to look like teams.

The “featuritis” problem

At 1:33:27, Corey says we are in an era where tools can build surprisingly useful software from a single prompt.

Then Grant names the side effect at 1:34:05: “featuritis.”

Once you realize you can add anything, you start adding everything.

That is the hidden skill beginners need with agents: restraint. The agent can build more. Your job is to decide what should exist.

A good agent workflow includes a reducer. After the builder adds features, ask another agent or subagent to remove clutter, simplify the interface, and identify which features distract from the goal.

The best first action for viewers

The episode gives a lot of tools, but the best first step is not “go build an agent.”

The best first step is: create one Skill for one task you already repeat.

Grant says this plainly at 1:34:42: try to create a skill for something you do every day that AI can reasonably accomplish end to end.

Corey describes the “click” moment at 1:35:36: once Skills made sense, he started looking through old workflows and thinking, “Make it a skill, make it a skill, make it a skill.”

That is the behavior change this episode is really pointing toward. Stop hoarding good prompts in old chats. Turn good processes into reusable assets.

Beginner exercise:

• Pick one task you did this week.
• Find the chat where AI got it right.
• Ask: “Turn this workflow into a Skill I can reuse.”
• Test it.
• Update the skill when it misses something.
• Add a version number when you improve it.

That one habit does more than learning ten new AI terms.

The missing meta-layer: AI should suggest Skills for you

One of the sharpest viewer comments comes at 1:40:31: the model can already pick which Skill to fire once a Skill exists. What it cannot reliably do yet is notice that you keep solving the same problem by hand and suggest making it a Skill or Agent.

Corey’s response is basically: please, someone build this.

Grant sketches a workaround at 1:41:58: create a skill that checks whether you have asked for the same kind of thing before, then suggests turning repeated workflows into Skills.

That is clever and slightly cursed, which makes it a very 2026 AI workflow.

The product version should be native. If ChatGPT, Claude, or Gemini notices you have asked for the same output five times, it should say:

“You keep doing this. Want me to turn it into a reusable workflow?”

One click. Done.

Whoever ships that first will get copied by everyone else about four weeks later, which Corey basically predicts at 1:23:56.

The final demo: using /goal to change a squirrel game

The most chaotic and useful demo begins at 1:53:30, when Grant shows a little squirrel game he built with Claude.

Yes, a squirrel game. Stay focused.

At 1:55:05, Corey suggests adding the ability to rotate the screen so you can see around a tree. Grant turns that into a goal at 1:55:22: add a 360-degree view, zooming, and the ability to switch views.

Then Grant explains why /goal is different from a normal prompt at 1:56:29. The goal sets a looping process in motion. It gives the agent a “heartbeat” so it keeps working until it reaches the specified outcome.

That is an advanced concept, but the demo makes it concrete:

• Normal prompt: “Add this feature.”
• Goal: “Keep working until this feature exists and works according to this definition of done.”

If you're not a software engineer and don't know what you're doing, you should have the AI help you define what "done" looks like using /plan mode. That's what Grant does!

At 2:00:31, the camera work continues. At 2:01:12, Grant adds follow-up goals: mark goals on the minimap and make bridges behave like true walkable bridges.

That is agentic software building in miniature. You test, notice what feels wrong, define the next goal, and let the agent keep working.

The danger, again, is featuritis. The squirrel does not need enterprise resource planning. Probably.

The practical framework: which one should you use?

Here is the full beginner version, cleaned up from the episode.

Use a Project when the work needs a home

Projects are best for ongoing work with context.

Use a Project for:

• A newsletter workflow.
• A course.
• A business launch.
• A research effort.
• A client project.
• A home renovation.
• A hiring process.

Watch: Projects as workspaces, Projects as folders, Project instructions and knowledge.

Use a Gem or Custom GPT when you want a reusable assistant

Gems and GPTs are best for repeatable roles.

Use one for:

• A writing coach.
• A brand editor.
• A tutor.
• A meal planner.
• A support assistant.
• A research assistant.

Watch: Gemini Gems demo, Custom GPT workplace use case, GPTs versus agents.

Use a Skill when you want repeatable process

Skills are best for workflows you already know.

Use a Skill for:

• Show notes.
• Weekly reports.
• Transcript processing.
• Image prompt formats.
• Sales email cleanup.
• Data cleaning.
• Any task you do more than twice.

Watch: Skill definition, formal workflow definition, B-roll skill demo, more than twice rule.

Use an Agent when the AI needs to take action

Agents are best for multi-step tasks with tools.

Use an Agent for:

• Researching and creating a report.
• Monitoring YouTube trends every morning.
• Updating files.
• Sending summaries.
• Working through code changes.
• Moving data between apps.
• Running scheduled workflows.

Watch: agent definition, agent examples, scheduled YouTube report agent.

Use connectors when the AI needs app access

Connectors let AI reach tools like Gmail, Google Drive, Slack, Linear, GitHub, and other apps.

Watch: connectors explanation, permission settings, Google Drive workflow.

Use plugins when you want the whole setup packaged

Plugins bundle multiple skills, app integrations, and connectors.

Watch: plugin definition, data analytics plugin, iOS app plugin.

Use loops and goals when you need repeated improvement

Loops are for “try, check, improve, try again.”

Watch: loop definition, prompt versus loop, define done, human checkpoint, squirrel game goal demo.

The beginner recommendation

Start with Projects and Skills.

Projects solve the most common beginner problems: “Where did all my AI work go?” and "How do I stop repeating myself when I work with AI?"

Skills solve the second-most common beginner problem: “Why do I keep typing the same instructions?”

Gems and GPTs are useful once you know which assistant roles you repeat. Agents come later, when the task has clear steps, clear permissions, requires tool access, and a clear definition of done.

The episode’s deepest idea is that AI work is moving from prompts to systems. A prompt is one request. A Project is a place to store work. A Gem or GPT is a reusable assistant. A Skill is a reusable workflow. An Agent is a system that can act (and use all of those other things, minus maybe the Gem or GPT which could eventually just become a skill or level up to become an agent).

Now, you do not need to master all of them today.

But here's our recommendation: Pick one recurring task. Make the AI do it once. Improve the result. Then turn the workflow into a Skill.

That is the moment AI stops feeling like a chat box and starts feeling like a tool you are teaching to speed up your work.