Modern Creator

This is the Most Powerful Tool to Give to Claude Code

A 14-minute tour of Printing Press — a CLI factory that turns any site (even ones without an API) into a token-efficient command-line tool your agent can call.

VIDEO OF THE DAY★ ★ ★1stWINNATE HERK | AI AU…May 9, 2026
Posted
1 months ago
Duration
Format
Tutorial
educational
Views
95.1K
2.9K likes
Big Idea

The argument in one line.

CLIs are 35 times more token-efficient than MCPs and built specifically for how agents think, making them the ideal interface for Claude Code to access any website or service—including those without APIs.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…
  • A builder or automation engineer using Claude Code who needs to extract data from sites without APIs and wants to minimize token spend.
  • Someone already comfortable with CLI concepts and basic command-line workflows who wants to give Claude Code access to services like Skool or other web-only platforms.
  • An AI agent builder who's tried MCPs or raw APIs and found them inefficient or bloated, and wants a lighter alternative for specific tool integrations.
SKIP IF…
  • You primarily work with official APIs that already exist for the services you need — this focuses on filling the gap where APIs don't exist.
  • You're unfamiliar with command-line interfaces and CLIs and aren't willing to spend time learning the concept before evaluating the tool.
TL;DR

The full version, fast.

Command-line interfaces are the most token-efficient and reliable way for coding agents like Claude Code to talk to external services, beating both raw APIs and MCP servers on cost and consistency. Printing Press, a new tool at printingpress.dev, ships a library of around fifty pre-built CLIs and a factory skill that lets the agent reverse-engineer any site � even ones without an API, like Skool � into its own local Go-based CLI in roughly ten minutes. Install the starter pack plus the factory, get Go on your machine, then ask in natural language for the tool you need. Treat CLIs as tier one, APIs as fallback, and MCP servers only when nothing else fits.

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 →
Chapters

Where the time goes.

00:0000:26

01 · Cold open — Skool with no API

Demos Claude Code pulling 9 community wins from Skool (no public API) via a CLI he built. Sets up the entire promise of the video.

00:2601:18

02 · Second demo + the token magic

Pulls 10 recent posts from his community; reveals the kicker — 132K tokens came back from Skool, but only ~2K hit Claude's context because everything was routed through the CLI.

01:1801:39

03 · Introducing Printing Press

Reveal of printingpress.dev — a CLI factory and CLI library. Thesis: APIs suck for agents, MCPs suck for agents, even most official CLIs suck for agents.

01:3902:14

04 · What even is a CLI?

Defines CLI as 'command-line interface' — a way to use a tool by typing a command. Lists examples: Gemini CLI, Claude CLI, Codex CLI, GitHub CLI, Playwright CLI, HeyGen CLI, GWS CLI.

02:1403:13

05 · API vs MCP vs CLI — three ways agents talk to tools

Compares the three transports. APIs are raw and token-heavy. MCPs add overhead, schema bloat, and a server to keep running. CLIs are local, fast, composable, SQLite-backed, agent-native.

03:1303:36

06 · The token receipt

Re-shows the Skool example — 132K tokens from Skool's response, only 2K of summary into the context window. That's the whole pitch in one screenshot.

03:3604:04

07 · Why APIs lose

APIs were built for code, not for autonomous agents that pay per token. Massive JSON bodies, pagination, auth headaches.

04:0404:31

08 · Why MCP loses too

MCP solved discovery but added a new tax — schema bloat. Real benchmark: MCP used 35x more tokens than CLI on the same task; reliability drops from 100% (CLI) to 72% (MCP) as tasks get harder.

04:3105:09

09 · Why CLIs win

Built for how agents actually think — lazy discovery, preformatted outputs (~200 tokens of clean text), composable commands, local SQLite mirror, auth solved once, native to the agent. 'APIs are built for code, MCPs are built for tools, CLIs are built for agents.'

05:0905:43

10 · Tour of printingpress.dev

Inspired by Peter Steinberger (creator of OpenCode) needing to build his own CLIs. Walks the homepage: a factory plus a library of ~50 pre-built CLIs.

05:4306:16

11 · Library tour + starter pack

Scrolls the catalog: flight-goat, ESPN, movie-goat, recipe-goat, Linear, Amazon, Craigslist, eBay, TikTok Shops, Shopify. Recommends starting with the starter pack (ESPN, flight-goat, movie-goat, recipe-goat).

