Source: raw/CLAUDE_SKILLS_FULL_COURSE_2.5_HOURS_Beginner_to_Expert.md Creator: Eliot Prince URL: https://www.youtube.com/watch?v=-DawhgUKiOg Duration: 2:31:58 Platform: YouTube Published: 2026-09-10

Eliot Prince’s 2.5-hour course takes a no-code Claude user from “what is a skill” to a five-skill SEO “department” that runs under an orchestrator and is packaged as a plugin. He builds every piece live in the Claude desktop app: a wrapped-prompt audit skill, a blog-writer skill trained on his own expertise, a recorded client-report skill, a connector-driven strategy skill, the chain that links them, the manager on top, and a separate brand-voice skill with evals. The useful parts are the frameworks: two skill types, five levels, three ways to build, and six rules for quality. Each comes with a worked example. Eliot says he has built 450+ skills and taught 3,000+ students; both are creator claims.

Dated UI (published 2026-09-10)

The course was recorded before Anthropic merged chat and Cowork into one Claude on 2026-09-16 (Claude Cowork § One Claude). Every “switch to Cowork mode” step below describes the two-mode UI of August and early September 2026. After the merge there is no mode to pick; where the Turn into skill and Record a skill entry points now sit has not been checked.

Key Takeaways

  • A skill is a saved SOP Claude runs on command. A process written down once (often a prompt you already trust) that Claude follows the same way every time. It fires two ways: pick it from the / menu (certain to load), or phrase a request close enough to its trigger phrases that Claude loads it on its own.
  • Anatomy: description, SKILL.md, reference files. The description says what the skill does and lists trigger phrases. SKILL.md holds the step-by-step instructions. Reference files (templates, checklists, scripts) are fetched only at the step that needs them. Eliot’s split: SKILL.md holds the decisions (job order, what good looks like, what it must never do); references hold the supporting detail (long worked examples, the full style guide, schemas, good and bad examples).
  • Two types. Deterministic skills (audit, invoice, monthly report) produce a templated output and fail loudly, so they are the easiest to build and fix. Non-deterministic skills (brand voice, thinking frameworks, second opinions) carry judgment and taste, fail quietly, and need longer training. “More of an art than a science.”
  • Five levels, which are not a scoreboard. (1) Wrapped prompt, runs with no input. (2) Ask, needs your input or answers. (3) Connect, pulls from or pushes to outside tools through connectors. (4) Chain, skills hand off to each other. (5) Orchestrator, a manager skill that picks which skills to run toward a goal. Eliot: a level-1 skill that saves two hours a week beats an over-engineered level-5 system that needs constant troubleshooting. Most people stop at levels 1-2.
  • Three ways to build. (1) Give a dialed-in prompt to the built-in skill-creator and ask it to wrap it. (2) Start cold: run the process in Cowork with your expertise plus research, test it on a real input, iterate until the output is right, then turn that conversation into a skill. (3) Record a skill: screen-record yourself doing the task while narrating (Cowork only). Eliot calls way 2 “probably the best way”.
  • Capture the process at the moment the output is right. The first run with AI is often slower than doing the job by hand. The payoff comes from saving that session as a skill so you never repeat the back-and-forth.
  • Running the process first is what surfaces the house rules. The blog-writer skill only learned its rules (no em dashes, title-case H2s, numerals, on-the-nose titles, a standard FAQ) because Eliot tested the SOP on a real transcript before saving. “A lot of people just bake the Claude skill and then it will fall down because they haven’t tested and refined the process.”
  • Six rules from good to great: one skill, one job; keep SKILL.md tight (around 500 lines is a common guide); write code for the mechanical bits; build from work you have already done well; include 3-5 examples of excellent output; stop skills fighting each other over triggers. Full list below.
  • Chains need persistence. Linked skills (audit, strategy, blog, report) need history to work from. Run them inside a Claude Project, in Cowork on a dedicated client folder, or against a Notion database that stores every output.
  • Default chain hand-offs to “offer, then wait”. Eliot sets each skill to offer the next one rather than auto-run it, and lets the report skill recommend next steps without invoking them. Use auto-chaining only when the next step always follows.
  • The orchestrator’s own test. The generated “SEO department” skill contains the line: “If you run the same skills in the same order every time, you failed. You are then a chain with extra steps. A chain does not need a manager.”
  • Plugins are a filing system and a shipping box. A plugin bundles skills, their reference files, the connectors they need and a README. Someone who installs it is told which connectors to connect. Building one is a plain-language request; afterwards, delete the loose copies of the skills so each one does not exist twice.
  • Test a skill against no skill. Run the same job with and without it and compare. The skill-creator does this itself as evals. In the voice-skill demo, Eliot reports a pass rate of about 97% with the skill against 50% without, at 126.5 s versus 28.9 s and a higher token cost.

