15:47Jay E | RoboNuggets · Tutorial
Anthropic Just Launched Claude for Small Business
A 15-minute walkthrough of the free 31-skill plugin that wires Claude into your small business ops stack.
June 2ndThe argument in one line.
Printing Press eliminates the token inefficiency of APIs and MCPs by auto-generating lightweight CLIs from any website's network traffic, letting Claude agents automate tools without public APIs.
Read if. Skip if.
READ IF YOU ARE…
- A Claude Code user who regularly needs to automate tasks across apps without public APIs and wants to reduce token overhead compared to standard API integrations.
- An AI engineer building agentic workflows who needs a faster way to scaffold CLIs for multiple third-party tools without writing boilerplate Go code.
- Someone already using Claude agents or Code Interpreter who has hit friction connecting to tools like Skool, MyFitnessPal, Google Ads, or other non-API platforms.
SKIP IF…
- You work exclusively with tools that already have mature, official APIs — Printing Press is solving a problem you don't have.
- You're not comfortable debugging network requests, reading HAR files, or troubleshooting CLI tooling when something breaks in the generation process.
The full version, fast.
Connecting Claude Code to external apps through APIs or MCP servers wastes context � APIs return verbose JSON and MCP tool descriptions preload into every session before you type a prompt, while a CLI returns only what was asked. Printing Press is an open-source toolkit that auto-generates a Go-based CLI, a Claude skill, and an optional MCP server for any website, including ones with no public API like MyFitnessPal, Skool, Google Ads, or Domino's. You record a normal session in Chrome DevTools, export the HAR file, and Claude Code strips the noise, extracts real endpoints, builds the CLI, and bundles a local SQLite mirror of relevant data to avoid IP blocks and repeated calls. The result: token-efficient automation for any tool you already use.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 01:00
01 · Cold open + proof shots
Hook on automating any app even without a public API. Shows Skool-via-Cloud-Code, MyFitnessPal-via-Telegram, then teases a list of community-built CLIs (Google Photos, Google Ads, Mercury, Kalshi, Domino's).
01:00 – 01:44
02 · Why agents need external tools
Most real work lives in the apps we use every day; without a connector your agent is blind. Three connection avenues exist: CLI, API, MCP.
01:44 – 03:50
03 · API vs MCP vs CLI — the token-bill argument
APIs return verbose JSON walls (a lot of tokens for a small ask). MCPs preload every tool description into the context window before you type a prompt — context bloat by default. CLIs only return exactly what was asked, so they're the most lightweight of the three.
03:50 – 04:50
04 · Side-by-side — same task, different token bill
Visual: CLI labelled 'LIGHTWEIGHT', API labelled 'VERBOSE', MCP labelled 'ALWAYS LOADED'. Same task across all three; CLI wins on context economy for general-use cases.
04:50 – 05:50
05 · The catch — CLIs have to exist first
OCR caption: 'Only problem with CLIs — they have to exist first.' Historically a developer had to build them. Pivot: 'lucky for us… we can now build them ourselves' with Printing Press.
05:50 – 07:01
06 · What Printing Press is
Tour of printingpress.dev — a toolkit (set of skills for your agent) that auto-prints a token-efficient Go CLI, a Claude Code skill, an OpenClaw skill, and optionally an MCP server from any website. The site itself shows starter prompt recommendations.
07:01 – 08:00
07 · Install it personalised, not generic
Pro tip: don't just install the repo — feed Cloud Code the link plus the prompt 'what are the top 3 CLIs that I can print based on all you know about me?' and let it suggest based on your actual stack (YouTube analytics, Substack, Todoist were Jay's).
08:00 – 08:26
08 · Browsing the community library
Second repo: printing-press-library, a growing community catalog. CLIs already exist for Notion, Slack, Linear, Fireflies, Google Ads, Klaviyo, Trigger.dev, Domino's, Ahrefs, AllRecipes, and more. Recommendation: let Cloud Code triage the library for you.
08:26 – 09:03
09 · Mid-roll CTA — RoboNuggets community
Hard pivot to the sponsor/community pitch: 'going from just using AI to getting paid for it'. Members get live build sessions, templates from the video, and first-client wins. Brief, then back to teaching.
09:03 – 10:02
10 · The 5-step Printing Press framework
Jay shows the HTML slide he had Claude generate to explain how Printing Press works: a five-stage process — Capture (HAR) → Sniff (browser-sniff) → Generate → Mirror (SQLite) → Run (one binary).
10:02 – 11:02
11 · Step 1 — Capture (the HAR file)
The only manual step. Open Chrome DevTools → Network tab → enable 'Preserve log' → perform the action you want to automate (e.g. logging a meal in MyFitnessPal) → right-click → 'Save all as HAR'. That HAR is an HTTP Archive — a JSON-formatted log of every network call made on the page.
11:02 – 11:42
12 · Steps 2–3 — Sniff & Generate
From here Cloud Code drives end-to-end. Printing Press reads the HAR, picks out the real API calls, drops the noise (ads, trackers), groups endpoints by topic, and auto-builds three things from the spec: a CLI tool, a Claude skill, and (optional) an MCP server. Same logic, three interfaces.
11:42 – 12:42
13 · Step 4 — Mirror (local SQLite cache)
The clever bit. Printing Press bundles a local SQLite mirror of a hand-picked subset of the source's data (e.g. ~200 foods you've actually used out of MyFitnessPal's 14M-food catalog, ~5MB on disk). Searches happen on your machine in ~50ms — no rate limits, no IP blocks, no network round-trip. Jay's analogy: 'like Spotify caching your library — not the whole catalog.'
12:42 – 13:20
14 · Step 5 — Run + invoke from agents
Final stage: one binary file. Type a command, get the answer — no Python install, nothing else to set up. Invoke it as a slash command, in natural language to Cloud Code, on a schedule, or (Jay's setup) through a Telegram agent that calls the CLI for him.
13:20 – 13:32
15 · Outro + subscribe ask
Wrap-up: if you've got a tool you can't connect to your agents, printingpress.dev may be the unlock. Subscribe ask, sign-off.
Lines worth screenshotting.
- CLIs are the most token-efficient way to connect an AI agent to external tools because they return only the exact data requested rather than a verbose JSON payload.
- MCPs preload all their tool descriptions into the context window before any prompt is typed, consuming tokens even for tools not used in that session.
- Printing Press auto-generates a Go-based CLI, a Claude skill, and an MCP server from a DevTools HAR recording — turning any website into an agent-accessible tool without a public API.
- Skool, MyFitnessPal, Google Ads, Domino's, and Mercury are all now automatable via Claude Code CLIs even though none of them have published public APIs.
- A HAR recording (HTTP Archive from Chrome DevTools) captures all the network calls a website makes, which is the raw material Printing Press uses to generate the CLI.
- The community library of pre-built Printing Press CLIs means a developer does not need to generate their own for popular tools — they can install an existing one immediately.
- Asking Claude Code to recommend the top three CLIs to print based on your specific workflow — rather than blindly installing everything — is the personalization step that makes adoption practical.
- The existence of a Domino's CLI (allowing an agent to order pizza on command) is a memorable proof-of-concept that makes the abstract capability of agent-to-app connection immediately tangible.
- A CLI that returns only the last three YouTube videos from a channel uses a fraction of the tokens an MCP tool would consume for the same request.
- The publishing of Printing Press as an open-source project democratizes the creation of agent-to-app connections, which previously required dedicated API access or complex MCP setup.
- An agent connected to Skool via a custom CLI can query member posts and engagement data from inside Claude Code — turning a closed platform into an observable data source.
- The three connection options (CLI, API, MCP) each have different token footprints and setup costs — CLI wins for established workflows, MCP wins for discovery and discoverability.
Steal the format — and the framing.
Cloud Code automation playbook
Reframe MCP-vs-CLI as a context-tax argument, then teach a 5-step pipeline where only step 1 is manual — that's the whole video.
- Lead with a token-economy mental model before naming the tool. Jay spends 4 minutes on CLI-vs-API-vs-MCP context cost before he ever opens printingpress.dev — that earns him the right to pitch a specific solution.
- Show proof shots in the first 30 seconds, not at the end. Two screen-recordings (Skool query + MyFitnessPal logging from Telegram) close the 'does this actually work?' objection before he even explains what Printing Press is.
- Have Cloud Code generate your teaching slides. Jay says the 5-step framework slide was an HTML page he had Cloud Code build for him — that's a reusable production pattern for Joe's own dev tutorials.
- Bury the CTA in the middle, right before the payoff slide. The RoboNuggets pitch comes at 8:26 and earns its place by promising the framework breakdown is still coming. No bottom-of-video pitches.
- Use 'lucky for us, we are living in the future' as a pivot phrase. It's the cleanest 5-word turn from problem statement to product reveal Joe has seen all month.
- When something has multiple interfaces (CLI + skill + MCP), pitch the interface, not the engine. 'Same logic, three interfaces' is exactly how Joe should describe Mod Producer / ShowRunner / etc when one engine drives many surfaces.
Terms worth knowing.
- CLI (command-line interface)
- A text-based way to interact with a program by typing commands in a terminal — used by AI agents to call external tools with minimal overhead compared to graphical interfaces or verbose APIs.
- API (application programming interface)
- A set of rules that lets one software application request data or actions from another — often returning verbose structured output (typically JSON) that can consume significant AI context tokens.
- MCP (Model Context Protocol)
- A standardized protocol developed by Anthropic that allows AI assistants to connect to external tools and services, though its tool descriptions are loaded into the context window at session start, consuming tokens before any work begins.
- Printing Press
- An open-source toolkit at printingpress.dev that automatically generates a token-efficient CLI, a Claude skill, and an MCP server for any website by analyzing a DevTools HAR recording of user interactions.
- HAR file
- An HTTP Archive file — a JSON-formatted log of all network requests and responses captured by a browser's DevTools during a browsing session, used here to reverse-engineer a website's API calls without needing official documentation.
- DevTools
- The built-in browser developer tools (accessed via F12 in Chrome) that let users inspect network traffic, HTML, JavaScript, and other technical details of a webpage — used here to capture the network calls a website makes.
- context window
- The total amount of text (measured in tokens) that an AI model can read and hold in memory during a single conversation — a finite resource that large API responses and MCP tool descriptions can quickly fill.
- agentic harness
- A software environment that runs an AI model in an autonomous loop, allowing it to use tools, execute code, and complete multi-step tasks without constant human input — Claude Code is an example.
- local mirror
- A locally stored copy of a subset of data from a remote service, set up so an AI agent can query it quickly without repeatedly hitting the live server — reducing latency, bandwidth costs, and the risk of IP-based rate limiting.
- Go (programming language)
- An open-source, statically typed programming language developed by Google, valued for producing fast, small compiled binaries — used by Printing Press to generate efficient CLI tools.
- Skool
- An online platform for building paid or free communities, hosting courses, and managing member content — used here as an example of an app that lacks a public API but can still be automated via a custom CLI.
Things they pointed at.
00:35toolGoogle Photos CLI (community)
00:36toolGoogle Ads CLI (pp-google-ads)
00:38toolMercury CLI (community)
00:39toolKalshi CLI (community)
00:41toolDomino's CLI (pp-dominos)
07:43toolNotion CLI (community)
07:45toolSlack CLI (community)
07:46toolLinear CLI (community)
07:49toolFireflies.ai CLI (community)
08:07toolKlaviyo CLI (pp-klaviyo)
08:07toolTrigger.dev CLI (pp-trigger-dev)
08:07toolAhrefs CLI (pp-ahrefs)
08:08toolAllRecipes CLI (pp-allrecipes)
10:25toolChrome DevTools (Network tab → Preserve log → Save all as HAR)
12:25productCal AI (referenced as functionality to replicate via image input)
Lines you could clip.
00:09
“Skool.com doesn't have a public API, and yet I connected Cloud Code to it.”
04:50
“Now there is one problem with CLIs and that is the fact that they have to exist first. And for a lot of tools, they actually don't exist unless a developer made them in the first place. But lucky for us, we are living in the future and we can now build them ourselves.”
03:20
“If you have too many MCPs loaded within your cloud code… the descriptions of these MCP tools and these connectors get preloaded into the context window even before you type or prompt anything.”
11:08
“Step one is probably the only manual step that you need to take because these following steps from two onward can already be handled end to end by your Cloud Code.”
12:20
“It's sort of similar to caching… just making sure that those local files are available on your device so that it is faster as well.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphoranalogystory
What if I told you that you can now let Cloud automate any application out there even if that tool doesn't have a public API? Well, I just did that. Skull.com doesn't have a public API, and yet I connected Cloud Code to it.
And here you can see I am querying some of the posts by our members right from within Cloud Code. MyFitnessPal also doesn't have a public API, and yet here, my Cloud Agent on Telegram just added the meal I had straight to the MyFitnessPal app.
And this is now possible because I just made custom CLIs or command line interfaces for these apps that I use. And with this new tool called PrintingPress, those CLIs are now so easy to create.
In fact, it's so easy that someone created a CLI for Google Photos, for Google Ads if you want your agent to connect to Google Ads. There's one for Mercury. There's one for Kalshi, and there's even one for Domino's.
So if you wanna order pizza using your Cloud Code agent, that is now possible too with the CLI. So if you want to create CLIs of your own, I think this tool will change the way you use Cloud Code if you use it correctly. So let's dive into it.
So just to set the scene on why this tool that I'm about to show you is quite important, you know when you're working with agentic harnesses like Cloud Code, you need to connect them to external tools in order to do real work. And the reason why that is is because a lot of the information and the work that we actually do live in the tools that we use every day.
And if you don't have a way for your agent like Cloud Code to connect to these tools, then you also won't be able to automate a lot of the work that you do in these platforms. Now as it stands, there are mainly three avenues by which we connect our agents to these tools. There is the command line interface or CLIs, application programming interfaces or APIs, and the one that is newest among them which are MCPs or model context protocols.
Now this tool that we're about to go through today called PrintingPress basically lets you create a command line interface for any external tool out there. Now that's a lot of technical terms and abbreviations, so let me just differentiate what each of them actually entail.
APIs, which are probably the most popular amongst these three, the way that works is quite simple. Let's say your agent asks for some information. The tool basically responds back with this structured output.
Basically, a wall of text usually in a JSON format that gives you a lot of information. And often, it is quite verbose, which means that apart from giving your agent exactly what it needs, it also gives it a bit more information that it didn't really ask for. And it depends on the way that this API is structured from the external tool side, but most often, the output that the agent gets is quite verbose.
And because there's a lot of words in here, that also means that it uses quite a lot of tokens. Now since then, Entropic actually invented this model context protocol. But the problem with this option is that if you have too many MCPs loaded within your cloud code, for example, what usually happens there is that in every session that you open, the descriptions of these MCP tools and these connectors get preloaded into the context window even before you type or prompt anything.
And so if you were to imagine how that connection happens, basically, the external tool is giving the agent the whole menu of actions first even before the agent connects with that tool, which has its drawback as well because then it fills up the context window. And so this is mainly why when I'm trying to connect to an external tool, the first thing that I ask my Cloud Code to look for is to see if there is a CLI interface for that particular external third party tool.
The reason why that is is because amongst these three, CLIs have the most potential to be the most lightweight. Because the way they can work is that if the agent asks for something, then the tool will give only that specific ask. And so if you think about the context used between the three of these, then the CLI tool would be the most minimal, while API and MCP connections usually have drawbacks when it comes to token usage.
And just to show how that looks like under the hood, if in case you are curious, let's say if you're using a CLI tool to get the last three YouTube videos of my particular channel, for example, literally what the agent will do is to just type out a command like this, and then it will get the result back. If this API is designed to be verbose with its output, it will get not just the request that it's asking for, but also a lot of other attributes and parameters in here, which you might not necessarily need.
And then if you go to the MCP, that has a similar problem because if you have the MCP, let's say, for YouTube installed on your agentic platform, what's going to happen there is that these tools like search videos, get video details, get channel info, these tools and their descriptions will be loaded into your context. And even before you type any prompt into any particular cloud code session, then these words and tokens will be using up your context already even before you interface with your agent.
And so that is why, at least for broad general use cases, I think CLI wins amongst these connection types. Now there is one problem with CLIs and that is the fact that they have to exist first. And for a lot of tools, they actually don't exist unless a developer made them in the first place.
But lucky for us, and we can now build them ourselves using this open source project called the printing press. And if we go to printingpress.dev, is their website, it's basically a toolkit and you can think of it as a set of skills for your agent where if you invoke this printing press toolkit and skill that will allow your Cloud Code to print the best agent design CLI of all time from anything.
So let's say a website doesn't have a public facing API. If you use PrintingPress and I was able to go through the process that they have earlier, your Cloud Code will basically guide you on how to create a best in class CLI for whatever tool it is that you want to create a connection for. And it will not only print you a token efficient Go CLI, so Go is this coding language by Google.
And apart from that, it will also give you a Cloud Code skill, an Open Claw skill, and even an MCP server if you wish. And to get started with it, I actually recommend for you to check out these two links that they have here.
One is their official GitHub repository where that toolkit lives, and this library where they already have CLIs for new tools that their community has already developed. So I'll link to their GitHub repo below. And to install this in Cloud Code, as usual, you can just send the link to this repository to your Cloud Code.
But instead of just asking Cloud Code to install it for you, what I usually advise for you to do is to actually let Cloud Code personalize it for your setup. So you can see the prompt that I gave it. Very simple.
I ask using this, what are the top three CLIs that I can print based on all you know about me? And that is pretty useful because you can see here that it's recommending to me to create a YouTube analytics CLI because I do YouTube content. I also send stuff on Substack.
So if that's a CLI that I want to print, I can do that as well. And also because I used Todoist for a lot of my personal to dos, then it knows that that might be a CLI interface that would be useful to me. In fact, here you can see that it also taught about MyFitnessPal, but since we created that earlier together, that is now available to me.
So try out a simple prompt like that. And for sure, since all of us have different use cases for Cloud Code and the work that we do, it might suggest different things for you. Now in case you want to just browse the official library or the current library of CLIs that have already been printed by their community, then you can just go to this other repo called the printing press library.
Now do note that I think this toolkit was only launched like maybe a day or two ago. So for sure, the library here is not yet that big. So instead of browsing this library yourself, my advice is to just have Cloud Code do it for you.
So you can see here, I gave it that link and I ask it what are the top CLIs here that might be useful to me given all you know about me. And it tells me here there is already a CLI for Notion. So if I want to automate Notion, that is something I can do.
Slack is there as well. Linear for project management. If you're using fireflies.ai for meeting transcripts, that would be one as well.
And you can see because this printing press toolkit made it now so easy to create these CLIs, there's already quite a few in there that may be useful to you. So there, with just those two repos, you are pretty well set to get started really.
And if you want a bit more visual view, you can also browse the different printing press CLIs that they created here right in their website. There's even one that lets you order pizza from Domino's, which is quite interesting.
I haven't tried that out yet, but, like, with the theme of this video, you can basically do a CLI for everything now apparently. But, of course, the real power of this tool is when you create the CLI yourself. So how do we do that?
And by the way, if you're interested in going from just using AI to getting paid for it, then check out the RoboNuggets community down in the description. We've got founders in there who landed their first client in weeks, live build sessions where we create this stuff together, and the actual templates behind what I just showed in this video.
The community is also the reason these lessons get made, so see that below if that's for you. So from within this Claude code session, that is actually how I created that MyFitnessPal CLI that I was testing it out earlier, and it literally only took me, like, fifteen minutes to set it up.
And here, after the fact, I just asked it to teach me how printing press works, and it's basically this five step process. And instead of going through the text that it gave us here, you know, I'm a big fan of HTML slides, so I just asked my Cloud Code to create this HTML slide for me just so that we can go through it better.
And, basically, how the PrintingPress Toolkit works is that first, you help Cloud Code capture the essential actions within that website. So what you do there is you use the website normally with DevTools recording, save that, and then give that to Cloud Code in this HAR format. And if you don't know what that is, an HAR is basically an HTTP archive.
So again, with a lot of these tools, it's just another text file. And to be honest, once you do this with your Cloud Code, it will actually guide you how to do this dev tools recording anyway. But how that basically works is when you're on the website that you're trying to automate, on Chrome, if you press f 12 let me just zoom that in so you can see.
If you go to this network tab, click on preserve log and make sure it is recording. If you do the actions that you want to automate like this one, if I want to automate MyFitnessPal, what I'll do is to just do the steps manually once, like adding the food in here.
And basically, the network here on the right, it will capture all of the network elements that happened from within this page. And then from that, what you can do is just do a right click.
And if you go to copy, there is an option here to copy all as h a r. And if you do that, that will give you the HTTP archive that Cloud Code needs to move to step two. Now the great news is that step one is probably the only manual step that you need to take because these following steps from two onward can already be handled end to end by your Cloud Code, and you just need to sort of steer it and just make sure that the spec that you are trying to create is aligned with what you want.
But, essentially, what it will do is it will use this skill, I believe, with printing press where it will read that recording, that HAR that you did. It will pick out the real API calls, drops noise, which there's a lot of them.
There's trackers in that sort of interaction in the network that you just did, and basically makes endpoints for you grouped by topic. And then after that step, it will now generate the CLI tool and even give you a Claude skill from whatever spec it is that you agreed. Now something unique that they've done, which I think is quite smart, is they introduced this step where you actually bundle of a local copy of the relevant data from that external tool.
Now in case that's confusing to you, it's actually simpler than you think. Basically, let's say you are connecting to MyFitnessPal all of their data, like their food database that lives in the cloud, basically in a computer that they have somewhere.
Now what printing press apparently allows you to do and guides you to set up is to set up a local mirror where it downloads a select subsection, obviously not the whole database, of just the relevant data and stores it in what's called a SQL like database. So essentially, just the food that I guess is relevant to you or other stuff that you want to keep a local copy of.
And the reason why this is important is because if you try to keep hitting this source in particular for those same data points, then you may encounter issues such as blocks to your IP. And also overall, that just costs more tokens and more bandwidth versus having to store select data in your local computer, which you can anyway ask your cloud code to edit if it becomes too sizable.
So it's sort of similar to caching and just making sure that those local files are available on your device so that it is faster as well. And now once you have that, what you can now do is to run or even include this new CLI of yours as part of a routine to run on a schedule. And the way you invoke that just like any skill is just by typing the slash command for it or even just by talking to your Cloud Code in natural language that you want to connect to, let's say, Bifit the Spy using the CLI that you just built.
And because I have Claude code connected to my Telegram agent, then what I can also do is invoke that skill whenever I need it and just ask Robo here to control my MyFitnessPal for me so that I don't have to do the logging manually. And I haven't tested it yet, but I think what I can also do is to send an image in here and sort of just replicate that Cal AI functionality where you pass in an image and it will figure out what to add.
So I'm probably going to play around with this a bit and see how we can improve the CLI to accommodate for that. And there you go. That is how you make a CLI for literally everything now.
So if you have any tools that you are working on or using sort of on a day to day basis and you can't find a solution to connect that to your AI agents, then this printingpress.dev toolkit may be something that you want to check out.
I hope that was useful. And if it is, then consider subscribing so that we can put out more stuff like this. I'll see you guys next time.
Thank you.
The Hook
The bait, then the rug-pull.
Jay opens with a flex — Claude Code is already inside Skool, MyFitnessPal, and a Telegram-driven food log, none of which expose a public API. The reveal: he stitched custom CLIs together with a new toolkit called Printing Press, and the rest of the video is a quietly thorough case for why CLIs (not MCPs, not APIs) are the right shape for agents to talk to the outside world.
Named ideas worth stealing.
09:03list
How Printing Press works — 5 steps
- Capture — record a HAR file with Chrome DevTools while you use the site manually
- Sniff — Printing Press reads the recording, drops trackers/ads, groups real API calls by topic
- Generate — auto-build a Go CLI, a Claude skill, and an MCP server from the same spec
- Mirror — bundle a local SQLite copy of the relevant data (cache, not the whole DB)
- Run — single binary, invoke from slash command, natural language, schedule, or another agent
The Printing Press pipeline turns any human-driven web session into an agent-callable CLI in five steps, only one of which is manual.
Steal forany internal tool, paid SaaS, or no-API website you want Cloud Code to drive — record yourself doing the task once, ship a CLI
01:35model
Three ways agents connect to tools — CLI vs API vs MCP
- CLI — agent asks, tool returns only that ask (lightweight)
- API — agent asks, tool returns that ask plus everything else (verbose JSON)
- MCP — tool gives the agent the whole menu of actions before the agent asks (always loaded into context)
A clean mental model for evaluating any new agent-tool integration on token cost first.
Steal forthe rubric Joe should apply before bolting any new MCP onto a Cloud Code project — does this need to be MCP, or would a CLI do the job in 10% of the tokens?
How they asked for the click.
VERBAL ASK
08:26product
“If you're interested in going from just using AI to getting paid for it, then check out the RoboNuggets community down in the description. We've got founders in there who landed their first client in weeks, live build sessions where we create this stuff together, and the actual templates behind what I just showed in this video.”
Embedded as a brief mid-roll right before the 5-step payoff slide — earns the pitch by promising the meat is still coming. Soft secondary CTA at the end is just a subscribe ask. No pushy stack of links.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
AFFILIATECommission earned if you click.
OTHER LINKSAlso linked in the description.
Visual structure at a glance.
