Latest / In The Loop / Claude Skills: How to use them, why they are important & what they are.

Transcript

Claude Skills: How to use them, why they are important & what they are. · In The Loop

• 0:00
  Skills are, in my view, one of the most important and probably
• 0:04
  one of the most underused features in the.
• 0:07
  Cloud ecosystem right now. And even arguably beyond the
• 0:11
  cloud ecosystem, if you're using cloud for anything serious, you
• 0:15
  probably hit. This problem.
• 0:17
  You've got it working exactly how you want it for a specific
• 0:20
  task that has a perfect output, and then the next time you have
• 0:23
  a conversation it's just begotten everything.
• 0:26
  You could copy and paste instructions into the chat every
• 0:28
  time, and many people do this, but that doesn't scale.
• 0:32
  GPTS or clawed projects help, but they're not the same as it
• 0:37
  understanding a process for a specific task, and they fill up
• 0:40
  the context window far too quickly.
• 0:43
  Because you preload them. Full of so much information.
• 0:46
  To it has the information it needs to help you do a task.
• 0:49
  And so you're constantly running out of space in a conversation
• 0:52
  and having to start a new thread.
• 0:53
  The solution is skills. A skill is a set of instructions
• 0:56
  you write once give to claw. Encode your process and your
• 0:59
  preferences, and today we're going to go deep on them.
• 1:03
  We're going to go into the actual principles of context
• 1:07
  engineering and why skills are so important.
• 1:09
  The exact anatomy of a skill file with real examples that you
• 1:13
  can use today and how you can make them and how you can chain
• 1:16
  different ones together and where to.
• 1:18
  Find skills and install them. How they fit alongside MCPS.
• 1:22
  Or plug insurance. And we shouldn't.
• 1:24
  Even bother using them at all, this is in the loop.
• 1:26
  With Jack Horton. Hope you enjoyed the show.
• 1:40
  Before we get into what skills are, I think it's probably worth
• 1:44
  understanding the problem they were built to solve and kind of
• 1:47
  what they consist of. What is a skill?
• 1:50
  Because once you understand that, I think everything will
• 1:51
  start to really fall into. Place so throughout. 2025 AI
• 1:55
  coding agents were getting dramatically better and better.
• 1:59
  Core code could suddenly, you know, build really complex
• 2:03
  systems. They could.
• 2:03
  Read an entire file system. They could.
• 2:06
  Interact with Git. They can run tests, they can
• 2:08
  deploy things, and the capability was obviously there
• 2:11
  to do really cool stuff. But what most people found is
• 2:14
  they hit a wall, and that wall really was the context window.
• 2:17
  We've talked about context engineering before in July 2025,
• 2:21
  and it's the same for even those that are not using core code.
• 2:24
  The amount of times you just run out of space and this happens
• 2:27
  with GPTS. And core projects.
• 2:29
  And what's actually happening here is that every time you want
• 2:31
  Core to obviously know something.
• 2:32
  Whether? It was your, I don't know,
• 2:34
  teams, coding standards, how an API works, the context of the
• 2:38
  market or the business you're working in.
• 2:40
  You basically be pasting lots of information to the chat, which
• 2:43
  essentially crams. Everything into the.
• 2:46
  LLM System prompt which is this big long prompt.
• 2:49
  It gets sent to an LLM that defines, you know, its.
• 2:52
  Purpose. How it should behave?
• 2:53
  What it should? Do and as agents and LLMS get
• 2:57
  more powerful, the list of things that.
• 3:00
  Is included. In that system.
• 3:01
  Prompt is always growing, so there's more instructions,
• 3:04
  there's more tools so the integrations it can use.
• 3:06
  So that system prompt is just ballooning.
• 3:08
  And the problem with that is that the context windows are
• 3:10
  finite. The more you step in there, the
• 3:12
  worse the agent starts to perform.
• 3:14
  It gets slower and more expensive, less reliable, and
• 3:18
  there's a real tension between giving an agent you know as much
• 3:21
  information as possible and making it able to execute
• 3:25
  consistently well. And this insight is what led to
• 3:28
  skills. Agents don't need all of that
• 3:31
  knowledge and information all of the time.
• 3:34
  What they need is the right information, the right ability
• 3:37
  to run a process, or awareness of a process at the perfect
• 3:40
  moment. And so in in about late October