The frameworks

Two types x five levels

DeterministicNon-deterministic
OutputSame template every timeVaries by situation
ExamplesAudit, invoice, monthly report, SEO blog templateBrand voice, thinking frameworks, second opinions
How it failsLoudly (missing column, wrong numbers)Quietly (looks fine, slowly drifts)
Build effortLowestLonger; constant tweaking
LevelNameWhat it addsCourse example
1Wrapped promptRuns on a trigger, no extra inputSearch visibility audit (give it a URL)
2AskNeeds your input or answers to questionsSEO blog writer (needs a transcript)
3ConnectConnectors pull data, push output, or drive a toolClient report (Claude in Chrome, Gmail, Google Drive); 6-month strategy (Apify, DataForSEO, Firecrawl, Notion); morning inbox triage in Gmail
4ChainSkills hand off findings to the next skillAudit → strategy → blog → report, looping back
5OrchestratorA manager that turns a plain-language goal into a sequence of skills”SEO department”

Types and levels combine freely: any level can be either type.

The six rules (plus three gotchas)

  1. One skill, one job. The most common structural mistake is one “SEO skill” that audits, writes and reports. When output disappoints, split the job, for example into a content audit and a technical audit. Eliot splits further only when a skill is struggling.
  2. Keep SKILL.md tight. Some people recommend about 500 lines. There is no hard number, but longer instructions drift more. Move templates and long material into reference files.
  3. Write code for the mechanical bits. “I will never get Claude to do maths directly.” Have it build the spreadsheet with formulas, or scripts for file conversion, arithmetic, format checks and bulk renames. Keeping scripts as reference files also saves tokens.
  4. Build from work you’ve done well. Wrap a prompt you have already proven, or run the process until the output is right and capture it then. “Make me a skill that writes LinkedIn posts” with no expertise behind it “looks good” but performs badly.
  5. Three to five examples. Put 3-5 examples of excellent output in the references so the skill can compare its work against them, not copy content from them. Eliot admits he skipped this in the course and should have done it for the blog writer and the report.
  6. Stop them fighting each other. Check that descriptions and trigger phrases do not overlap, so two skills don’t compete for the same job.

Gotchas he hit while building (they match Agent Skills Overview § two hard authoring constraints):

  • The description must be at most 1,024 characters. Claude often overshoots. Paste the save error back into the chat and it shortens the description.
  • “Claude” is a reserved word in skill names.
  • A colon or quote inside the description can break the file.

The course build, step by step

Way 1: wrap a prompt (level 1, deterministic)

  1. Check that skill-creator (by Anthropic) is on: Customize → Skills → search “creator”. Eliot says it is on by default.
  2. Invoke it with /skill-creator, or say “build a Claude skill”.
  3. “I’m going to give you a prompt for an SEO audit skill. Take this prompt and wrap it in a Claude skill so that I can fire it at any time.” Then paste the prompt (role, input = a URL, steps, detailed output spec).
  4. Result: a “search visibility audit” skill with a description, trigger phrases and instructions, and no reference files, because none were needed. Claude checked his existing skills so the new triggers would not collide with them. It did not test the skill; Eliot prefers to test personally anyway.
  5. Save skill, then test it in plain language (“can you run an SEO audit on my website?”). The trigger fired. The output was an artifact with a verdict, a score, findings with evidence, a fix list, long-game strategy and 15 pages worth upgrading. Eliot claims this used to take him days.