06:1607:00

12 · Install flow — feed Claude the URLs

Take the three printingpress URLs, paste them into Claude Code, say 'install everything I need.' Claude figures out you also need Go (free, open-source language from Google), and walks you through downloading it in about a minute.

07:0007:43

13 · Why this is a big deal

Most sites your agent wants don't have a clean API — Printing Press doesn't care. ESPN: no public API. Craigslist: no API. AllRecipes: anti-scrape, so the CLI uses a real Chrome session. Domino's: no public API. Skool: no public API.

07:4309:05

14 · Listing what's installed

Asks Claude 'take a look at our Printing Press library of CLIs and tell me what we have access to.' Shows three locally built (Skool, Tally, YouTube) plus the starter pack (ESPN, flight-goat, movie-goat, recipe-goat).

09:0510:00

15 · Live ESPN test — 'what NBA games are on tonight?'

Natural-language prompt invokes pp-espn, returns Knicks vs Sixers at 7 and Spurs vs Timberwolves at 9:30 — checks out. Then mentions contact-goat (LinkedIn + Happenstance + Dripify cross-check for verified emails) as a possible use case.

10:0011:20

16 · Building your own — Hacker News example

Walks through asking Claude to build a Hacker News CLI from scratch with the factory. Plain English: 'I want to pull articles from Hacker News and get insights every day.' Notes that auth-protected services still need keys in your .env.

11:2012:20

17 · The factory's research phase

Claude announces it will research Hacker News, catalog every feature, generate a Go CLI, build it, and verify via dogfood, runtime verification, and scoring. Estimates 30-60 min (Nate jokes those estimates are always wrong).

12:2013:38

18 · Sharing CLIs with your team

You can publish a CLI back to the public library OR push it to a private repo and invite teammates as contributors. Demos his Tally CLI being packaged into a sharable GitHub repo. Security caveat: no API keys inside the CLI scripts.

13:3814:45

19 · Decision tree + outro Hacker News test

The mental model: CLI tier 1, API tier 2, MCP tier 3. Hacker News CLI finishes building, Nate asks 'which sites are dominating Hacker News today?' — gets a clean ranked list back in seconds. Sign-off + like ask.

Atomic Insights

Lines worth screenshotting.

  • A CLI built with Printing Press routed 132,000 tokens through the school community interface but injected only 2,000 tokens of summary into the Claude context — keeping the session clean while still completing the task.
  • APIs are built for code, MCPs are built for tools, and CLIs are built for agents — and confusing which layer to use for agent-to-service communication is the source of most token waste and reliability failures.
  • MCP used 35 times more tokens than the equivalent CLI on the same task, and reliability dropped from 100 percent to 72 percent as task complexity increased.
  • A site with no API — like Skool — can still be accessible to a Claude Code agent by building a custom CLI through Printing Press in about ten minutes.
  • Printing Press was inspired by a developer needing to build better CLIs than the official ones provided — which is how the GOG CLI became more useful than Google's own official GWS CLI.
  • The local SQLite mirror in a CLI-based architecture means there are no round trips and no rate limits — the agent reads from a local cache rather than hitting the external service on every call.
  • Auth is solved once in a CLI and held by the tool permanently, eliminating the token overhead and session management complexity that MCP servers add to every interaction.
Takeaway

Steal the format.

Tutorial playbook

Open with the impossible-looking demo, then spend the middle proving the why with one cheap framework — and end with a 'build your own' walkthrough that turns viewers into operators.

  • Lead with a working result on a service the audience knows is hard (Skool has no API). Don't tease — show it executing in the first 20 seconds.
  • Drop ONE framework on screen as a bullet slide ('API vs MCP vs CLI'). Three columns, one sentence each. That's the entire educational backbone of a 14-minute video.
  • Include the receipt. '132K tokens out, 2K into context.' Hard numbers screenshot well and beat any adjective.
  • Always run a live test on camera, even a boring one (NBA scores). The natural-language prompt landing real data IS the magic moment.
  • Close with a tier list. 'CLI > API > MCP.' Audience walks away with a portable decision rule.
  • Make the CTA invisible. No newsletter pitch, no sponsor. Just 'hit like.' The tool itself is the lead magnet.
Glossary

Terms worth knowing.

