CLI-Anything: transforme qualquer app em um CLI para Claude Code e Codex (GIMP, Blender, LibreOffice e mais)

Autoria: AICodeKing · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: CLI-Anything: Turn ANY App into a CLI for Claude Code & Codex (GIMP, Blender, LibreOffice & More!) · Canal: AICodeKing · 10:49 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Claude Code, Engenharia de software com IA, Ferramentas de desenvolvimento com IA

Resumo

O vídeo apresenta o CLI-Anything, projeto da HKUDS que cria CLIs para softwares existentes, permitindo que agents os usem por comandos de texto em vez de automação de GUI. Ele demonstra o CLI hub, que permite encontrar e instalar CLIs já disponíveis, e o gerador, que analisa o código-fonte de um software e cria comandos, testes, documentação e um arquivo skill. O apresentador mostra exemplos com LibreOffice e Blender e explica como refinar e validar os CLIs gerados. Entre as limitações, destaca a necessidade de modelos fortes, o melhor desempenho com acesso ao código-fonte e a importância de revisar os testes e comandos antes de usar o CLI em tarefas importantes.

Pontos-chave

O CLI-Anything transforma softwares existentes em ferramentas de linha de comando que agents podem usar por meio de texto.
Os CLIs chamam o software real, em vez de substituí-lo por uma implementação simplificada.
O CLI hub permite pesquisar e instalar CLIs disponíveis para programas como Blender, Inkscape e LibreOffice.
A meta skill do CLI hub ensina um agent a encontrar e instalar ferramentas por conta própria.
O gerador cria CLIs em sete fases, incluindo análise, implementação, testes, documentação e publicação.
Os CLIs gerados podem oferecer saída JSON, modo REPL e suporte a desfazer e refazer.
O comando refine permite ampliar a cobertura do CLI, adicionando comandos, testes e documentação para recursos ausentes.
O projeto recomenda modelos fortes; usar apenas um binário compilado ou um modelo local pequeno pode reduzir a qualidade.
O apresentador recomenda revisar os testes e comandos antes de dar acesso do CLI a arquivos importantes.

Capítulos

Início	Capítulo	Resumo
00:03	O que é o CLI-Anything e por que usar um CLI	O vídeo apresenta o projeto e compara CLIs com automação de GUI, APIs limitadas e reimplementações incompletas.
02:15	CLI hub: encontrar e usar ferramentas existentes	O apresentador demonstra como instalar CLIs pelo hub e como um agent pode descobrir e usar o CLI do draw.io.
04:22	Gerar e usar um CLI para um software	A demonstração percorre as fases de geração e mostra exemplos de uso com LibreOffice e Blender.
07:05	Refinamento, testes e limitações	O vídeo explica como ampliar e validar CLIs, apresenta demonstrações do projeto e discute custos e cuidados necessários.
09:46	Conclusão e recomendações	O apresentador resume as vantagens do CLI hub e recomenda experimentar a meta skill e o gerador.

Citações

Um CLI é texto de entrada e texto de saída. — 01:10

Ele chama o software real. — 01:43

O agent compara o que o software pode fazer com o que o CLI pode fazer. — 07:05

Um CLI com saída JSON é rápido, barato e fácil para um agent usar. — 09:46

Conceitos e entidades

CLI Anything (repo): Projeto que gera CLIs para softwares existentes para que agents possam operá-los por comandos.
HKUDS (empresa): Laboratório de data intelligence da University of Hong Kong responsável pelo CLI-Anything.
CLI hub (ferramenta): Gerenciador de pacotes do projeto para pesquisar, instalar e iniciar CLIs disponíveis.
CLI generator (ferramenta): Gerador que analisa um software e cria para ele um CLI com comandos, testes e documentação.
Claude Code (ferramenta): Ambiente de programação usado na demonstração do gerador de CLI.
Codex (ferramenta): Agent citado como compatível com a meta skill do CLI hub.
Blender (ferramenta): Software de criação 3D usado como exemplo de integração por CLI e de renderização.
LibreOffice (ferramenta): Suíte de escritório usada no exemplo de criação e exportação de um documento PDF por CLI.
draw.io (ferramenta): Ferramenta cujo CLI é encontrado e usado por um agent para criar um diagrama de arquitetura.
Apache License 2.0 (conceito): Licença indicada no vídeo para o projeto CLI-Anything.