• 3:42
  2025, Anthropic published a blog called Equipping Agents for the
• 3:47
  Real World. With agent skills.
• 3:49
  And they framed. It kind of like this they.
• 3:50
  Said Claude is really powerful, but real work requires
• 3:53
  procedural information and just organizational contacts.
• 3:57
  And as agents become more and more capable, we need more
• 4:00
  composable, scalable and portable ways to equip them with
• 4:03
  that domain specific expertise. And that's what led to agent
• 4:08
  skills, which essentially are an organized set of folders.
• 4:11
  Full of instructions and resources that help agents.
• 4:15
  To basically discover and load the right thing at the right
• 4:17
  time and I think the key phrase. Here is dynamically.
• 4:20
  So these skills. Aren't always there for.
• 4:24
  The agent, they're not sitting in the context window taking up
• 4:27
  space. They only get loaded when
• 4:29
  they're relevant and stay out of the way when they're not.
• 4:31
  And that's A, and that's a fundamental.
• 4:34
  Design. Principle of any modern day
• 4:35
  agent. Really you know and topic is a
• 4:37
  specific. Name for it.
• 4:38
  That's been adopted. Everywhere.
• 4:40
  Which is called. Progressive disclosure so you
• 4:43
  progressively. Disclose more information to the
• 4:46
  agent needs. Only.
• 4:47
  Actually when it needs it. So this progressive disclosure
• 4:50
  happens. In three layers.
• 4:51
  Layer one when Claude starts a. Session it basically preloads.
• 4:55
  Just the name. And the description of the
• 4:58
  skills. So not the full set of
• 5:00
  instructions, just a one line summary.
• 5:02
  You know, maybe 100 tokens per skill.
• 5:04
  So again, a few words. This makes it possible for the
• 5:07
  agent to know, I guess, what is available to it.
• 5:10
  We just talked about this before, the tools that were
• 5:12
  available to this agent and therefore it's cheap enough to
• 5:15
  always have those small. Descriptions loaded.
• 5:17
  Then you've got layer 2 when when essentially Claude
• 5:20
  encounters a task and recognises that one of those descriptions
• 5:23
  is relevant. It then loads that full skill
• 5:25
  file and as a result it will have the complete.
• 5:28
  Rules and instructions that you. Create for it, but only does it
• 5:31
  for that specific skill, not all of the skills.
• 5:34
  So again, you could give it dirty.
• 5:36
  Skills or tools? And it will only.
• 5:39
  Use one of them so again. Protecting that context window,
• 5:42
  and then you've got layer three. If the skill MD file references
• 5:47
  other files in the folder of templates or reference docs or
• 5:51
  scripts, code will actually be able to navigate to those as
• 5:54
  needed. It doesn't read everything
• 5:57
  upfront, it follows it for references.
• 5:59
  So if a process that it's following says use this extra
• 6:03
  doc, it will then go and find that extra dock.
• 6:06
  It won't then load every single skill.
• 6:07
  Think about it like a set. Of instructions.
• 6:09
  Basically layer 1 is like the table of contents, layer 2 is
• 6:12
  that you know, relevant chapter I guess and layer. 3 is the
• 6:16
  appendix. You don't need the whole thing
• 6:17
  every time. So now you understand, you know,
• 6:19
  why we have skills, why they're important and what they're kind
• 6:22
  of made-up of. I think then let's build a skill
• 6:25
  together. And I think the walkthrough.
• 6:27
  Of this. Helps you.
• 6:28
  Really understand what a skill is beyond just me using.
• 6:31
  Kind of abstract words, instructions, because I think
• 6:34
  it's really important to. Understand the mechanics.
• 6:35
  And the specifics here. So if we build 1 together,
• 6:37
  right, you have to picture this. So let's say you write a team
• 6:41
  update every single Friday, and every time you ask Claude for
• 6:45
  help with this, you end up giving it basically the same set
• 6:47
  of prompts every single time. You know, keep it under 300
• 6:49
  words. Lead with wins.
• 6:51
  Plain language, no weird AI, slop language.
• 6:55
  End with the blockers and every few.
• 6:57
  Weeks Cloud does something annoying.
• 6:58
  Maybe it allowed a random sign off or use the wrong language
• 7:01
  again and you have to then. Correct it.
• 7:03
  So here's how you would solve that with skills.