Way 2: cold start, expertise first (level 2)

  1. State the pain and the outcome, and ask for the process, not the skill. He asked Claude to research current SEO and GEO best practice and write a standard operating procedure (SOP) plus a template before doing any writing. He supplied transcripts of two of his old SEO videos as the expertise layer. Alternatives: a brain dump, SOPs from your Drive, or “quiz me with five questions about my process”.
  2. Run it in Cowork (pre-merge mode), which tracks a multi-step plan. Answer the clarifying questions: platform-agnostic, and deliver as markdown SOP plus templates, not a skill yet, so nothing gets locked in early. The run took about 20 minutes and produced the SOP, supporting evidence, an article template and a publish checklist.
  3. Test the SOP on a real input: a transcript of his “three levels of Claude memory” video, target keyword “claude memory”. The SOP caught itself over-optimizing headings and asked for confirmation on the gaps it could not fill.
  4. Give concrete feedback. He asked for an on-the-nose title (“Claude Memory Clearly Explained (and How to Set It Up)”), the keyword in the first H2, a keyword-rich lower H2, and a five-question FAQ with one- or two-sentence answers. Repeat until the output is right.
  5. Turn it into a skill. In Cowork, the dropdown at the top of the task has Turn into skill, which just pre-fills “Turn this into a skill”. Eliot added direction: accept a transcript, brain dump or any long-form input, and quiz the user for missing inputs and quotable lines before starting.
  6. Read what it captured (here, the house rules) and Save.
  7. Edit conversationally when something is missing. The saved skill had no trigger phrases. He opened it with Try in chat, asked for five core triggers (“turn this transcript into a blog post”, “help me write a blog post”, and so on), then clicked Update. In Cowork, the right-hand panel lists which skills a task activated.

Way 3: record a skill (level 3)

Covered in depth in Record a Skill. In this course version:

  • Cowork mode → + → Record a skill. Screen, clicks, typing and voice are captured. The recorder warns you not to show passwords or secrets.
  • He narrated a monthly SEO client report. In Search Console: Performance, compare the last 28 days year over year (“so the data isn’t tainted by seasonality”), read rising and falling queries and pages, export a CSV. Then Google Analytics, and spot-checks in live Google searches. Then a Google Doc with an H1 of ” SEO report”, five bullets (the good, the bad, key insights, opportunities, anything else notable), a one-page write-up framed positively (“reframe it as an opportunity to regain”) and a 30-day plan. Then a Gmail email with the subject ” SEO report”, “Dear ”, two lines, and the report attached.
  • The capture: 199 steps over a 291-second recording, with screenshots and keystrokes matched to the narration.
  • Claude chose the tools. With no Google Search MCP connected, it used Claude in Chrome for Search Console. It used the Gmail connector to draft the email and Google Drive for the doc. Before running, it asked how deep to go and offered to build a dashboard.

Level 3 again: connectors on purpose

  • Add connectors under Customize → Connectors → Discover. Apify connects with an API key from Apify’s Settings → API integrations; Eliot cites 60,000 scrapers and $5 of free credit a month, both unverified creator claims. Semrush connects through its own login.
  • Name the tools in the prompt. His strategy prompt listed a Notion URL as the output destination, plus Apify, DataForSEO and Firecrawl. You can also point a skill at one specific Google Doc, Sheet or Notion database.
  • Wrapping the prompt produced a “6-month SEO strategy” skill. Claude listed “six places I went beyond your prompt, which are the ones worth arguing with”. The first save failed the 1,024-character description limit. The reference files (strategy template, forecasting scripts, tool routing) were missing until he asked for them, so check that a build actually packaged its references.