Tradução completa (pt-BR)

00:03 Olá. Bem-vindos a mais um vídeo. Hoje quero falar sobre um projeto chamado CLI Anything. Ele é do HKUDS, o laboratório de inteligência de dados da University of Hong Kong. É o mesmo laboratório que criou o Light RAG e alguns outros projetos populares de agent. A ideia é simples. As pessoas criam a maioria dos softwares para humanos. Eles têm botões, menus e janelas. Agents de IA não são bons nisso. Eles são bons com texto. Então, o CLI Anything pega um software e oferece uma interface de linha de comando que um agent pode usar. E faz isso com um único comando. Você

00:36 fornece o código-fonte de um aplicativo, como o Blender. Então, seu agent de programação lê o código e cria uma CLI completa para ele. Também escreve testes, documentação e um arquivo de skill para o agent. O repo já tem mais de 54.000 estrelas. Ele é licenciado sob Apache 2.0 e é totalmente open source. Portanto, é um projeto bem grande. Agora, vamos falar sobre por que uma CLI é a interface certa neste caso. Atualmente, existem três maneiras comuns de permitir que um agent use um aplicativo de desktop. A primeira é a automação de GUI. O agent faz capturas de tela e clica em pixels. Isso é lento e deixa de funcionar quando a interface muda.

01:10 A segunda é uma API, mas muitos aplicativos não têm uma, ou a API cobre apenas uma pequena parte do aplicativo. A terceira é uma reimplementação. Alguém cria uma pequena cópia do aplicativo em Python, mas essa cópia não tem a maioria dos recursos. Uma CLI resolve esses problemas. Agents já sabem usar um terminal. Uma CLI recebe texto e retorna texto. Cada comando tem uma página de ajuda para que o agent possa descobrir o que consegue fazer. E aqui todo comando também tem uma flag –json. Com essa flag, a saída é um JSON limpo que o agent pode ler sem precisar adivinhar. O outro ponto importante é que o CLI Anything não substitui o

01:43 software de verdade. Ele o chama. Por exemplo, a CLI do LibreOffice cria um PDF de verdade por meio do LibreOffice em modo headless. A CLI do Blender renderiza usando o Blender de verdade. O projeto chama isso de integração autêntica com o software. Assim, você obtém todo o poder do aplicativo, não uma versão de brinquedo. Agora, há duas maneiras de usar este projeto. A primeira é usar CLIs que outras pessoas já criaram. A segunda é criar uma nova CLI para o seu próprio software. Vou mostrar as duas. Vamos começar pela primeira, que é o CLI Hub.

02:15 O CLI Hub é um gerenciador de pacotes para essas CLIs. Para instalá-lo, abra o terminal e execute pip install cli-anything-hub. Você precisa do Python 3.10 ou mais recente. Quando a instalação terminar, execute cli-hub-list. Isso mostra todas as CLIs do registro. Há muitas. Você pode ver Blender, Inkscape, Audacity, OBS Studio, LibreOffice, Kdenlive, Shotcut, draw.io, Zoom, Ollama, ComfyUI, FreeCAD, QGIS, Obsidian, Zotero e muitas outras. Se estiver procurando algo específico, execute cli-hub-search e depois digite uma palavra-chave.

02:45 Por exemplo, cli-hub-search-image. Agora, você só vê as ferramentas de imagem. Para instalar uma, execute cli-hub-install-gimp. Depois, execute cli-hub-info-gimp para ver os detalhes. E, para iniciá-la, execute cli-hub-launch-gimp. Uma coisa importante: essas CLIs chamam o aplicativo de verdade. Então, se instalar a CLI, você também precisa ter o aplicativo na sua máquina. O mesmo vale para Blender, LibreOffice e os outros. Agora, vamos disponibilizá-la para um agent. O projeto tem uma meta skill para o CLI Hub. Uma meta skill é uma skill que ensina o agent a

03:16 encontrar e instalar outras ferramentas. Para adicioná-la, execute npx-skills-add-hkuds/cli-anything. Depois, –skill cli-hub-meta-skill, em seguida, -g e, por fim, -y. A flag -g faz uma instalação global. A flag -y ignora as perguntas. Isso funciona com Claude Code, Codex, Open Claw, Nanobot, Antigravity e outros agents que oferecem suporte a skills. Depois, você pode dar ao seu agent um prompt como este: encontre um software CLI adequado no CLI Hub e conclua a tarefa.