CLI (Command Line Interface)
A way to interact with a program by typing text commands into a terminal, rather than clicking through a graphical interface. CLIs are fast, scriptable, and easy for AI agents to call.
Printing Press
A CLI factory and library tool (printingpress.dev) that helps AI agents build custom command-line interfaces for any website or service, including those without a public API.
API (Application Programming Interface)
A set of defined endpoints that allow one piece of software to request data or actions from another. REST APIs typically return large JSON payloads that can consume many tokens when fed to an AI agent.
MCP server
A server implementing the Model Context Protocol that exposes a set of tools to an AI agent. MCP adds discovery flexibility but also adds token overhead since tool descriptions are loaded into context even when unused.
Context window
The maximum amount of text (measured in tokens) that an AI model can process in a single session; data that exceeds this limit cannot be seen by the model.
SQLite mirror
A local SQLite database that stores a cached copy of remote data, eliminating the need to make a network request every time the data is needed and avoiding rate limits.
Lazy discovery
A pattern where a tool only loads or exposes information about its capabilities when explicitly asked, rather than loading everything upfront — reducing unnecessary token usage in AI agent sessions.
Go (programming language)
An open-source compiled programming language developed by Google, known for being fast, simple, and well-suited for building command-line tools, web servers, and cloud applications.
.env file
A plain-text file that stores environment variables (API keys, secrets, configuration values) for a project, keeping sensitive credentials out of source code.
OAuth
An open authorization standard that lets a user grant a third-party application access to their account on another service without sharing their password.
Resources

Things they pointed at.

05:20channelPeter Steinberger (creator of OpenCode)
05:33toolgog CLI (Google CLI by Steinberger)
09:51toolcontact-goat CLI (LinkedIn + Happenstance + Dripify)
01:47toolGemini CLI
01:50toolCodex CLI
02:01toolPlaywright CLI
02:02toolHeyGen CLI
01:57toolGWS CLI (Google Workspace)
Quotables

Lines you could clip.

00:50
PP stands for printing press, which is the tool I'm gonna show you guys today.
the name reveal lands the gagIG reel cold open↗ Tweet quote
01:18
APIs suck for agents, MCPs also suck for agents, and a lot of times official CLIs suck for agents because they waste tokens.
contrarian framing, the entire thesis in one lineTikTok hook↗ Tweet quote
02:55
When MCP came out and it kinda broke the internet, everyone just assumed that MCPs were the answer.
calls out the herd, sets up the pivotX quote post↗ Tweet quote
04:20
MCP used 35 times more tokens than the CLI on the same task, and reliability drops from 100% with the CLI to 72% with MCP as tasks get harder.
hard numbers, screenshot-able receiptnewsletter pull-quote↗ Tweet quote
05:05
APIs are built for code, MCPs are built for tools, and CLIs are built for agents.
tight three-beat rhetorical structure, t-shirt lineTikTok hook↗ Tweet quote
07:25
ESPN, for example — no public API. Craigslist, no public API. AllRecipes has anti-scrape protection but the CLI uses a real Chrome session. Domino's has no public API. Skool, as you guys saw, no public API.
rapid-fire list, ends on the demo callbackIG reel cold open↗ Tweet quote
09:00
Do you think that I could have done that myself? Absolutely not. But this just figured it out for me in, like I said, ten minutes.
personal admission of skill gap, then the unlockTikTok hook↗ Tweet quote
The Script

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.