• 7:21
  Now before I get into this, it's.
• 7:22
  This is a few bits of a process here, and it's also important to
• 7:25
  note that on all the cloud interfaces you should have an
• 7:28
  option of just either having a skills creator.
• 7:31
  Or just telling. Claude, create all of this
• 7:34
  process as a skill and review it and collaborate with it.
• 7:36
  Collaborate on this skill with me.
• 7:39
  So you can actually tell it to turn things you've been working
• 7:41
  on into a skill, then review it. But I think for the purposes of
• 7:46
  this discussion, it's still important to understand how to
• 7:48
  create one because it'll give you an in depth understanding of
• 7:51
  what the heck this thing is. So step one would be create a
• 7:53
  new. Folder on the computer, call it
• 7:54
  weekly update or tell Claude to create a folder and call it
• 7:59
  weekly update. Tell it to organise.
• 8:01
  It as it. Sees fit or it.
• 8:03
  Makes sense. Remember the core Co work
• 8:05
  episode we've done I think about 5 weeks back?
• 8:08
  If you haven't listened to that, I'd recommend also listening to
• 8:11
  that alongside this episode. Anyway, Step 2 would be to go
• 8:16
  inside that folder, create a new.
• 8:17
  File and it's a text file, you name it skill dot MD.
• 8:20
  All caps for skill then dot MD. For the extension.
• 8:23
  Step three. You open that file and at the
• 8:25
  very top you're going to give. Cloud 2 piece of information,
• 8:28
  you name the name of the skill and a one line simple
• 8:31
  description of what it does and that's.
• 8:33
  It below that you write actual. Instructions for example.
• 8:37
  Write a concise weekly team update following our style of
• 8:40
  format. Use when the user asks for help
• 8:43
  with a weekly update or. Stand up summary or team status
• 8:46
  report. Now notice that description.
• 8:47
  I've included a few trigger phrases.
• 8:49
  Weekly update stand up. Summary team status report.
• 8:54
  So this gives Claude multiple ways to recognize when this
• 8:56
  skill is needed. So if I then in a conversation
• 8:59
  say I am writing this team status report, it would then
• 9:03
  pull up and use this. This tool or this this?
• 9:06
  Skill Step 4, you would then write the body, which is the
• 9:08
  instructions. So you'd call it a heading
• 9:11
  weekly team update format. And then when asked to write or
• 9:14
  help with a weekly team update, all of these rules and then you
• 9:18
  set the rules out. You can also have areas called
• 9:20
  structure, you know open with a section called wins of the.
• 9:22
  Week. Containing 2.
• 9:24
  To four bullet. Points of complete work.
• 9:26
  You could have tone so don't use AI jargon and weird corporate
• 9:30
  pillar. Keep it in first person.
• 9:33
  You say LEMP, keep it under 300 words and then add a section
• 9:37
  called gotchas. So never use phrases like
• 9:40
  moving. Forward or synergy or circle?
• 9:42
  Back don't sign off saying kind regard because this isn't an
• 9:46
  e-mail. This is going into a Slack
• 9:48
  channel. And that's what a skill file is.
• 9:51
  And the gotcha section is something Anthropic specific
• 9:53
  calls out as one of the highest signal content in any set of
• 9:56
  skills, One of the. Claude.
• 9:58
  Code team members actually wrote that in a in a blog post that
• 10:02
  the highest value thing you could possibly do is build up a
• 10:05
  gotcha section over time so every time Claude makes a
• 10:08
  mistake you can add to it. The skill becomes a living
• 10:11
  document that essentially accumulates your hard won
• 10:13
  knowledge about what goes wrong and how to prevent it.
• 10:16
  So every time you're having a conversation with Claude, say I
• 10:19
  want you to update the skill dot MD file for XYZ skill with.
• 10:23
  These new gotchas and. Again, you're just building up.
• 10:26
  Constant information and knowledge on this.
• 10:28
  And then finally, obviously you. Save the file.
• 10:30
  So that means you've now got a. Folder called weekly.
• 10:32
  Update with a file called skill dot MD inside it.
• 10:35
  You can then install it. And this depends on how you use
• 10:37
  calls. If you're using cloud dot AI, so
• 10:39
  the web interface, you zip that folder, not the file, the actual
• 10:43
  folder itself. Right click the folder, compress