Level 4: chain them

  1. Name the skills explicitly and say which one pushes to which: “When I kick off a search visibility audit … push its findings to inform the 6-month SEO strategy skill.”
  2. Choose auto-chain or offer-then-wait. He chose offer-then-wait. The audit now ends with a hand-off block and an offer (“Want me to run a 6-month strategy off these findings?”), and the strategy skill’s intake reads “look for an audit handoff before anything else”.
  3. Add the return paths. The blog writer actions the first article from the strategy, but stops to read the brief and asks what it needs, because it is a level-2 skill. The report grades performance against the plan and recommends a strategy review, a blog fix or a targeted audit without invoking any of them. The audit gained a “targeted investigation” mode. The result is a loop, not a line. Claude also wrote up the loop architecture, which the orchestrator later used.
  4. Give the chain memory: a Claude Project, a Cowork folder per client, or Notion.
  5. Mistake to avoid: “build me a full suite of SEO skills” in one go. Get each skill right on its own first. If a two-mode skill starts failing, split it into two skills.

Level 5: the orchestrator

  • Prompt brief: the manager knows what each skill does and where it sits, takes a goal in plain language, states its plan, runs the skills, reports back and asks questions where needed. Use the skills’ real current names.
  • The output, “SEO department”, included routing rules, a rule against re-asking questions the user has already answered, a reporting format and anti-AI-writing patterns.
  • Test: “Can you help me improve the SEO traffic for courchevel.vip?” It read memory and project files to find where the work stood. It noticed the client earns its revenue December to April, and that in September anything that must rank by December has 6-8 weeks to ship. It proposed the audit first with a decision point after, then invoked the audit skill.
  • Eliot’s own account has a marketing orchestrator (“a fractional CMO in a box”) that routes vague requests across brand voice, keyword research, positioning, direct-response copy, a newsletter writer and a content atomizer. His full SEO set is about 15 skills, which is where a manager pays off most.

Package it as a plugin

  • “Can we turn my four SEO skills plus my SEO department skill into a plugin with all of the skills included with their reference files, as well as the connectors required … Call it the SEO department plugin.” List the skills by name to be sure.
  • Claude asked which connectors to declare (all of them) and whether to make it specific or a shareable template. He chose shareable, so it genericized the details: “Eliot” became “the operator”, and real sites became example.com.
  • Output: the skills with their references and assets, the MCP and connector declarations, and a README. Save plugin; it appears under Customize → Plugins and is invoked through + → Plugins.
  • Claude warned that each skill now existed twice (loose and inside the plugin), which makes triggering ambiguous. Remove the loose copies.

The brand-voice skill (non-deterministic)

  1. Analyze before building. Run a voice-analysis prompt over your best human-written material: articles, transcripts (natural speech works well), LinkedIn posts, newsletters, customer emails, even WhatsApp messages. AI-written samples teach it nothing. For courchevel.vip he pointed it at the site’s top articles. It analyzed five pages, excluded one that did not read like his writing, and extracted sentence mechanics, vocabulary and structure, marked as evidenced or inferred. It then asked five questions (his I-versus-we habit; editorial pages only).
  2. Build with a second prompt that names the skill (“VIP brand voice”) and supplies your anti-AI-slop list and banned-word list as reference files. His lists cover patterns (runs of three, em dashes, “in a [X] world”, “not just X but Y”) and words and phrases (“it’s worth noting”, “furthermore”). See Anti-AI Slop Guide.
  3. Let skill-creator run evals. It spawned six agents: three with-skill and three baseline runs, graded against the skill’s own rules. Without the skill, outputs failed “no sentence longer than 25 words” and “no em dashes”.
  4. Read the generated skill and cut what’s wrong. Key rule: “Change how it’s written. Never change what it says.” It has three modes (editorial, brand recommendation, partner brief), hard rules (no em dashes, no formal connectives, no paragraph longer than five lines), frequency caps (“hidden gem” at most once per article or per 1,000 words), and a report of what it changed. He deleted an inferred trait (“deflates the luxury”) and replaced it with “luxury is the product, don’t undercut it”.
  5. Train it through use. Collect 10-20 notes on what you dislike, then update the skill in one pass. In the test rewrite of “five reasons to ski in Courchevel”, it chose editorial mode, removed four em dashes and flagged semicolons and exclamation marks. What it still lacked was original story, which has to come from a transcript or from Claude interviewing you.
  6. Use cases: run it over every output (reports, transcripts, emails), or hand it to ghostwriters and sales teams so a personal or company voice stays consistent.