03:49 E depois disso, você escreve a sua tarefa. Digamos que eu peça para ele criar um diagrama de arquitetura simples. O agent pesquisa no Hub. Ele encontra a CLI do draw.io, instala-a, lê o arquivo de skill dessa CLI e começa a executar comandos. Ele adiciona formas, conecta-as e, no final, exporta um PNG. E eu não disse a ele qual ferramenta usar. Ele encontrou a ferramenta sozinho. Isso é bem legal, com certeza. Agora, vamos à parte principal, que é o gerador de CLI. É isso que você usa quando o Hub não tem o software que deseja ou quando tem sua própria ferramenta interna

04:22 e quer que seus agents a usem. Vou mostrar isso no Claude Code, mas também funciona no Cursor, Code X, Open Code, Pi, Hermes, GitHub Copilot CLI e alguns outros. Primeiro, você precisa adicionar o marketplace. No Claude Code, execute /plugin marketplace add HKUDS/CLI-anything. Depois, execute /plugin install cli-anything. E pronto. O plugin está ativo. Se você usa Windows, precisa do Git for Windows ou do WSL. O Claude Code executa comandos de shell por meio do Bash, e o plugin precisa dele. Agora, para criar uma CLI, execute /cli-anything e depois informe um caminho ou

04:56 uma URL do GitHub. Por exemplo, /cli-anything ./ . Ou você pode informar a URL do repo do Blender no GitHub. Então, o plugin executa um pipeline com sete fases. Vou explicar cada uma. A fase um é análise. O agent lê o código-fonte. Ele encontra as ações realizadas pela GUI e associa cada ação ao código que a executa. A fase dois é o planejamento. O agent planeja os grupos de comandos, o modelo de estado e os formatos de saída. A fase três é a implementação. O agent escreve a CLI usando a biblioteca Click em Python. Toda CLI recebe um modo REPL, saída em JSON e funções de desfazer e refazer.

05:29 A fase quatro é planejar os testes. O agent escreve um arquivo chamado test.md com um plano para testes unitários e testes de ponta a ponta. A fase cinco é escrever os testes. O agent escreve os testes com base nesse plano. A fase seis é documentar. O agent executa os testes e registra os resultados em test.md. Nessa fase, ele também cria um arquivo skill.md. Outros agents usam esse arquivo para encontrar a CLI. A fase sete é publicar. O agent cria um arquivo setup.py e instala a CLI no seu PATH. Isso leva algum tempo, então vamos esperar um pouco.

06:02 E agora terminou. Agora, vamos usar a CLI que ele criou. Entre na pasta do agent harness e execute pip install -e .; depois, você poderá chamá-la de qualquer lugar. Todas as CLIs seguem o mesmo padrão de nome. É cli-anything- seguido do nome do software. Então, aqui está: cli-anything-blender. Se executarmos cli-anything-blender –help, veremos todos os grupos de comandos. Agora, vamos criar um projeto. Eu executo cli-anything-blender project new com uma largura de 1920 e uma altura de 1080 e um arquivo de saída chamado poster.json. Depois, adiciono uma camada com a flag –json. E você pode ver que a saída é um JSON limpo.

06:32 O README também tem um bom exemplo com o LibreOffice. Então, vamos experimentar. Primeiro, crio um novo documento do Writer. Depois, adiciono um título que diz “Relatório do primeiro trimestre”. Em seguida, adiciono uma tabela com quatro linhas e três colunas. Depois, executo o comando export render para criar um PDF. E aqui está o PDF. É um PDF de verdade, criado pelo LibreOffice em modo headless. Agora, se você executar uma CLI sem nenhum comando, entrará no modo REPL. Vamos experimentar com Blender. Executo cli-anything-blender e recebo um prompt interativo. Digito scene new com o nome product shot.

07:05 Depois, adiciono uma malha de cubo. Em seguida, executo render execute com o mecanismo Cycles. E o Blender renderiza a imagem em segundo plano. O prompt também mostra o nome da cena e exibe um asterisco quando há alterações não salvas. Assim, o agent sempre sabe qual é o estado atual. É isso. Agora, a primeira execução nem sempre cobre o aplicativo inteiro. Para isso, existe o comando refine. Execute /cli-anything:refine e depois informe o caminho. O agent compara o que o software consegue fazer com o que a CLI consegue fazer. Então, ele adiciona comandos, testes e documentação