metaphorstory
00:00Alright. So what would you think if I told you that I just said to Cloud Code, hey. Go to my school community and grab me some posts.
00:05And keep in mind, school does not have an API, and it was able to use the CLI. It was able to find nine wins, and it made sure that they were in the wins category, and then it gave me the three strongest ones. And I got a link to all of them so we can see if they actually exist.
00:17As you can see, here is Michael's win. And quick shout out to my community members, Michael, Chris, and Fernando. But anyways, the way that we're doing this is we're using a CLI, and the tool I'm gonna show you guys today actually helped me build the school CLI.
00:29So if you've never heard of the term CLI before, don't worry. I'm gonna explain it. I'm gonna compare it to APIs and compare it to MCPs.
00:34But before we get into all that, let me show you one more example. So here I said, hey. Can you just go pull 10 of the most recent posts in my community?
00:41It goes ahead and it uses the school PP CLI. PP stands for printing press, which is the tool I'm gonna show you guys today. It comes back.
00:47It grabs all of these 10 posts. And then I also asked, like, how many tokens did you actually consume to make the CLI request? And it said, okay.
00:54Here's what happened. I sent about 260 to school.
00:57It sent me back about a 100 and 32,000 tokens, but what's important is that none of that hit my context window because we were basically able to point all of that routing through the CLI so that none of it actually pollutes your session or your context. So that is super cool, and I built the school CLI, and it literally took me about ten minutes.
01:14Alright. So here is the tool that we are using. Introducing printing press, a CLI factory and a CLI library.
01:21The whole idea is that APIs suck for agents, MCPs also suck for agents, and a lot of times, official CLIs suck for agents because they waste tokens or they're not efficient. So printing press has a library of, like, 50 pre built CLIs that you can use right away, and it also gives you a factory so that you can turn anything into a CLI.
01:37So let's just start off with the basics real quick. Why CLIs beat MCPs and APIs, and what even is a CLI? So CLI stands for command line interface, and it's a way to use a tool by typing a command instead of clicking buttons.
01:49So it's not a new concept. It's been around for a long time. You know, like, Gemini's got a CLI, Claude CLI, Codec CLI.
01:54And you might have been seeing a lot of tools recently create CLIs. Like, Google have their official GWS CLI, which is probably the most used thing in my cloud code. GitHub has a CLI.
02:03Playwright has a CLI. Hicksfield just created a CLI. HeyGen just dropped a CLI.
02:08It's really just the best and most efficient way to have agents talk to other tools. Now what are the other ways? API, MCP.
02:15And when MCP came out and it kinda broke the Internet, everyone just assumed that MCPs were the answer, and we're just gonna shove MCPs into all of our agent setups. And they all just have different pros and cons. APIs are very raw.
02:26You're gonna get back a huge JSON snippet from the API endpoint, and sometimes you need all that information, and it's really, really nice. They're also more token efficient than an MCP server because MCP servers have to have all the different tools and descriptions and the ability for the agent to look through everything, which is cool because they're way more flexible than an API endpoint.
02:45But as you can see, they add overhead, extra context bloat, you and have to keep a server running. So if you go into cloud code right now, brand new session, and do slash context, if you've got a bunch of MCP servers loaded in, you'll see how many tokens they're using every single time.
02:58And you may not even be invoking that MCP server, so it might just be a waste of tokens. And then we have CLIs, which are local, they're fast, they're composable, they have a SQLite back end, they're agent native. And you can start to build some skills around these CLIs just like you can with APIs and MCPs as well to chain them together and make some really cool, fast workflows.
03:17And the cool thing is the output you get is super short and super clean. So, basically, the CLI response to the agent is super short. And that's what we just saw in that school example where our agent was like, yeah.
03:26You know, that took about a 132,000 tokens. But right here, it said into my clawed context though, I only pulled about 2,000 tokens of summary, not the full a 132,000.
03:36Okay. So real quick to hit on each of those individually. Why do APIs lose?
03:40Because they were built for code, not for all of these autonomous agents that pay per token. Because when you get back an API response, you just get this massive JSON body. Those of you who came with me all the way from end to end, you know what it used to look like when you would hit a server and get that massive API structure back.
03:56You You also might run into issues with pagination or auth, and it just can get a little bit funky sometimes. And what about MCP? MCP solve discovery because, like I said, you could quickly glance at 50 tools that are available from a certain server.
04:09But because you're loading all 50 tools, now you have tokens and sort of like, you know, descriptions for all of those 50 tools. Here's a real benchmark.
04:17MCP used 35 times more tokens than the CLI on the same task, and reliability drops from a 100% with the CLI to 72% with MCP as tasks get harder. So really, if you can just shift to every single time you want Cloud Code to talk to something, just try to find a CLI or build your own CLI now.
04:34Because they were built for exactly how agents actually think. They have lazy discovery. They have preformatted outputs where you're basically just getting 200 tokens of clean text rather than raw JSON.
04:43You can compound commands together. You have a local SQLite mirror, which means no round trips and it means no rate limits. It's obviously native to the agent, and the auth is pretty much solved one time because the CLI holds the token, and then you are all set.
04:56So the bottom line, APIs are built for code, MCB is built for tools, and CLIs are built for agents, especially when you're paying per token or, you know, managing your session limit. Okay. So what is printing press?
05:06What are we looking at today? So if you go to printingpress.dev, this is what it will look like.
05:10It's a very new tool. Just dropped like yesterday, and I've been playing with it all day today. And I've already built a few cool CLIs, which I'll show you guys when we hop over to Cloud Code.
05:18But printing press, It's funny. So this kind of was inspired by Peter Steinberger, the creator of OpenClaw, needing to make his own CLIs because the official ones were bad.
05:27So he built, like, GOG CLI, which is for Google, and people are saying that it's even better than the GW CLI that is, you know, Google's official CLI. So that's the whole idea. You have a factory, so basically a skill and a tool to help you build CLIs, but also if you come down here, there's a library.
05:41So you've got a a flight goat CLI. You've got ESPN. You've got movie goats.
05:46You've got recipe stuff. You've got linear. And if we keep scrolling down, you can see there's different Amazon, Craigslist, eBay, TikTok shops, Shopify.
05:53There's so many different CLIs on here that you can use. And now you guys can see where I got the the p p from. Anyways, what I would recommend if you wanna get in here and get started is just start off with the starter pack, which is exactly what I did.
06:04This has like four or five CLIs. It's got ESPN, FlightGoT, MovieGoat, and RecipeGoat.
06:09And then you can obviously clone other skills and you can install more stuff. And when you install the factory, that's what helps you actually build your own CLIs. So I will leave links to this in the description.
06:18I will also leave a link to the library of different CLIs, which is the GitHub, and I will leave this printing press one, which is what you need to help build other ones. So basically what I did is I took all three of those URLs, and I went into my Cloud Code, and I said, hey.
06:34Read all three of these. This is a new tool I'm seeing that has a bunch of preloaded CLIs, and it also helps you build CLIs, and just install everything I need. So like I said, this is the main command if you wanna run the starter pack, and then you need the factory as well in order to build your own.
06:47And it's super, super easy. You basically install it, and then you can do natural language requests to use all this stuff. The one prereq is that you're gonna need to get Go, and it's basically as simple as asking Cloud Code to do it.
06:58So if you drop in those three links and you say, hey. Help me get this set up. It's gonna come back and say, okay.
07:02I figured it out, but you need to install this first, which is Go. And it's a free open source programming language made by Google. It's designed to be simple, fast, and it's great for building command line tools, so CLI tools, web servers, cloud apps, and other AI related stuff.
07:15It's a very popular language, and it's, like I said, completely free to download. So that'll take you maybe one minute. You tell Cloud Code, okay.
07:21Download that for me. And then you just follow the prompts. Cloud might ask you to do a few other things, but you'll be able to get set up super, super easy.
07:27And why is this a big deal? Because most websites your agents want don't have a clean API, but printing press just lets you basically build your own with the CLI. So ESPN, for example, no public API.
07:37Craigslist, no public API. Allrecipes has anti scrape protection, but the CLI uses a real Chrome session. Domino's has no public API.
07:45School, as you guys saw, no public API. So if I come into Cloud Code, now that I've got this all installed, I can ask, can you take a look at our printing press library of CLIs and tell me what we have access to? Here you can see it's using the printing press catalog skill, and what it's gonna do is it's going to list the ones that we've already installed, and it's also going to list the available CLIs in the catalog that we could install.
08:05Okay. So here is what we have. These are the three local ones that I've just built.
08:08We have school, we have tally, and we have YouTube. And I basically just transformed my, you know, YouTube data API as well as the tally API I was connected to and said, hey. Can you just turn this into a CLI?
08:18So now it'll be faster and more efficient. And then, of course, school, it had to reverse engineer. So it did some deep discovery, looked at school, and it figured out how to basically create these endpoints through a CLI.
08:28So that's just really cool. Do you think that I could have done that myself? Absolutely not.
08:31But this just figured it out for me in, like I said, ten minutes. And then we've got some other ones that are installed as skills. We've got ESPN, FlightGoat, MovieGoat, and the RecipeGoat.
08:40I also built a skill around the tally one, which I'm going to do for YouTube and school as well, but those are the five you can see here. It didn't actually pull the catalog stuff yet. It said, do want me to check what's available in the catalog?
08:50I don't really care because I could just go here, and like I said earlier, we can look through all of this. And, like, let's say we wanted this Airbnb one. This just takes you to the GitHub repo, which I showed you guys earlier, which is the library of all the different CLIs that you could install.
09:02So now if I just say, what NBA games are on tonight? What we're gonna see is it's going to use the ESPN skill right there, p p ESPN, and it's going to pull back that data for us.
09:13So it says, okay. There are two NBA games on tonight, eastern time, Knicks and Sixers at seven, and Spurs and Timberwolves at 09:30. You can see right here that is exactly correct.
09:22This is in central time, so eastern time would be one hour ahead. So what I would recommend is you go in here, you take a look at which of these might be useful to you, and then you just pull them in and you test them out. They showed a cool example here with one called contact goat.
09:34Find a verified email for a person you've never met. It looks them up on LinkedIn. It cross checks them on happenstance, and then it does a deep line verified email check.
09:43Though I haven't personally tried this one, but the ability to maybe do things on LinkedIn through a CLI is pretty cool. So hopefully you guys understand the value here and how easy it really is to get set up. The last thing I wanna do now is just show you what it actually looks like to build your own.
09:55So I'm pretty sure there is a Hacker News one that already exists on the website on the catalog. But let's say I did wanna build my own, and we're gonna take Hacker News as just an example. I would basically just say, hey.
10:07Can you please use printing press? Can you use the CLI factory to help me create my own CLI? I wanna be able to pull in articles from Hacker News and, you know, just get insights every day from that site.
10:17And then I also just gave it a link right there to the page that I was just on. It's using the printing press skill once again. Now Hacker News doesn't actually take any authentication.
10:26Like, we should be able to just pull it in. And so this isn't, like, the most impressive demo, so that's not what I want you to take away from here. The point is that you can just ask a natural language, and it will start doing all the research and investigating and, like, reverse engineering things and then help you build it out.
10:40But if it does take, like, authentication cookies or, you know, OAuth or an API key, then you still basically treat it the same way you would like an API. You would be putting those in your dot ENV and storing them in there.
10:52And then when you build the skill around the CLI, it will understand that it needs to pull from that. Another thing to keep in mind is let's say you have some sort of quota. So let's take YouTube for example.
11:01I can only post a certain amount of comments per day through the API, and if you got a rate limit there, you know, just because you're using a CLI doesn't mean you're jumping over those quotas. You're still gonna have those limits. So anyways, this comes back and it says, I'm gonna research Hacker News.
11:14I'm going to catalog every feature that exists in any tool. I'm going to present what I found, and then I will generate you a Go CLI, build every feature, and then we will verify quality through dog food, runtime verification, and scoring. So at the end, we will have a fully functional CLI for Hacker News.
11:29It says that it's gonna take thirty minutes to sixty minutes, but it's not. It's always bad at those estimations. I don't know if you guys have noticed that, but sometimes it'll say, hey.
11:36This is gonna take thirty minutes, and then it takes, two. But, anyways, I'm just gonna say, yep. Go ahead and build that out for me.
11:41And so while this is doing that research and building it out, I'll talk about something else real quick, which is what can you do with those CLIs? Because you could publish them back to the library, and then other people could, like, publicly pull them in and use those CLIs as well. You can also just share them with your team internally.
11:55So for example, this Tally one that I just built, I have been able to push this to a private repo, and now I can just invite some of my team to actually, like, be a contributor to this so they can clone it, and then they can use the Tally CLI as well and maybe just swap out their own API key in their dot ENV file or whatever.
12:10And all I did was I said, okay. Cool. So you built me this Tally CLI and you built me this skill.
12:15Can you just package just that into a GitHub repo so I can share that across my team? And then, you know, a couple seconds later, I had this new GitHub repo.
12:23So, of course, what that means is you don't wanna be putting any of your API keys or your authentication stuff inside of the CLI scripts or anything like that. That would still be treated the same way as you treat, like, your API endpoints and stuff like that. So this actually just came back with a huge list.
12:37So you can see that there's different phases. It has to do all of this stuff, and then hopefully by the end, it's gonna be able to actually have a working CLI for us.
12:45So once again, it's not exactly that like, hey, this CLI is going to give you so much more functionality than if you just used the API, but it's the ability to, first of all, be able to turn anything into a CLI and start natively working through just CLIs rather than APIs and MCPs. So maybe think of an example of something that you use a lot that doesn't have a great API or, know, it only has an MCP server or whatever it might be, and just think about the fact that you could now tell Cloud Code, hey.
13:09I use this software for x, y, and z. Do you think you could help me build a CLI around that right here in Cloud Code? And, hopefully, it will give you research, and it will build you a list like this, and then you'll finish up with the CLI.
13:20So it's kinda just like the checklist of thinking about how you talk to tools. I would say, like, CLI would be tier one. If there's no CLI option or you just can't do it, then the API would be next.
13:29If there's an API, you're pretty much, like, a 100% gonna be able to make CLI. But then if there's no API and you can only use an MCP, then that would be the final option.
13:38Alright. So all of that has finished up now. We can see this is exactly where the binary actually lives.
13:43It's giving some examples here where you could actually, like, invoke this command basically in the CLI. Or as you guys know, it should have built kind of like a skill around this, and we're able to just invoke it with natural language. So I'm just gonna go ahead and see what happens if I say, can you test this out using the actual skill and just go ahead and see which sites are dominating Hacker News today?
14:06That came back super fast. It said, okay. Last twenty four hours of stories with a 100 plus points ranked by total score, and we get these 10 stories right here.
14:13So anyways, this demo wasn't about the fact that we're doing this with Hacker News. It was just to show you guys how easy it is to set up these CLIs. And from here, you can build skills around them, and you can chain them together.
14:21And from here, you can build skills around them, you can chain them together, and, of course, you can access the catalog on printingpress.dev. And I'm assuming that this is just gonna continue and continue to grow.
14:31And I'm assuming this is just going to continue to grow and grow. So, anyways, wanted to keep this one quick, but I hope that you guys learned something new or enjoyed the video. And if you did, please give it a like.
14:39It helps me out a ton. And as always, I appreciate you guys making it to the end of the video, and I will see you all in the next one. Thanks, everyone.
The Hook

