Playbook
Tasteful Skills
“Tasteful Skills” argues that the best agent skills are not documentation or best-practice lists.
Back to Podcast Digest
Everyone Is Prompting Better. Almost Nobody Is Packaging Work.
TL;DR
The bottleneck isn’t better prompting anymore — it’s packaging repeatable work — Nate B Jones says most people are still cramming reusable processes into prompts, even though in 2026 the real leverage comes from scaffolding agents with skills, plugins, connectors, hooks, and scripts.
His core mental model is simple: prompt once, skill for reuse, plugin for installable workflow — a prompt is for one-off asks, a skill is usually just a reusable markdown playbook for recurring work, and a plugin bundles skills plus tools, assets, MCPs, scripts, and metadata into something a team can share.
Plugins matter because they turn you from the ‘human plugin’ into someone who automates the loop — his memorable line is that if you’re copying from one app, pasting into chat, fetching data elsewhere, and checking outputs manually, you are already doing plugin work by hand.
MCPs and connectors are not plugins — they’re the live data pipes inside them — Salesforce, Slack, Figma, GitHub, dashboards, and other systems become available to an agent through MCPs/app connectors, but the larger workflow package is the plugin.
Deterministic steps should never be left to model judgment — formatting code, validating schemas, checking JSON, running tests, and mandatory review loops belong in scripts and hooks, because the model should not be trusted to merely ‘remember to be careful.’
Non-technical domain experts now have real power to build agent workflows — Nate says this was hard in 2025 but materially easier in 2026, pointing to examples like an editorial review plugin and design workflows connected to Figma, and arguing that the people who know what good work looks like should encode it.
The Breakdown
The real story isn’t smarter models — it’s the “mech suit” around them
Nate opens by saying the confusing middle layer between “the model is smart” and “the work got done” is where the real action is now. His metaphor is great: LLMs need a Darth Vader or Transformers-style mech suit — the scaffolding around the model is what makes real work possible, and understanding CodeX-style plugins is the easiest way to see that.
Prompts are for one-offs, not your whole operating system
His first hard line is blunt: in 2026, a prompt is what you use when you want to do something once. He argues people over-index on prompts and end up wasting “hours and hours and hours a week” by stuffing repeatable processes into text that can’t carry tools, permissions, or shareable workflow logic.
Skills are reusable house style in markdown form
The next layer up is the skill: a reusable way to teach Claude, CodeX, or another tool how your team does something repeatedly. His examples are concrete — pull request review, marketing docs, cold outbound emails — and he frames skills as your house style written down, often in a markdown file, with the warning that once people get this idea, they often create too many skills and need to focus on the 20% driving 80% of value.
Plugins are workflow packages, not little app-store add-ons
Then he zooms out: if a skill is a repeatable method, a plugin is the larger package around it. A plugin can include skills, app integrations, MCP servers, hooks, assets, commands, and metadata, all wrapped into something installable and team-shareable — his Salesforce outbound example is the clean illustration of where a skill ends and a plugin begins.
“You are the human plugin” if you’re still doing the glue work manually
This is the video’s stickiest line. If you’re moving data from one app to chat, asking the model to reason, checking the output, and bouncing back to another system, Nate says you are literally acting as the plugin yourself — which is why he insists non-engineers should stop assuming this is out of reach.
MCPs are the plugs; scripts and hooks are the guardrails
He distinguishes MCPs and connectors as the way agents access live systems like Salesforce, Slack, GitHub, or Figma — more like internet plugs than workflow packages. Then he makes the safety-and-reliability point: tests, schema validation, formatting, JSON checks, and review gates should be deterministic scripts or hooks, not vibes-based requests for the model to be careful.
The big shift: package bounded workflows, not giant vague ones
From there he pushes a more strategic idea: stop thinking of prompts, skills, MCPs, and plugins as “battle bots” competing with each other, and think of them as Lego bricks. The real high-value skill is drawing boundaries around the right unit of work — not making one huge customer success plugin, for example, but maybe separate refund, activation, and upgrade plugins.
2026 is the year non-engineers can actually build this stuff
He closes with examples meant to make the point feel practical: an editorial review plugin that gave a first-pass critique faster than a person, design workflows plugged into Figma, weekly business reports built from spreadsheets, Slack, dashboards, docs, and past reports. His thesis is that the “mysterious middle layer” should not stay mysterious — especially for CEOs and other leaders — because the organizations that win will be the ones whose domain experts know when to use a prompt, a skill, a plugin, an MCP, or a script.
Share
Keep Reading
Two Ways to Follow
The Weekly Echo. The inbox-shaped summary of what mattered.
New editorials announced here.