07:36 para preencher as lacunas. Você também pode definir um foco. Por exemplo, pode dizer que quer mais comandos para processamento em lote e filtros. Você pode executar refine várias vezes. Cada execução acrescenta itens à CLI e não apaga o trabalho anterior. Há também mais dois comandos. O comando test executa os testes e atualiza test.md. O comando validate verifica a CLI em relação às regras do projeto. Essas regras estão em um arquivo chamado harness.md. Esse é o manual que o agent segue em cada fase. Ele traz algumas boas lições. Por exemplo, a CLI precisa usar o software de verdade. Ela não pode usar Pillow no lugar de Outra lição

08:10 é que um código de saída zero não prova que uma exportação funcionou. Por isso, os testes verificam os arquivos de saída reais. Eles verificam os bytes mágicos, a estrutura do arquivo, os pixels, os níveis de áudio e a duração. E os números dos testes são bons. O readme mostra mais de 2.400 testes aprovados em cerca de 30 harnesses. Cada harness tem testes unitários com dados fictícios e testes de ponta a ponta com o software real. Além disso, se o software real não estiver instalado, os testes falham. Eles não são ignorados. Gosto muito disso, porque um teste ignorado pode esconder uma CLI com problemas.

08:41 O readme também tem algumas boas demonstrações. Em uma delas, um agent constrói um rover Curiosity no FreeCAD, passo a passo, com uma prévia ao vivo. Em outra, um agent constrói um drone de ficção científica no Blender. Há também um agent que joga Slay the Spire 2 pela CLI. E há um que controla uma sessão ao vivo do ArcGIS Pro. Portanto, isso não serve apenas para ferramentas de escritório. Agora, vamos falar das limitações, porque existem algumas. Primeiro, é preciso um modelo poderoso. O readme diz que você precisa de um modelo de classe frontier para obter resultados confiáveis. Eles listam modelos como Claude Opus e Sonnet e GPT-5.4.

09:15 Um modelo local pequeno pode criar uma CLI incompleta ou incorreta. Portanto, não é barato usar isso em uma base de código grande. A geração pode consumir muitos tokens. Segundo, funciona melhor quando você tem o código-fonte. Se você só tiver um binário compilado, a qualidade e a cobertura serão muito menores. Terceiro, uma execução muitas vezes não é suficiente. Provavelmente, você vai precisar executar refine algumas vezes antes de a CLI estar boa para trabalho de verdade. E também vou dizer o seguinte: uma CLI criada por um agent ainda é código criado por um agent. Então, leia os testes e verifique os comandos antes de

09:46 dar acesso a arquivos importantes. No geral, acho que é uma ideia muito boa. Agents de GUI que usam capturas de tela são lentos e custam caro. Uma CLI com saída JSON é rápida, barata e fácil de usar por um agent. E este projeto faz o trabalho tedioso de criar essa CLI para você. A parte do hub de CLI também é gratuita e fácil de usar, mesmo que você nunca crie uma CLI por conta própria. Se você usa bastante Claude code ou Codex, eu instalaria primeiro a meta skill do hub de CLI. Ela não custa nada, e seu agent ganha um grande conjunto de novas ferramentas. Então, se você tiver um aplicativo que não esteja no

10:18 hub, experimente o gerador com ele. No geral, é bem legal. Enfim, conte o que você achou nos comentários. Se você gostou deste vídeo, considere fazer uma doação pela opção super [música] thanks ou se tornar membro clicando no botão de adesão. Além disso, dê um [música] gostei neste vídeo e inscreva-se no meu canal. Até a próxima. Até lá, tchau. >> [música]

10:49 [campainha]

Transcrição original

[00:03] Hi. Welcome to another video. So today I want to talk about a project called CLI anything. It comes from HKUDS, the data intelligence lab at the University of Hong Kong. This is the same lab that made Light RAG and a few other popular agent projects. The idea is simple. People make most software for humans. It has buttons, menus, and windows. AI agents are not good at those. They are good at text. So CLI anything takes a piece of software and gives it a command line interface that an agent can use. And it does this with one command. You

