Lesson 8: MCP and plugins, adding outside tools and the cost to check first

After this lesson, you'll know how to plug extra “outside tools” into Claude Code through the MCP standard: have the machine control the Chrome browser, read and label a Gmail inbox, and work with task-management software. Just as important, you'll know the token cost of each item you plug in, and the experienced users' strategy of “try with MCP, lock in with a skill”.

What MCP is, in plain English

In lesson 7 you learned skills: SOPs you write for the machine. MCP (Model Context Protocol) is a skill that someone else has written for you, usually by the team behind a major piece of software. It's a connection standard introduced by Anthropic so outside software can “reach a hand out” to the AI: plug one in, and your machine suddenly knows a new set of actions, like hiring an employee who already knows a certain software well.

Installation is surprisingly easy. Each MCP comes with a short JSON config snippet (find it by searching “software name + MCP server”, or browse directories like mcpservers.org). Paste that snippet into Claude Code with a line like “install this MCP into my workspace”, and the machine handles the rest. For services that need a login (Gmail, task management software and so on), it walks you through getting an API key or clicking an allow-access button, just like issuing an access badge to a new employee. Remember the rule from lesson 5: an API key is the key to the safe. Don't paste it around, and don't show it in screen recordings.

A safety note, stated plainly: MCP directories on the internet are third-party stuff, with uneven quality and safety. Prefer official MCPs from the software's own developer or from Anthropic; obscure ones with few stars and few users shouldn't be plugged into a machine holding business data.

The most worthwhile one to plug in: Chrome DevTools MCP

If you plug in just one, heavy users almost unanimously choose Chrome DevTools MCP: it lets Claude Code control and observe a real Chrome browser. That means the machine opens pages, scrolls, clicks buttons, takes screenshots and reads content by itself.

The business value of this is bigger than it looks: many services have no official connection port for outside software, getting data out of it used to mean hiring someone to sit and click by hand. With Chrome DevTools MCP, the machine can do things like: visit a competitor's page, capture it and summarize the price table; browse e-commerce marketplaces and collect product information by the criteria you set; check that your own website displays correctly on each page. Combined with skills (lesson 7), it becomes the hands and feet for processes that until now “only a person could do because they had to look at a screen”.

The cost of MCP: check with /context before praising it

Now for the part lesson 6 set up. Once you've plugged in a mid-sized MCP (for example, the MCP of a task management tool), type /context and look: its tool-description set alone can eat nearly 20,000 tokens, taking up more room than Claude Code's own built-in toolkit. Before you type a single command, a quarter of the “desk” is taken, and that's the start of the prompt, the highest-quality stretch.

A comparison to make it sink in: a skill loads only the description at the top of the file, and loads its full contents only when called. An MCP loads its whole tool-description set the moment it's plugged in. Connect to Gmail the same way: the MCP version permanently costs thousands of tokens and runs slower; the skill version that calls the API directly costs only a few dozen tokens of description, and in the original course's demo, processing 100 emails was roughly 5 to 10 times faster. (Newer versions of Claude Code have a built-in way to avoid some of this: when an MCP's description is too bulky, the machine only fetches the exact tool it needs. But that's no reason to plug things in carelessly.)

From here comes the two-step strategy of experienced users, and also the most valuable lesson in this one:

1. Use MCP to try things quickly. It installs in a minute, runs right away, and answers the question “can the machine do this, and is it worth doing”.
2. If it's worth doing, convert it into a skill. Tell the machine: “this approach works, now write it as a skill that calls the API directly instead of going through MCP, referring to the format of my existing skills.” You get a version that is faster, cheaper and more stable for long-term use.

A real example from the original course, and the one you should follow: labeling your Gmail inbox. Step one, ask the machine to propose a sensible set of labels (prefer action-based labels: “needs action”, “awaiting reply”, “save for reference”). Step two, plug in the Gmail MCP, let the machine read and label 15 emails as a trial, and if it looks good, run 100. Step three, turn it into a skill that calls the API directly: the measured result was fetching 100 emails in 1 second, then classifying and labeling them in 36 seconds. From now on, clearing your inbox each morning is a single command.

Plugins: good enough to just know

Claude Code also has a whole plugin (open the plugin management section in settings to see them, along with Anthropic's official directory and a few third-party marketplaces). Some are genuinely useful, like Context7 (which compresses the API docs of the tools you often use so the machine can read them in a token-saving way). Others improve interface aesthetics, which the original course instructor himself rated as far weaker than the “reference image + screenshot loop” from lesson 2. The overall view, from both the original instructor and us: the stock version without plugins is already plenty, and the plugin area will likely be folded into skills over time. Knowing it exists is enough, so don't waste time collecting plugins.

Try it yourself before moving on to lesson 9

1. Install Chrome DevTools MCP, tell the machine to open your own company's website, capture it and comment on the home page.
2. Next, send it to a competitor's page to summarize how they present their price table.
3. Do the Gmail exercise: propose a label set and label 15 emails as a trial through MCP.
4. Convert that Gmail process into a skill and compare the speed of the two versions.
5. Type /context before and after plugging in an MCP, and answer for yourself: is this worth the space it takes?

Lesson 9 moves up to orchestration: sub-agents and agent teams. How to split work among “sub-employees” running in parallel, each with its own memory space, and how the 100-email job drops from 36 seconds to a few seconds.