Skip to content
Back to search

claude-video-editor

Edita vídeos longos do YouTube (gravação de tela + voz) por código, do bruto ao MP4 final - cortes de silêncio e gagueira com Whisper, motions animados, música com ducking, legenda .srt, capítulos e descrição. Use quando pedirem para editar um vídeo bruto ou configurar a pasta de edição.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked yesterday
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/vitormenoli--claude-video-editor/badge.svg)](/listings/vitormenoli--claude-video-editor)

HTML

<a href="/listings/vitormenoli--claude-video-editor"><img src="/api/listings/vitormenoli--claude-video-editor/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 189 lines
  1. ---
  2. name: claude-video-editor
  3. description: Edita vídeos longos do YouTube (gravação de tela + voz) por código, do bruto ao MP4 final - cortes de silêncio e gagueira com Whisper, motions animados, música com ducking, legenda .srt, capítulos e descrição. Use quando pedirem para editar um vídeo bruto ou configurar a pasta de edição.
  4. ---
  5. # Claude Video Editor
  6. Esta skill transforma um vídeo bruto (gravação de tela + voz) num vídeo pronto para o YouTube, sem editor de vídeo:
  7. - corta **todo** silêncio, gagueira, falso começo e frase recomeçada (fica sempre a última versão);
  8. - corta as esperas (instalação, programa carregando, IA respondendo);
  9. - coloca **motions** animados (título, capítulos, painéis, etiquetas, números, comparações) quando a tela fica parada;
  10. - desfoca o que não pode aparecer;
  11. - mixa a voz com música de fundo baixinha e ducking, e fecha com o encerramento do canal (os dois são opcionais);
  12. - entrega o vídeo, a legenda `.srt`, os capítulos e a descrição para o YouTube.
  13. Ferramentas: Python, FFmpeg, faster-whisper e Playwright. Quem edita é o Claude; a pessoa só coloca os arquivos na pasta e aprova.
  14. Neste guia, `<SKILL>` é a pasta onde está este arquivo e `<PASTA>` é a pasta de edição escolhida pela pessoa.
  15. ## Regras que nunca mudam
  16. 1. **Nunca invente fala.** Edição é cortar e decorar o que foi gravado. Nada de frase nova, voz sintética ou texto atribuído à pessoa.
  17. 2. **Nunca altere nem apague os arquivos da pessoa** (bruto, partes, roteiro, música, encerramento). Tudo de trabalho fica em `<PASTA>/_edicao`.
  18. 3. **Números de teste são sempre os reais da tela**, com a fonte em letra pequena.
  19. 4. **Logo de outra marca só por print real** do site oficial (`motions/capturar.js`). Nunca redesenhar.
  20. 5. **Na dúvida, não corte.** Nenhum corte pode mudar o sentido da fala.
  21. 6. Siga a `folha_de_estilo.md` e o `config_editor.json` da pasta de edição: eles mandam mais que os padrões deste guia.
  22. ---
  23. ## 1. Primeira vez: configurar a pasta de edição
  24. Faça isto quando a pessoa instalar a skill, pedir para configurar, ou quando `<PASTA>/config_editor.json` não existir.
  25. ### 1.1 Pedir a pasta
  26. - Peça a pasta que vai ser usada para editar os vídeos (ex.: `C:\Users\nome\Videos\Edicoes`).
  27. - No Claude Code, peça o caminho (ou use a pasta aberta, se a pessoa disser que é ela). No app do Claude com o computador conectado, peça acesso à pasta.
  28. ### 1.2 Instalar tudo
  29. ```bash
  30. python <SKILL>/scripts/instalar.py --baixar-modelo=large-v3
  31. ```
  32. - Ele instala sozinho os pacotes Python, o Playwright e o Chromium do Playwright, e baixa o modelo do Whisper (o `large-v3` tem ~3 GB).
  33. - Python 3.10+, FFmpeg (com libx264 e libvpx-vp9) e Node.js 18+ são programas do sistema. Se faltar algum, o script diz exatamente o que falta e o comando para instalar (winget no Windows, brew no macOS, apt no Linux). **Mostre isso à pessoa** e pergunte se pode rodar o comando; depois rode o `instalar.py` de novo até sair "Tudo pronto para editar".
  34. - No Windows o comando pode ser `python` ou `py`; no macOS/Linux, `python3`.
  35. ### 1.3 Perguntar as configurações
  36. Pergunte numa mensagem só (ou com perguntas de múltipla escolha), já com os padrões:
  37. | # | Pergunta | Padrão | Campo no `config_editor.json` |
  38. |---|---|---|---|
  39. | 1 | Duração mínima e máxima do vídeo final | 8 e 15 min | `duracao_minima_min`, `duracao_maxima_min` |
  40. | 2 | Quer prévias para aprovar antes do vídeo final? Ou o resultado final direto? | prévias de 60 s (início) e 30 s (fim) | `previas`, `previa_inicio_s`, `previa_fim_s` |
  41. | 3 | Vai usar música de fundo? | sim, `Midia do Canal/musica_fundo.mp3` | `musica_de_fundo` (`null` = sem música) |
  42. | 4 | Tem um encerramento (vinheta/logo animada) para o final? | sim, `Midia do Canal/encerramento.mp4` | `encerramento` (`null` = sem) |
  43. | 5 | Identidade dos motions: marca d'água, cor de destaque e cor de fundo | sem marca, `#4F8CFF`, `#0F1115` | `motions.marca_dagua`, `motions.cor_destaque`, `motions.cor_fundo` |
  44. | 6 | Efeitos sonoros baixinhos nos motions? | sim | `efeitos_sonoros` |
  45. | 7 | Qualidade da transcrição | `large-v3` (melhor); `medium` ou `small` (mais rápidos, erram mais) | `modelo_whisper` |
  46. | 8 | Volume da voz | -14 LUFS (padrão do YouTube) | `voz_alvo_lufs` |
  47. | 9 | Entregar legenda `.srt`, capítulos e descrição? | sim | `legenda_srt`, `capitulos`, `descricao_youtube` |
  48. ### 1.4 Criar a pasta
  49. ```bash
  50. python <SKILL>/scripts/configurar_pasta.py "<PASTA>" --config='{"duracao_minima_min": 8, "previas": true, "musica_de_fundo": null, "motions": {"marca_dagua": "› MEU CANAL"}}'
  51. ```
  52. Cria:
  53. ```
  54. <PASTA>/
  55. Arquivos Brutos/ vídeo bruto + roteiro (com LEIA-ME.txt explicando)
  56. Midia do Canal/ musica_fundo.mp3, encerramento.mp4, logo.png (opcionais)
  57. Resultado Final/ onde sai o vídeo editado
  58. _edicao/ arquivos de trabalho
  59. config_editor.json as respostas acima
  60. folha_de_estilo.md regras de edição (a pessoa pode editar)
  61. ```
  62. Rodar de novo não apaga nada; serve também para mudar uma configuração depois.
  63. ### 1.5 Explicar o uso
  64. Diga à pessoa, em poucas linhas:
  65. - coloque em **Arquivos Brutos** o vídeo bruto: **um vídeo só**, ou várias partes com os nomes **"Parte 1.mp4", "Parte 2.mp4"...** (juntadas nessa ordem);
  66. - coloque junto o **roteiro** em `.md` ou `.txt`: título, descrição, blocos/assuntos na ordem, links citados e o que não pode aparecer na tela;
  67. - coloque a música e o encerramento em **Midia do Canal**, se escolheu usar;
  68. - depois é só pedir: "edita o vídeo".
  69. ---
  70. ## 2. Editar um vídeo
  71. ### Etapa 0 · Preparar
  72. ```bash
  73. python <SKILL>/scripts/preparar_video.py "<PASTA>"
  74. ```
  75. - Confere a pasta **Arquivos Brutos**: um vídeo só, ou partes "Parte N" (junta na ordem). Se tiver vídeos fora do padrão, ele para e explica; passe a explicação para a pessoa.
  76. - Acha o roteiro (`.md`/`.txt`), extrai os áudios, mede a música, confere o encerramento e gera `_edicao/configuracao_video.json` e `_edicao/decisoes.json`.
  77. - Leia a `folha_de_estilo.md`, o `config_editor.json` e o roteiro inteiro antes de seguir.
  78. - Se faltar algo que o roteiro e a folha de estilo não respondem, pergunte numa mensagem só.
  79. ### Etapa 1 · Transcrição e cortes
  80. Dentro de `<PASTA>/_edicao`:
  81. ```bash
  82. python <SKILL>/scripts/transcrever_blocos.py large-v3 voz_16k.flac transcricao_large.jsonl blocos.txt
  83. python <SKILL>/scripts/transcrever_disfluencias.py large-v3 voz_16k.flac silencios_03.txt transcricao_disfluencias.jsonl
  84. ```
  85. (use o `modelo_whisper` do config). As duas demoram; rode em segundo plano e acompanhe.
  86. - Leia **as duas** transcrições inteiras. A limpa esconde as retomadas; a de disfluências mostra cada tomada repetida.
  87. - Anote em `decisoes.json` (exemplo em `<SKILL>/modelos/decisoes_modelo.json`):
  88. - `remover`: retomadas, frases abandonadas, trechos que a pessoa mandou cortar durante a gravação ("corta essa parte": corte a parte e o recado). Fica sempre a **última** versão.
  89. - `manter`: trechos que nenhum corte automático pode tocar.
  90. - `correcoes_texto`: nomes que o Whisper erra, para a legenda.
  91. - `"exato": true` quando o ponto do corte precisa ser exatamente aquele.
  92. - Os tempos do Whisper marcam as palavras ~0,3 s **antes** do som real e erram mais perto de hesitação. Para cortes manuais, olhe a energia da voz: `python <SKILL>/scripts/ferramentas/rajadas.py voz_16k.flac transcricao_disfluencias.jsonl 90:92` e corte no buraco entre as rajadas.
  93. ```bash
  94. python <SKILL>/scripts/montar_cortes.py transcricao_large.jsonl silencios_03.txt decisoes.json . transcricao_disfluencias.jsonl voz_16k.flac
  95. ```
  96. Sozinho ele corta: silêncio acima de `silencio_minimo_s` (deixando `respiro_s` de cada lado), palavra repetida em sequência (menos ênfase, como "muito muito"), esperas longas sem fala (só a partir de uma pausa real, e nunca onde há voz); e encaixa cada corte no respiro mais próximo.
  97. **Conferência obrigatória:**
  98. ```bash
  99. python <SKILL>/scripts/montar_voz_editada_16k.py voz_16k.flac mapa_tempo.json voz_editada_16k.wav
  100. python <SKILL>/scripts/transcrever_voz_editada.py large-v3 voz_editada_16k.wav transcricao_voz_editada "nomes próprios do vídeo"
  101. ```
  102. - Leia o `transcricao_voz_editada.txt` inteiro: é exatamente o que vai ao ar. Sobrou gagueira ou foi comida alguma palavra? Ajuste o `decisoes.json` e repita.
  103. - Compare a duração final com `duracao_minima_min` e `duracao_maxima_min`. Fora do intervalo: avise a pessoa antes de seguir (nunca estique com silêncio ou fala inventada; se passar do máximo, sugira o que pode sair).
  104. - Fechamento da etapa para a pessoa: duração antes/depois, número de cortes, retomadas que saíram.
  105. ### Etapa 2 · Motions
  106. 1. Escreva `_edicao/roteiro_motions.json` (exemplo em `<SKILL>/modelos/roteiro_motions_modelo.json`, referência em `<SKILL>/referencias/modelos_de_motion.md`). Cada motion é ancorado numa **frase do bruto** (como na `transcricao_large.jsonl`, sem pontuação) com `depois_de` e `ajuste`. Os caminhos e volumes já vêm do `configuracao_video.json`.
  107. 2. Onde colocar o quê:
  108. - `abertura` de 3 a 5 s com o título, entrando enquanto a pessoa já fala;
  109. - `transicao` + `capitulo` no início de cada bloco do roteiro (com `"capitulo": "Título"` no item, viram os capítulos do YouTube);
  110. - tela parada enquanto a pessoa explica → `painel`, `numero` ou `comparacao`;
  111. - tela sem importância → motion em tela cheia; tela importante → `"layout": "dividido"` (tela à direita, motion à esquerda);
  112. - comandos digitados, ferramentas, números e avisos → `pilula` ou `comando`, discretos no canto;
  113. - **nunca mais de um elemento ao mesmo tempo** (o `planejar.py` avisa sobreposição) e nunca cobrindo o que importa.
  114. 3. **Desfoque:** o que não pode aparecer entra em `desfoques_fonte` (tempos do bruto + região em pixels). Ache o intervalo com um mosaico: `ffmpeg -ss <ini> -t <dur> -i <bruto> -vf "fps=2,scale=320:180,tile=6x2" -frames:v 1 mosaico.jpg`.
  115. 4. Rode e confira:
  116. ```bash
  117. python <SKILL>/scripts/planejar.py transcricao_large.jsonl mapa_tempo.json roteiro_motions.json .
  118. node <SKILL>/motions/renderizar.js especificacoes_motions.json previa --previa --identidade="<PASTA>/config_editor.json"
  119. python <SKILL>/scripts/montar_folha_contato.py plano.json mapa_tempo.json "<bruto>" previa folha
  120. ```
  121. Olhe as folhas de contato (`folha_0.jpg`...): texto estourando (no layout dividido, itens com até ~25 caracteres), etiqueta cobrindo algo importante, sobreposição. Corrija e renderize:
  122. ```bash
  123. node <SKILL>/motions/renderizar.js especificacoes_motions.json motions --identidade="<PASTA>/config_editor.json"
  124. ```
  125. (os `.webm` precisam ficar em `_edicao/motions/`; `--so=nome1,nome2` renderiza só alguns).
  126. Sem `"nome"` fixo, o nome do arquivo vem da posição no roteiro; inserir um motion no meio renomeia os seguintes.
  127. ### Etapa 3 · Prévias (se `previas` for `true`)
  128. ```bash
  129. python <SKILL>/scripts/montar_video_final.py "<PASTA>" --previas
  130. ```
  131. Monta o áudio, renderiza só as partes do começo e do fim e salva em `Resultado Final/Previas/`. Peça para a pessoa aprovar estilo, ritmo e volume da música. Ajuste o que ela pedir e só depois siga.
  132. Com `previas: false`, vá direto para a etapa 4.
  133. ### Etapa 4 · Vídeo final
  134. ```bash
  135. python <SKILL>/scripts/montar_video_final.py "<PASTA>" --final
  136. python <SKILL>/scripts/montar_srt_editado.py transcricao_voz_editada.jsonl decisoes.json "<PASTA>/Resultado Final/<nome>_editado.srt" <duração do vídeo>
  137. ```
  138. - Monta o áudio (voz no alvo de LUFS, música com ducking, efeitos, encerramento), renderiza as partes (reaproveita as que não mudaram), junta tudo em `Resultado Final/<nome>_editado.mp4`, copia `capitulos.txt` e `cortes.csv` e mostra a conferência (resolução, fps, LUFS, duração).
  139. - Confira tela parada demais: `ffmpeg -ss 0 -t 140 -i <video> -an -vf "scale=480:270,freezedetect=n=0.003:d=8" -f null - 2>&1 | grep freeze_` (em pedaços de 140 s). Trechos de mais de ~12 s sem nenhum elemento → mais motion e rode o `--final` de novo (só as partes que mudaram são refeitas).
  140. - Se `descricao_youtube` for `true`, escreva `Resultado Final/descricao_youtube.md`: a descrição do roteiro (sem mudar o texto), os links citados no vídeo e os capítulos com as minutagens finais (o primeiro sempre em 0:00).
  141. - Fechamento para a pessoa: o que ficou pronto, onde está e o que falta. Sem relatório longo. A pasta `_edicao` pode ser apagada depois que o vídeo for publicado.
  142. ---
  143. ## Padrões (quando o config não disser outra coisa)
  144. - Saída: H.264 1920x1080 30 fps, CRF 18, AAC 192 kbps.
  145. - Voz -14 LUFS, pico -1,5 dBTP, passa-alta 70 Hz, redução leve de ruído e compressão leve.
  146. - Música -40 LUFS nas pausas e -8 dB de ducking com voz, fade in de 1 s e fade out de 1,5 s terminando na entrada do encerramento.
  147. - Efeitos sonoros só nos motions, a -24 dB.
  148. - Transição curta entre blocos (0,4 s), corte seco dentro do bloco, crossfade de 0,5 s para o encerramento; sem encerramento, o vídeo termina com fade de 0,8 s.
  149. - Sem zoom nos cortes e sem legenda queimada.
  150. ## Computador remoto (opcional)
  151. Se o vídeo fica no computador da pessoa e o Claude trabalha num ambiente na nuvem ligado a ele, com limite de tempo por comando, veja `referencias/ambiente_remoto.md`: transcrição e motions na nuvem; áudio (uma etapa por comando) e partes (`renderizar_parte.py plano.json N`, uma por comando) no computador; junção com `juntar_final.py`.
  152. ## Problemas conhecidos
  153. | Sintoma | Causa | Correção |
  154. |---|---|---|
  155. | Processo da transcrição morre sem erro | Whisper large-v3 + Chromium ao mesmo tempo (falta de RAM) | Um de cada vez |
  156. | Gagueira continua no vídeo | O Whisper "limpa" repetições na transcrição normal | Passada de disfluências + conferência da voz editada |
  157. | Fim de palavra comido | Corte começando no fim marcado pelo Whisper | `montar_cortes.py` só começa espera em pausa real |
  158. | Frase inteira sumiu | A transcrição pulou a frase e ela virou "espera" | Lacuna com voz em mais de 30% do tempo não é cortada |
  159. | Áudio escorrega no fim | Parte com um quadro a menos | Contagem exata de quadros por parte (já feita) |
  160. | Legenda com palavras de tomadas cortadas | Legenda feita da transcrição do bruto | `.srt` feito da transcrição da voz editada |
  161. | "Nenhum vídeo" ou "fora do padrão Parte N" | Arquivos Brutos com nomes misturados | Um vídeo só ou "Parte 1.mp4", "Parte 2.mp4"... |
  162. | FFmpeg sem libvpx-vp9 | Build mínima do FFmpeg | Instalar uma build completa (o `instalar.py` mostra o comando) |