• 10:46
  it into a zip and then go to cloud AI.
• 10:48
  And if you go into settings, you can actually.
• 10:51
  Go into customize and then skills and then you can upload
• 10:54
  the skill using that zip file. If you are using the web
• 10:56
  interface, which I recommend no one do, you should be using the
• 11:00
  Co work interface or core code. But if you are using that you
• 11:03
  need to go and turn on code execution and file creation
• 11:06
  skills. Kind of need that to function if
• 11:08
  you're using. The core code interface.
• 11:10
  It's really easy, you just tell it to do it and it will bash
• 11:13
  command it. It'll just set it up for you now
• 11:15
  if you are. Writing Organization.
• 11:16
  Wide skills you'll probably need to speak to your admin, but you
• 11:19
  can even tell it to make this a personal skill or a team wide
• 11:23
  skill if you're using clouds COA which is the.
• 11:26
  Desktop interface skills can come bundled in plug insurance
• 11:29
  or just upload them through the same settings panel.
• 11:32
  As Claude dot. AI as I said Claude Co work is
• 11:35
  the same agent as Claude code so.
• 11:37
  You can basically ask. It to just do it for you.
• 11:39
  And they've just released a new feature for most people called
• 11:42
  the Skills Creator, which just helps you create a.
• 11:44
  Skill. So yeah, once you've done that,
• 11:46
  every time you start a new conversation, Claude sees all
• 11:49
  the different skills that it's got available to it and it's
• 11:52
  descriptions. That's that layer one.
• 11:54
  It costs almost nothing in context window and capacity and
• 11:58
  then when you say something like here are my.
• 12:00
  Notes for this week's. You know, write up our update,
• 12:03
  it will then load up that skill and it will work.
• 12:05
  Now really quick, really quick note here.
• 12:08
  It could probably be quite attractive to start turning
• 12:10
  everything into skills when that's just not necessary.
• 12:14
  So if it's a one off task, just use prompts.
• 12:16
  If it's a repeatable task that you do a.
• 12:17
  Lot or you need other. Team members to fulfill.
• 12:20
  Then you can make a skill. And when you write.
• 12:22
  The skills. There's a trap.
• 12:24
  You don't need to. Reinstate what Claude as a
• 12:26
  baseline model already knows. Anthropics guidance on this is
• 12:30
  really really direct, so don't tell it how to write Python
• 12:33
  because it knows. How to write Python?
• 12:35
  Don't tell it what good code looks like in general, tell it
• 12:37
  what good code looks like in your specific code base.
• 12:40
  So again, it's about making it contextual and writing it out
• 12:44
  your process that you want. This thing to follow and then
• 12:46
  once you've built a skill, test it.
• 12:48
  Don't just use it once and go, oh, that was good.
• 12:50
  Use the skill. Creator's Evaluation.
• 12:51
  Tools run the skill against different prompts.
• 12:53
  And then don't. Make it too prescriptive so
• 12:56
  there's a difference between. A skill and a.
• 12:57
  Template templates. Break the moment.
• 13:01
  The situation changes. We talked about this last week
• 13:03
  and you'll notice this is all about reliability.
• 13:06
  And consistency. If you write something that is
• 13:08
  if this, then that. It's.
• 13:10
  Going to be. Quite rigid.
• 13:12
  And therefore. If you need to be flexible, it's
• 13:15
  not going to work in the same way.
• 13:16
  So again, Quad and Anthropica are very clear here.
• 13:20
  It's about a skill. Not a template.
• 13:22
  So yeah, that that's how to make a skill and when not to make a
• 13:25
  skill. But I also wanted to talk about
• 13:27
  how to make skills extremely powerful.
• 13:30
  So if you imagine, that's kind of like getting started.
• 13:33
  This is now moving into. Advanced thinking, not because
• 13:36
  it's super complex, but because it makes such an extra impact on
• 13:40
  how you work. And that's skill chains.
• 13:56
  So yeah, the next level is when skills start working together,
• 13:59
  and I'm going to give you an example of four skills that feed
• 14:01
  into each other to form a complete development process
• 14:04
  from a vague idea all the way. Through to tested ship code.
• 14:07
  And it came from a developer called Map Poco.
• 14:10
  And you might be thinking, oh, but I'm not a developer now.
• 14:13
  I'll also provide a couple of extra examples here about.