[00:36] give it the source code of an app like or Blender. Then your coding agent reads the code and builds a full CLI for it. It also writes tests, docs, and a skill file for the agent. The repo has more than 54,000 stars now. It is Apache 2.0 licensed and it is fully open source. So this is quite a big project. Now, let’s talk about why a CLI is the right interface here. At the moment, there are three common ways to let an agent use a desktop app. The first is GUI automation. The agent takes screenshots and clicks on pixels. This is slow and it breaks when the UI changes.

[01:10] The second is an API, but many apps do not have one or the API covers only a small part of the app. The third is a rewrite. Someone builds a small copy of the app in Python, but that copy misses most of the features. A CLI fixes these problems. Agents already know how to use a terminal. A CLI is text in and text out. Each command has a help page so the agent can discover what it can do. And here every command also has a dash-dash JSON flag. With that flag, the output is clean JSON that the agent can read without guessing. The other important point is that CLI anything does not replace the

[01:43] real software. It calls it. For example, the LibreOffice CLI makes a real PDF through LibreOffice in headless mode. The Blender CLI renders with real Blender. The project calls this authentic software integration. So you get the full power of the app, not a toy version of it. Now, there are two ways to use this project. The first way is to use CLIs that other people already made. The second way is to build a new CLI for your own software. Let me show you both. Let’s start with the first way, which is CLI hub.

[02:15] CLI hub is a package manager for these CLIs. To install it, open your terminal and run pip install cli-anything-hub. You need Python 3.10 or or newer. When the install finishes, run cli-hub-list. This shows you every CLI in the registry. There are a lot of them. You can see Blender, Inkscape, Audacity, OBS Studio, LibreOffice, Kdenlive, Shotcut, draw.io, Zoom, Ollama, ComfyUI, FreeCAD, QGIS, Obsidian, Zotero, and many more. If you want something specific, run cli-hub-search and then type a keyword.

[02:45] For example, cli-hub-search-image. Now, you only see the image tools. To install one, run cli-hub-install-gimp. Then, run cli-hub-info-gimp to see the details. And to start it, run cli-hub-launch-gimp. One thing to note here, these CLIs call the real app. So, if you install the CLI, you also need on your machine. The same is true for Blender, LibreOffice, and the others. Now, let’s give this to an agent. The project has a meta skill for CLI hub. A meta skill is a skill that teaches the agent how to

[03:16] find and install other tools. To add it, run npx-skills-add-hkuds/cli-anything. Then {dash} {dash} skill cli-hub-meta-skill, then {dash} g, and then {dash} y. The {dash} g flag makes it a global install. The {dash} y flag skips the questions. This works with Claude Code, Codex, Open Claw, Nanobot, Antigravity, and other agents that support skills. Then, you can give your agent a prompt like this. Find appropriate CLI software in CLI hub and complete the task.

[03:49] And after that, you write your task. So, let’s say I ask it to make a simple architecture diagram. The agent searches the hub. It finds the draw.io CLI, it installs it, then it reads the skill file for that CLI, and starts to run commands. It adds shapes, it connects them, and it exports a PNG at the end. And I did not tell it which tool to use. It found the tool by itself. So, this is pretty cool for sure. Now, let’s come to the main part, which is the CLI generator. This is what you use when the hub does not have the software that you want, or when you have your own internal tool,

[04:22] and you want your agents to use it. I will show this in Claude Code, but it also works in Cursor Code X Open Code, Pi, Hermes, GitHub Copilot CLI, and a few more. First, you need to add the marketplace. In Claude Code, run {slash} plugin marketplace add HKUDS {slash} CLI anything. Then run {slash} plugin install cle anything. And that’s it. The plugin is now active. If you use Windows, you need Git for Windows or WSL. Claude Code runs shell commands through Bash, and the plugin needs it. Now, to build a CLI, you run {slash} cle anything, and then you give it a path or

[04:56] a GitHub URL. For example, {slash} cle anything. {dot} {slash} Or you can give it the Blender GitHub repo URL. Then the plugin runs a pipeline with seven phases. Let me explain each one. Phase one is analyze. The agent reads the source code. It finds the actions that the GUI does, and it maps each action to the code that does it. Phase two is design. The agent plans the command groups, the state model, and the output formats. Phase three is implement. The agent writes the CLI with the Click library in Python. Every CLI gets a REPL mode, JSON output, and undo and redo.