README.md · README · 92 lines
  1. # Claude Video Editor 🎬
  2. Uma skill para o Claude que edita vídeos longos do YouTube **do bruto ao MP4 final**, sem abrir editor de vídeo.
  3. Você grava a tela e fala, coloca o bruto e o roteiro numa pasta e pede "edita o vídeo". O Claude:
  4. - transcreve o vídeo duas vezes com o Whisper (uma limpa e outra que pega cada gagueira);
  5. - corta **todo** silêncio, gagueira, falso começo e frase recomeçada, sempre ficando a última versão;
  6. - corta as esperas (instalação, programa carregando, IA respondendo);
  7. - confere os cortes transcrevendo de novo o áudio já editado;
  8. - cria **motions animados** por código (título, capítulos, painéis, etiquetas, números, comparações) quando a tela fica parada;
  9. - desfoca o que não pode aparecer na tela;
  10. - mixa a voz com música de fundo baixinha e fecha com o seu encerramento (os dois opcionais);
  11. - entrega o vídeo, a legenda `.srt`, os capítulos e a descrição pronta para o YouTube.
  12. ## Instalação
  13. Peça ao Claude Code:
  14. > Instala essa skill pra mim: https://github.com/vitormenoli/claude-video-editor
  15. Ou instale na mão:
  16. ```bash
  17. git clone https://github.com/vitormenoli/claude-video-editor ~/.claude/skills/claude-video-editor
  18. ```
  19. (no Windows: `%USERPROFILE%\.claude\skills\claude-video-editor`)
  20. Na primeira vez, o Claude:
  21. 1. **pede a pasta** que vai ser usada para as edições;
  22. 2. **instala tudo sozinho** (pacotes Python, Playwright, modelo do Whisper) e, se faltar algo do sistema (Python, FFmpeg ou Node.js), diz exatamente o que falta e como instalar;
  23. 3. **pergunta como você quer editar:** duração mínima e máxima, se quer prévias antes do final, música de fundo, encerramento, cores e marca d'água dos motions, efeitos sonoros, qualidade da transcrição;
  24. 4. **cria a estrutura** da pasta com as suas configurações.
  25. Requisitos do sistema: Python 3.10+, FFmpeg 4.4+ (com libx264 e libvpx-vp9), Node.js 18+ e ~8 GB de RAM livre para o Whisper `large-v3` (os modelos `medium` e `small` usam menos).
  26. ## Como usar
  27. Depois de configurada, a pasta fica assim:
  28. ```
  29. Sua pasta/
  30. Arquivos Brutos/ ← coloque aqui o vídeo bruto e o roteiro (.md ou .txt)
  31. Midia do Canal/ ← música de fundo, encerramento e logo (opcionais)
  32. Resultado Final/ ← o vídeo editado sai aqui
  33. _edicao/ arquivos de trabalho
  34. config_editor.json suas configurações
  35. folha_de_estilo.md suas regras de edição (edite à vontade)
  36. ```
  37. - **Um vídeo só** em `Arquivos Brutos`, ou várias partes com os nomes **`Parte 1.mp4`, `Parte 2.mp4`...** (juntadas nessa ordem).
  38. - **Roteiro** com título, descrição, os blocos na ordem (viram os capítulos), links citados e o que não pode aparecer na tela.
  39. - Peça: **"edita o vídeo"**.
  40. Se você ativou as prévias, o Claude manda primeiro os 60 s do começo e os 30 s do fim para você aprovar (em `Resultado Final/Previas`). Depois sai o vídeo completo em `Resultado Final`.
  41. ## Como funciona
  42. ```mermaid
  43. flowchart LR
  44. A[Arquivos Brutos] --> B[preparar_video.py<br/>junta partes, extrai áudio]
  45. B --> C[Whisper: transcrição limpa]
  46. B --> D[Whisper: transcrição com hesitações]
  47. C & D --> E[montar_cortes.py<br/>silêncio, gagueira, retomadas]
  48. E --> F[conferência:<br/>transcreve o áudio editado]
  49. E --> G[roteiro_motions.json]
  50. G --> H[planejar.py]
  51. H --> I[motor.html + Playwright<br/>motions com transparência]
  52. H --> J[montar_audio.py<br/>voz, música, efeitos]
  53. I & J --> K[montar_video_final.py<br/>partes + encerramento]
  54. K --> L[Resultado Final<br/>vídeo + .srt + capítulos]
  55. ```
  56. O "editor" é o Claude seguindo o `SKILL.md`: ele lê as transcrições, decide o que cortar, escolhe onde entram os motions (sempre ancorados em frases da fala), confere tudo e só então renderiza.
  57. ## Personalizando
  58. - **Regras de edição:** `folha_de_estilo.md` na sua pasta (começa com um modelo).
  59. - **Números:** `config_editor.json` (duração, prévias, volumes, silêncio mínimo, música, encerramento). Para mudar depois, é só pedir ao Claude.
  60. - **Visual dos motions:** cor de destaque, cor de fundo e marca d'água no `config_editor.json` (`motions`). Para mudanças maiores, os modelos estão em `motions/motor.html` (cada modelo é uma função `modelos.<nome>`). Referência em `referencias/modelos_de_motion.md`.
  61. - **Sons:** `python motions/sons.py motions/sons` gera de novo os efeitos (pop, sopro, contador, digitação, impacto), sintetizados e sem direitos autorais.
  62. ## Estrutura do repositório
  63. | Pasta | Conteúdo |
  64. |---|---|
  65. | `SKILL.md` | O passo a passo completo que o Claude segue |
  66. | `scripts/` | Instalação, configuração da pasta, preparação, transcrição, cortes, conferência, planejamento, áudio, render, legenda |
  67. | `motions/` | Motor de motions (`motor.html`), renderizador Playwright, captura de prints, sons e fontes |
  68. | `modelos/` | Exemplos de `decisoes.json` e `roteiro_motions.json` |
  69. | `referencias/` | Modelo de folha de estilo, referência dos motions e o modo com computador remoto |
  70. ## Princípios
  71. - **Nunca inventa fala.** Edição é cortar e decorar o que foi gravado: nada de frase nova nem voz sintética.
  72. - **Não mexe nos seus arquivos.** Tudo de trabalho fica em `_edicao`.
  73. - **Números reais.** Resultado de teste vai com o número da tela e a fonte.
  74. - **Logos de outras marcas só por print real** do site oficial.
  75. ## Créditos
  76. Criado por [Vitor Menoli](https://www.youtube.com/@vitor.menoli) com o Claude.
  77. Fontes Inter e JetBrains Mono sob a SIL Open Font License 1.1 (veja `motions/fontes/LICENCAS.md`).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.