• 14:16
  Non developer or product focused tasks.
• 14:18
  So the first skill is called. Grooming.
• 14:21
  And I'll read it out in full because I think it's important
• 14:23
  to hear just how simple a skill can be.
• 14:26
  The entire skill body is 3 sentences.
• 14:28
  Interview me. Relentless about every.
• 14:30
  Aspect of this. Plan until we.
• 14:31
  Reach a shared. Understanding.
• 14:33
  Walk down every single branch. Of the decision.
• 14:35
  Tree resolve any dependencies between decisions 1 by 1.
• 14:39
  And finally, if a question can be answered by exploring the
• 14:42
  code base, explore the code base instead, so.
• 14:44
  Three sentences and that's the whole thing.
• 14:46
  And he said Sessions where I called asked him 30-40 fifty
• 14:49
  questions from that tiny skill before it was satisfied that
• 14:53
  they understood the problem. And you might be thinking, gosh,
• 14:56
  that's a lot of typing. But if you've not got super.
• 14:59
  Wispy yet? I recommend you to go and pay
• 15:02
  just a few pounds a month. I think they.
• 15:04
  Also have a pre tier but it's just an amazing basically voice
• 15:08
  tool that you can press a shortcut, it appears and when
• 15:10
  you're finished speaking the text appears in any text box.
• 15:14
  It makes my life infinitely easier.
• 15:16
  But anyway. And then?
• 15:17
  Once the grilling. Is done.
• 15:18
  It'll invoke a second skill, write a PRD.
• 15:21
  So this is a structured multi step skill and apid is a
• 15:24
  product. Requirement document says.
• 15:27
  What people in product write. Before they build something
• 15:31
  so-called. Will then start to ask the user
• 15:32
  for a detailed. Description it'll explore.
• 15:34
  The repo to verify any. Assertions it will interview.
• 15:38
  And once all this is done, this. Document's written.
• 15:40
  It will also submit this as a GitHub issue, so actually raises
• 15:44
  it in the system of record to track work.
• 15:46
  And So what comes out on the other end is a ticket or.
• 15:49
  An item of a a task to be done. With a full document, with a
• 15:53
  problem statement, a proposed solution, detailed stories.
• 15:56
  In the right format, implementation decisions.
• 15:59
  And then it will. Trigger 1/3 skill called the PRD
• 16:01
  to issues. That takes the document and
• 16:03
  breaks it. Into a series of individual.
• 16:05
  Tasks each task. Is essentially A deliverable
• 16:08
  piece of work that the team can work on.
• 16:10
  For example, it will start with. What is most important to start
• 16:13
  on? Usually the things with the
• 16:15
  highest risk to a project. The skill will also establish.
• 16:18
  Blocking relationships between. Tasks.
• 16:20
  So task 3 might depend on task one, but task 2 might be
• 16:23
  independent and should be therefore picked up in parallel.
• 16:25
  So this is really useful if you're running many different
• 16:28
  agents at the same time. For example, this is what a
• 16:30
  product manager and a developer has to be.
• 16:31
  Finally, when it's time to implement, there's a Test Driven
• 16:34
  Development skill. So basically is a process that
• 16:37
  enforces and confirms with the developer what interface.
• 16:40
  Changes are going to be needed. Agreed.
• 16:42
  Therefore, which behaviors we have to test and then enter a
• 16:44
  loop and you can't? Have that thing finished until
• 16:47
  it achieves those sets of behaviours that you were looking
• 16:50
  to. Actually achieve so.
• 16:52
  That's a very. Product centric example that the
• 16:54
  take away here for non developers as well is that.
• 16:56
  This principle. Of chaining works regardless of
• 16:59
  domain, so and even that process.
• 17:01
  We went through. You could build a research
• 17:03
  brief. Skill that feeds into a draft.
• 17:04
  Article skill that feeds into a format for newsletter skill.
• 17:08
  The exact same architecture, discovery, planning, execution,
• 17:13
  each skill picking up where the last one left on.
• 17:15
  And this mechanism is domain agnostic.
• 17:17
  The instructions inside is what makes.
• 17:20
  It specific to your work. Now you might be thinking, gosh,
• 17:22
  it's really exciting, but maybe a lot to get.
• 17:25
  Started on here. Well, there are places for you
• 17:28
  to go find other skills, bring them in and get inspiration.