[05:29] Phase four is plan tests. The agent writes a file called test.md with a plan for unit tests and end-to-end tests. Phase five is write tests. The agent writes the tests from that plan. Phase six is document. The agent runs the tests and writes the results back into test.md. In this phase, it also makes a skill.md file. Other agents use this file to discover the CLI. Phase seven is publish. The agent makes a setup.py file and installs the CLI on your path. This takes some time, so let’s wait a bit.

[06:02] And it is now done. Now, let’s use the CLI that it made. Go into the agent harness folder and run pip install {dash} e {dot} then you can call it from anywhere. Every CLI has the same name pattern. It is cli-anything {dash} and then the name of the software. So, here it is cli-anything If we run cli-anything {dash} {dash} help, we see all the command groups. Now, let’s make a project. I run cli-anything project new with a width of 1920 and a height of 108, an output file called poster.json. Then I add a layer with the {dash} {dash} json flag. And you can see that the output is clean

[06:32] json. This is what the agent reads. The readme also has a good LibreOffice example. So, let’s try that, too. First, I make a new writer document. Then I add a heading that says Q1 report. Then I add a table with four rows and three columns. Then I run the export render command to make a PDF. And here is the PDF. It is a real PDF and LibreOffice made it in headless mode. Now, if you run a CLI with no command, you get the rebel mode. Let’s try it with Blender. I run cli-anything Blender and I get an interactive prompt. I type scene new with the name product shot.

[07:05] Then I add a cube mesh. Then I run render execute with the cycles engine. And Blender renders the image in the background. The prompt also shows the scene name and it shows a star when there are changes that are not saved. So, the agent always knows the current state. So, there’s that. Now, the first run does not always cover the full app. For this, there is the refine command. Run {slash} cli-anything {colon} refine and then the path. The agent compares what the software can do with what the CLI can do. Then it adds commands, tests, and docs

[07:36] for the gaps. You can also give it a focus. For example, you can say that you want more commands for batch processing and filters. You can run refine many times. Each run adds to the CLI and it does not delete the old work. There are also two more commands. The test command runs the tests and updates test.md. The validate command checks the CLI against the project rules. Those rules are in a file called harness.md. This is the playbook that the agent follows in every phase. It has some good lessons in it. For example, the CLI must use the real software. It must not use Pello in place of Another lesson

[08:10] is that an exit code of zero does not prove that an export worked. So, the tests check the real output files. They check magic bytes, file structure, pixels, audio levels, and duration. And the test numbers are good. The readme shows more than 2,400 passing tests across about 30 harnesses. Each harness has unit tests with fake data and end-to-end tests with the real software. Also, if the real software is not installed, the tests fail. They do not skip. I like this a lot because a skipped test can hide a broken CLI.

[08:41] The readme also has some good demos. In one demo, an agent builds a Curiosity Rover in FreeCAD step-by-step with a live preview. In another one, an agent builds a sci-fi drone in Blender. There is also an agent that plays Slay the Spire 2 through the CLI. And there is one that drives a live ArcGIS Pro session. So, this is not only for office tools. Now, let’s talk about the limitations because there are some. First, it needs a strong model. The readme says that you need a frontier class model for reliable results. They list models like Claude Opus and Sonnet and GPT-5.4.

[09:15] A small local model can make a CLI that is not complete or not correct. So, this is not cheap to run on a big code base. The generation can use a lot of tokens. Second, it works best when you have the source code. If you only have a compiled binary, the quality and the coverage become much lower. Third, one run is often not enough. You will probably need to run refine a few times before the CLI is good for real work. And I will also say this, a CLI that an agent made is still code that an agent made. So, read the tests and check the commands before

[09:46] you give it access to important files. Overall, I think that this is a really good idea. GUI agents with screenshots are slow and they cost a lot. A CLI with JSON output is fast, cheap, and easy for an agent to use. And this project does the boring work of making that CLI for you. The CLI hub part is also free and easy to use, even if you never build a CLI yourself. If you use Claude code or Codex a lot, I would install the CLI hub meta skill first. It costs nothing and your agent gets a big set of new tools. Then, if you have an app that is not in

[10:18] the hub, try the generator on it. Overall, it’s pretty cool. Anyway, let me know your thoughts in the comments. If you like this video, consider donating through the super [music] thanks option or becoming a member by clicking the join button. Also, give this video [music] a thumbs up and subscribe to my channel. I’ll see you in the next one. Until then, bye. >> [music]

[10:49] [bell]