The bait, then the rug-pull.

The promise is dropped in the first breath: Claude Code just scraped a community platform that doesn't even have an API. Nate spends 14 minutes walking through Printing Press — a 'CLI factory' that just shipped to printingpress.dev — and arguing that CLIs are the third option creators keep missing between raw APIs and bloated MCP servers.

Frameworks

Named ideas worth stealing.

02:14concept

API vs MCP vs CLI — the three transports

  1. API — raw, verbose JSON dumps; built for code not agents; auth and pagination headaches
  2. MCP — solved discovery, but schema bloat; every tool dumped into context up front; 35x more tokens than CLI on the same task
  3. CLI — lazy discovery, ~200 tokens of preformatted output, local SQLite mirror, composable, auth solved once, agent-native

Three options for how an agent talks to a tool. CLIs are the underrated default.

Steal forany time Joe is wiring an agent to a third-party tool — pick CLI first
13:33list

Tier list for agent-to-tool transports

  1. Tier 1: CLI — always reach for this first
  2. Tier 2: API — fall back if there's no CLI option
  3. Tier 3: MCP — last resort, only if no CLI and no API

Nate's explicit decision tree for which transport to wire up.

Steal foragent architecture decisions on MCN, ModBoard, JACE
11:51list

Printing Press 5-phase factory loop

  1. Research the target site / tool
  2. Catalog every feature that exists in any equivalent tool
  3. Present what was found
  4. Generate a Go CLI, build every feature
  5. Verify quality via dogfood + runtime verification + scoring

What Claude Code does behind the scenes when you tell Printing Press to build a new CLI.

Steal forany 'build me a thing from a URL' workflow Joe might design
CTA Breakdown

How they asked for the click.

VERBAL ASK
14:30subscribe
I hope that you guys learned something new or enjoyed the video. And if you did, please give it a like. It helps me out a ton. And as always, I appreciate you guys making it to the end of the video.

Soft like-ask in the outro — no product pitch, no newsletter, no sponsor. Tutorial is the product. Links to Printing Press and the catalog get verbal mention in the middle ('I will leave links in the description') around t=390.

Storyboard

Visual structure at a glance.

cold open demo
hookcold open demo00:00
promise + reveal
promisepromise + reveal01:18
three-way framework
valuethree-way framework02:14
site tour
valuesite tour05:09
live ESPN test
valuelive ESPN test09:05
build-your-own demo
valuebuild-your-own demo10:00
Frame Gallery

Visual moments.

Watch next

More from this channel + related breakdowns.

16:53
Nate Herk | AI Automation · Tutorial

So You Learned Claude, Now What?

A 17-minute career roadmap arguing that the next move for anyone who can build with AI is to stop being a builder and start being a consultant — with a four-step playbook to do it without quitting your job.

June 22nd
Chat about this