Try It

  1. Pick one prompt you already reuse. Run /skill-creator, wrap it, save it, then trigger it in plain language. You now have a level-1 skill.
  2. For a task with no proven prompt, do way 2: ask for the SOP and template first, test on a real input, give two rounds of specific feedback, then turn the conversation into a skill. Read the captured house rules before saving.
  3. Add 3-5 examples of excellent output to the references of your most-used skill, then run it once with and once without the skill on the same input.
  4. Audit your trigger phrases. Delete vague ones (“write up this transcript”). If you run multiple brands, name the brand in the triggers.
  5. Before chaining, make each skill reliable alone. Then wire one hand-off with offer-then-wait and give the chain a project or folder to keep its history in.
  6. Add an orchestrator only when you have enough skills that you forget which to run. Check that it does not run the same sequence every time.
  7. Bundle a finished set into a plugin with its connectors declared, then delete the loose copies.

Implementation

  • Tool/Service: Claude desktop app (Customize → Skills / Connectors / Plugins); built-in skill-creator; Cowork for multi-step builds and Record a skill; Claude in Chrome; connectors used in the course: Gmail, Google Drive, Notion, Apify, Semrush, DataForSEO, Firecrawl, Kit.
  • Setup: Turn on skill-creator, then connect the connectors a skill will need before building it. To add a skill someone sent you: Customize → Add → Upload skill → Save. Each skill can be toggled off, downloaded, edited in place, opened with Try in chat, or deleted.
  • Cost: No extra cost for skills beyond plan usage. Apify and DataForSEO bill separately (Eliot’s DataForSEO account needed topping up mid-demo). The eval run showed a skill costing more time and tokens per run than no skill.
  • Integration notes:
    • Eliot says skills built in chat or Cowork are also available in Claude Code, but skills built in Claude Code don’t flow back, so he builds knowledge-work skills in Cowork.^[ambiguous] He said this on 2026-09-10, a week before Claude Code v2.1.275 (2026-09-17) shipped the documented claude.ai-to-terminal skill sync (Agent Skills Overview). He may have been describing the desktop app’s Code tab.
    • The companion “Complete Claude Skills Course Guide” (prompts plus “101 skill ideas”, such as a cash-flow narrator, a quote builder and an invoice generator) sits behind his AI Recipe Vault email sign-up (AI Recipe Vault). The guide itself was not ingested.
    • Choosing what to build: “start with the pain”, meaning tasks you hate or that drain you. His guide includes an interview prompt that recommends skills tailored to you.

Not covered here

  • The last ~25 minutes are two older videos spliced in: the “brand print” skill (brand assets folder → brand audit prompt → brand specification → skill that applies logo, colours and fonts to any output) and “5 Claude marketing skills” (director of psychology, trend jack, clipper army, lead magnet, email sequences). Both have their own raw files (raw/The_1_Claude_Skill_I_Can_t_Live_Without.md, raw/5_Claude_Marketing_Skills_I_Can_t_Live_Without_steal_them.md) and are compiled separately. One line from the spliced segment (“Claude Cowork went to all paid plans on mobile and web”) dates from before the September merge.
  • Pitches for the course guide and recipe vault were skipped.

Open Questions

  • After the merge: where do Turn into skill and Record a skill live now that there is no Cowork mode to switch to? Does Record a skill still require the desktop app?
  • Eval pass rate: the caption reads “passes 70 97%”. It is probably 97% against 50% without the skill, but this was not confirmed on screen.
  • “Colon or quote breaks the description”: this is plausibly YAML quoting in the frontmatter, but no first-party source in the wiki states it.
  • Chat/Cowork to Claude Code skill availability before v2.1.275: which surface was Eliot describing?
  • Apify’s “$5 free credit per month” and “60,000 scrapers” were not checked against Apify’s pricing page.