• 17:32
  I will have one warning. Which is obviously when you're
• 17:35
  downloading things from the Internet that are just very
• 17:38
  public and inside a community. It does present risk.
• 17:41
  So if you bring that straight into your.
• 17:44
  Your environment that you're doing coding from or whatever it
• 17:46
  might. Be.
• 17:47
  You need to make sure that you're going and getting trusted
• 17:50
  verified sources. So just just a.
• 17:52
  A preface that. Super popular ones, probably
• 17:54
  more say, but going on random websites and finding skills and
• 17:57
  downloading them. Will always present some risk.
• 18:00
  So anyway, Anthropic has got an entire skill set of a skill
• 18:03
  library, should I say, on the GitHub reposogithub.com
• 18:07
  Anthropic. Skills.
• 18:09
  You know there's skills by creating word docs, excel
• 18:11
  spreadsheets. PowerPoint presentations.
• 18:13
  PDS. Beyond Anthropic, the community
• 18:15
  is massive now. There are curated collections on
• 18:18
  GitHub with 10s of thousands of stars.
• 18:20
  There are directories listing. Thousands of community skills
• 18:23
  and there's even growing ecosystems of plug in.
• 18:26
  Particularly in core Co work and for those that don't understand
• 18:30
  the difference. Between skills, MCPS and plug
• 18:32
  insurance. There's often a lot of confusion
• 18:34
  here. Think of it in three layers.
• 18:37
  Skills are the knowledge layer, so they tell Claude how to do a
• 18:39
  thing. So a.
• 18:40
  Process or a preference. A skill doesn't connect Claude
• 18:43
  to anything in the external world.
• 18:45
  Just makes it smarter about a. Particular task MCPS.
• 18:48
  To model context protocol are the connection layer.
• 18:52
  They let Claude reach out into your.
• 18:54
  Slack your GitHub repo. Your CRM your.
• 18:57
  Calendar. And plug insurance are basically
• 18:59
  the. Packaging layer.
• 19:01
  A plug in bundles skills, MCPS, other resources together that
• 19:05
  you can just then install in a single gap.
• 19:08
  So instead of separately configuring a Slack MCP, writing
• 19:11
  a skill for how your team uses Slack, and then setting all that
• 19:14
  up manually, you can just. Create a plug in that does all
• 19:16
  of that together. Skills of the brain, MCPS of the
• 19:19
  hands and. Plug insurance the toolbox, and
• 19:21
  the best thing here is that skills aren't just an.
• 19:23
  Anthropic thing. It was published.
• 19:24
  As an open standard in December 2020.
• 19:26
  Five and. Since then it's been adopted by
• 19:28
  loads of tools like Open AI codecs, GitHub Copilot VS Co
• 19:33
  Cursor, Gemini. They're all supporting the same
• 19:35
  format. It's one of the fundamental ways
• 19:37
  that would build a. Lot of new.
• 19:38
  Functionality now. On our product.
• 19:40
  Aligning ourselves with that ecosystem.
• 19:59
  So yeah, let's conclude for today's episode because here's
• 20:02
  the bigger picture. We're in this massive
• 20:04
  transition. From using AI.
• 20:06
  As a conversation. To using.
• 20:07
  It as a library of reliable. Repeated.
• 20:10
  Capabilities and every time you figure out how to get one of
• 20:13
  these things, these systems, these large language models to
• 20:16
  do something well, you can capture that knowledge.
• 20:19
  So it compounds over time, and that's what skills are
• 20:22
  compounding information. That you and your team can
• 20:25
  leverage over time. Skills turn.
• 20:28
  One person's expertise into everyone's.
• 20:30
  Capability your best. Engineers review process
• 20:33
  becomes. A skill the whole team can run.
• 20:36
  Your best writer can be the foundation to how every person
• 20:40
  in your company writes content. So if there's one thing to take
• 20:42
  from this episode, it's this The next time you find yourself
• 20:45
  giving called the same instructions the third time in a
• 20:48
  row, just stop and write skill. We'll look to link everything
• 20:52
  into the show notes. You know, documentation skills
• 20:54
  repos basically as much as. Possible for you to.
• 20:57
  Get started on. Skills anyway.
• 21:00
  That's it for me. I hope you enjoyed the episodes.
• 21:04
  And I'll see you next week.