AI-translated from English; not yet reviewed by a fluent editor.

# Transformer une longue vidéo autorisée en cinq courts formats verticaux vérifiés

> Un processus fondé sur la documentation pour cinq extraits vidéo vérifiés à la source, avec sous-titres corrigés, cadrage vertical et examen humain.

By BIG CHANGE Editorial

Published: 2026-10-21T09:43:38.285Z
Updated: 2026-10-21T09:43:38.285Z
Canonical: https://bigchange.ai/blog/five-checked-video-shorts-claude-code-whisper-ffmpeg

![Conceptual charcoal illustration of five upright unbranded phones in a wall shelf, each showing a generic vertical image with a blank orange caption bar.](https://bigchange.ai/api/media/file/owned-video-five-shorts-hero-v1.png)
AI-generated conceptual illustration by BIG CHANGE.

Un enregistrement peut fournir plusieurs extraits courts, mais une transcription ne détermine pas si un extrait respecte le contexte, et un export de 1080 × 1920 ne prouve pas qu’il est agréable à regarder. Ce guide utilise cinq compétences de projet Claude Code invoquées manuellement pour organiser le travail : transcrire, classer, couper, sous-titrer et exporter. Un monteur humain approuve chaque intervalle source et regarde chaque fichier terminé. Le processus concerne une vidéo que vous possédez ou que vous avez expressément le droit de modifier et de partager.

Cette recette, destinée à Terminal sous macOS avec zsh, repose sur la documentation. BIG CHANGE n’a pas exécuté ces commandes, inspecté de séquences privées ni produit les cinq fichiers. Vérifiez l’aide des outils installés et vos médias réels avant de commencer. L’illustration principale représente conceptuellement les cinq vidéos verticales qu’un créateur examinerait. Elle ne montre ni des extraits réels, ni une sortie logicielle, ni un test BIG CHANGE du processus.

## Le grand changement

- **Ce qui change :** Les compétences de projet Claude Code peuvent répartir un montage vidéo local en cinq étapes invoquées manuellement. Les relevés de transmission proposés relient les repères temporels sources, les coupes approuvées, les sous-titres corrigés et les fichiers finaux ; la documentation des outils ne démontre pas que cet enchaînement précis a été exécuté avec succès.
- **Pourquoi cela compte :** Un créateur disposant des droits sur la vidéo peut confier au monteur une décision précise à chaque étape, y compris déterminer si cinq extraits distincts existent réellement. Cette structure permet de rejeter une coupe faible ou trompeuse avant de l’exporter avec des sous-titres.
- **À surveiller :** Le partage d’un résultat dépend toujours des droits, de la politique de données du compte Claude choisi et du visionnage intégral de chaque MP4 enregistré. Une analyse technique réussie du fichier ne tranche pas ces questions.

## Avant de commencer

Vous avez besoin d’un fichier local `source.mp4` avec un son exploitable, d’un stockage suffisant, d’un accès à Claude Code, d’un exécutable local whisper.cpp opérationnel `whisper-cli` et d’un modèle compatible avec la langue, ainsi que de FFmpeg et ffprobe avec les encodeurs et filtres requis. Un monteur doit pouvoir vérifier l’enregistrement et les cinq exports. Consignez le compte Claude Code et sa politique de données, les versions installées, le commit ou la compilation whisper.cpp, le SHA-256 et la licence du modèle, ainsi que les limites d’utilisation. Claude Code peut utiliser un modèle hébergé même si transcription et rendu sont locaux. Ne lui donnez que l’accès aux transcriptions ou médias autorisé par vos droits et la politique du compte. Ses [instructions de compétence](https://code.claude.com/docs/en/skills) ne restreignent pas les accès. Les [contrôles distincts d’autorisation des outils](https://code.claude.com/docs/en/permissions) régissent les appels ; selon les réglages, des lectures ordinaires peuvent s’exécuter sans demander confirmation. Examinez volontairement ce que la compétence peut lire, ainsi que ce qu’elle propose d’écrire ou d’exécuter.

Placez une copie immuable de la source et `rights.json` dans un nouveau dossier local de travail fiable. Le relevé des droits doit identifier le SHA-256 source, le monteur, les extraits et usages ultérieurs autorisés, les permissions relatives aux intervenants, à la musique et aux visuels, et les règles de stockage et de conservation. Ne continuez pas si les droits sont incertains. Ouvrez Terminal dans ce dossier, vérifiez `pwd`, puis créez les dossiers de travail :

```shell
mkdir -p transcript clips captions shorts probes .claude/skills/video-transcribe .claude/skills/video-rank .claude/skills/video-cut .claude/skills/video-caption .claude/skills/video-vertical
command -v claude
command -v ffmpeg
command -v ffprobe
claude --version
ffmpeg -version
ffprobe -version
ffmpeg -hide_banner -h encoder=libx264
ffmpeg -hide_banner -h encoder=aac
ffmpeg -hide_banner -h filter=subtitles
ffmpeg -hide_banner -h filter=scale
```

Définissez `WHISPER_CLI` et `WHISPER_MODEL` avec de vrais chemins absolus entre guillemets. Définissez `LANGUAGE` avec le code vérifié de la langue parlée, par exemple `en` seulement si l’audio est en anglais. Confirmez la compatibilité du modèle ; un modèle uniquement anglais `.en` ne couvre pas une autre langue. Une langue mixte ou non prise en charge nécessite un plan vérifié avant de continuer. La [référence CLI de whisper.cpp](https://github.com/ggml-org/whisper.cpp/blob/master/examples/cli/README.md) documente `-l`, `-m`, `-f`, `-osrt`, `-oj` et `-of`; vérifiez ces options dans l’aide de votre compilation. N’activez pas son option de traduction.

```shell
WHISPER_CLI='/absolute/path/to/whisper-cli'
WHISPER_MODEL='/absolute/path/to/approved-model.bin'
LANGUAGE='en'
test -x "$WHISPER_CLI"
test -r "$WHISPER_MODEL"
"$WHISPER_CLI" --help
ffprobe -v error -show_entries format=duration:stream=index,codec_type,codec_name,width,height,sample_aspect_ratio -of json source.mp4
```

Remplacez les chemins et la langue d’exemple avant toute exécution. Vérifiez la durée source, les flux, l’orientation, le son et l’espace libre. Confirmez que le filtre installé `subtitles` dispose de libass et que `scale` accepte `force_original_aspect_ratio`, `force_divisible_by` et `reset_sar`. Si une fonction manque, suivez les instructions de compilation des mainteneurs et recommencez les vérifications. Ne supprimez pas silencieusement les sous-titres.

## Créer cinq compétences de projet délimitées

Dans le projet fiable, enregistrez cinq fichiers distincts `.claude/skills/<name>/SKILL.md` . Chacun nécessite son propre `name`, `description`, `disable-model-invocation: true`, ainsi qu’une règle complète d’entrée, d’action, de sortie et d’arrêt. Invoquez-les manuellement, dans cet ordre : `/video-transcribe`, `/video-rank`, `/video-cut`, `/video-caption`, `/video-vertical`. N’ajoutez pas `allowed-tools`: Claude Code précise que ce champ autorise les outils répertoriés sans confirmation pendant l’invocation ; il ne limite pas la compétence. Conservez les autorisations normales et examinez les accès. Une lecture peut ne pas demander confirmation, tandis que les écritures et exécutions suivent les contrôles réels du compte.

Utilisez les contenus complets suivants avec le relevé commun décrit ci-dessous. Le texte d’une compétence est une instruction à Claude Code, pas une frontière de contrôle imposée.

**`.claude/skills/video-transcribe/SKILL.md`**

```markdown
---
name: video-transcribe
description: Transcribe the authorized local source for the five-short workflow.
disable-model-invocation: true
---

Input: rights.json, immutable source.mp4, checked source probe, verified language and local whisper.cpp executable/model. Confirm matching source and model hashes, usable audio and permitted access before any command.
Action: From the checked run directory, confirm source.wav and both transcript output paths do not exist. Extract mono 16 kHz 16-bit PCM source.wav with explicit first-audio mapping and no overwrite. Continue to whisper-cli only after a zero exit and valid WAV readback; use the verified model and explicit language, SRT and JSON output, and translation off. Inspect both outputs, parse source-relative times, and compare representative passages and uncertain names or quotes against source audio. Record a nonzero exit or uncertain output as a manifest blocker before any next stage.
Output: transcript/source.srt and transcript/source.json, recorded hashes, corrections or marked uncertainties, tool and model identity in manifest.json.
Stop: Missing rights, changed inputs, absent audio, empty or malformed transcript, or unverified relevant speech. Do not upload, publish or overwrite accepted files; ask the editor to settle uncertainty.
```

**`.claude/skills/video-rank/SKILL.md`**

```markdown
---
name: video-rank
description: Suggest source moments for human selection of five distinct clips.
disable-model-invocation: true
---

Input: Checked source transcript and hash, immutable source hash and probe duration, rights.json, intended audience. Verify all identities and authorized transcript access.
Action: Suggest more than five moments with numeric source-second start/end, source words, surrounding context and editorial rationale. Treat ranking as a suggestion, never a viral forecast. Have the editor open each candidate in the original and check speaker, wording, facts, context and rights. Record exactly five distinct coherent approved intervals and a rejected-candidate log.
Output: approved-moments.json with order, source hash and five numeric bounds satisfying 0 <= start < end <= source duration.
Stop: Fewer than five permissible, meaningful moments, mismatched hashes, uncertain bounds or missing human approval. Do not invent a fifth excerpt.
```

**`.claude/skills/video-cut/SKILL.md`**

```markdown
---
name: video-cut
description: Cut the five approved source intervals into separate local clips.
disable-model-invocation: true
---

Input: Immutable source.mp4, source hash/probe and five human-approved intervals. Verify hashes and calculate each duration as end minus start.
Action: For each 01-05, confirm its unique output path is unused, then transcode the approved source-relative interval with input -ss, -t duration, explicit first video/audio mapping, libx264, AAC and -n. Continue only on zero exit and file readback. Probe streams and duration, inspect first and last frames, and have the editor watch each whole cut for boundaries, sync and context. Record the exact command and output hash. Any failure or uncertain write is a manifest blocker; never pass that clip to captioning.
Output: Five accepted numbered clips, individual probe records and links to approved intervals in manifest.json.
Stop: Wrong bounds, absent stream, drift, misleading context, output collision or uncertain command result. Read back the existing path first; correct bounds with human approval and use a new filename. Never overwrite or reuse an old clip hash.
```

**`.claude/skills/video-caption/SKILL.md`**

```markdown
---
name: video-caption
description: Create and check local captions from each accepted clip.
disable-model-invocation: true
---

Input: Five accepted clip hashes, verified language and local model identity. Reject stale clips or mismatched source links.
Action: For each actual numbered clip 01-05, verify its accepted hash and unused WAV/raw-SRT paths, then extract its own mono 16 kHz 16-bit PCM WAV with -n. Run whisper-cli only after zero exit and WAV readback, with the matching language and SRT output; translation stays off. Preserve raw SRT. Have the editor correct words, names, numbers, cue timing, overlaps and readability against the actual clip, then save a distinct .checked.srt. Use clip-local times, not source-offset cues. Record failures as blockers before rendering.
Output: Five checked SRTs with raw-ASR and exact clip hash links in manifest.json.
Stop: Any cue outside clip duration, uncertain speech, bad alignment or stale clip hash. Repair and replay before rendering; a recut requires matching new captions.
```

**`.claude/skills/video-vertical/SKILL.md`**

```markdown
---
name: video-vertical
description: Render and review five captioned 1080x1920 MP4s.
disable-model-invocation: true
---

Input: Five accepted clip hashes/probes, matching checked SRT hashes, rights record and a human-approved crop or framing plan for each clip.
Action: Check decoded orientation and sample aspect ratio. Choose even integer crop width, height and x/y for each clip; require positive dimensions, nonnegative offsets and a rectangle within the decoded frame. A fixed crop does not track motion. Verify unique output and probe paths are unused. From the established run directory, render each separately with crop, aspect-preserving scale, pad, clip-local subtitles, explicit video/audio mapping, libx264, yuv420p, AAC and -n. Continue only on zero exit and saved-file readback. Create probe JSON without clobbering an existing path, reopen the MP4 and have the editor watch its entire video and audio, checking cut context, every caption, framing, sync, facts and rights. Record any failure or uncertain output as a blocker.
Output: Five distinct accepted 1080x1920 MP4s, hashes, probe JSON, exact source/clip/SRT lineage and UTC human acceptance notes.
Stop: Unknown orientation, invalid crop, missing filter, collision, unreadable file, silent audio, cut-off text, wrong duration, bad context or failed full playback. Inspect uncertain existing outputs; revise to a new filename, probe and watch again. No upload or publishing.
```

Conservez un seul `manifest.json` pour cette exécution. À chaque transmission, notez le relevé des droits et le SHA-256 immuable de la source, les versions des outils, le SHA-256, la licence et la langue du modèle, les entrées et sorties avec SHA-256, les intervalles sources numériques approuvés, les commandes exactes et les décisions UTC. Si un fichier nommé ou une empreinte diffère, arrêtez et résolvez le problème avant la compétence suivante.

Traitez chaque bloc de commandes ci-dessous comme une étape dans un nouveau script zsh ou un shell contrôlé, avec `set -e` pour qu’une commande en échec arrête l’étape. Vérifiez que chaque chemin de sortie est libre avant l’exécution et consignez tout code de sortie non nul, fichier manquant ou écriture incertaine comme obstacle dans le manifeste. La compétence suivante doit lire cet état et l’empreinte de sortie ; elle ne peut accepter une coupe ratée parce qu’un ancien extrait existe.

## 1. Transcrire la source

Le [README des mainteneurs de whisper.cpp](https://github.com/ggml-org/whisper.cpp/blob/master/README.md) indique que l’exemple CLI exige actuellement un WAV 16 bits. Après avoir confirmé la présence du son source, exécutez ce qui suit depuis le dossier de projet vérifié. `-n` empêche FFmpeg d’écraser un WAV existant.

```shell
set -e
test ! -e source.wav
test ! -e transcript/source.srt
test ! -e transcript/source.json
ffmpeg -i source.mp4 -map 0:a:0 -ar 16000 -ac 1 -c:a pcm_s16le -n source.wav
test -s source.wav
"$WHISPER_CLI" -m "$WHISPER_MODEL" -f source.wav -l "$LANGUAGE" -osrt -oj -of transcript/source
test -s transcript/source.srt
test -s transcript/source.json
```

Confirmez que `transcript/source.srt` et `.json` existent, contiennent des paroles horodatées et restent dans la durée source mesurée. Écoutez des passages représentatifs et vérifiez les noms, nombres et citations incertains dans l’original. Gardez une transcription corrigée ou des marques explicites d’incertitude. Si l’extraction ou la transcription est vide, examinez le flux source, l’exécutable, la langue et la compatibilité du modèle avant de tenter une nouvelle sortie sous un nom unique.

## 2. Sélectionner cinq moments dans l’original

Invoquez `/video-rank` avec la transcription vérifiée et le public visé. Demandez plus de cinq propositions pour pouvoir rejeter les extraits faibles. Pour chacune, exigez les secondes numériques de début et de fin depuis le début de la source, le passage prononcé, le contexte avant et après, et la raison pour laquelle il peut être compris seul. Ouvrez chaque intervalle dans l’original. Le monteur décide si l’intervenant, les paroles, le contexte visuel, les faits et les autorisations résistent à la coupe. Enregistrez exactement cinq intervalles distincts approuvés dans `approved-moments.json`; incluez l’ordre, l’empreinte source et `0 <= start < end <= source duration`. Un passage transcrit n’est qu’un repère. Pour la tâche plus ciblée de localisation temporelle, consultez [Retrouver le passage prononcé avant de monter une vidéo](https://bigchange.ai/blog/find-spoken-moment-before-video-editing).

Si l’enregistrement ne contient pas cinq passages défendables, arrêtez. La tâche à cinq fichiers reste incomplète.

## 3. Découper les intervalles approuvés

Invoquez `/video-cut`. Pour chaque intervalle, calculez `DURATION = END - START` à partir des bornes numériques approuvées. Remplacez les paramètres entre chevrons ci-dessous par de vraies valeurs ; ces paramètres ne sont pas exécutables. Répétez avec `clip-02.mp4` jusqu’à `clip-05.mp4`. FFmpeg documente la recherche dans l’entrée, la durée, la sélection explicite des flux et le [comportement de sortie sans écrasement](https://ffmpeg.org/ffmpeg.html). Réencodez au lieu de copier directement les flux pour les limites de coupe prévues.

```shell
set -e
test ! -e clips/clip-01.mp4
ffmpeg -ss <START_SECONDS> -i source.mp4 -t <DURATION_SECONDS> -map 0:v:0 -map 0:a:0 -c:v libx264 -c:a aac -n clips/clip-01.mp4
test -s clips/clip-01.mp4
```

Analysez les flux et la durée de chaque extrait réel, inspectez sa première et sa dernière image, puis regardez-le en entier. Notez son empreinte et l’intervalle source approuvé. Une mauvaise coupe nécessite de nouvelles bornes approuvées et un nouveau nom. En cas d’échec ou de résultat incertain, inspectez le fichier existant et son analyse avant toute répétition ; ne réessayez jamais vers le même nom.

## 4. Corriger les sous-titres sur chaque coupe réelle

Invoquez `/video-caption`. Transcrivez chaque extrait accepté : ses sous-titres doivent commencer à zéro au début de cet extrait. Pour l’extrait 01, les commandes sont :

```shell
set -e
test ! -e captions/clip-01.wav
test ! -e captions/clip-01.srt
ffmpeg -i clips/clip-01.mp4 -map 0:a:0 -ar 16000 -ac 1 -c:a pcm_s16le -n captions/clip-01.wav
test -s captions/clip-01.wav
"$WHISPER_CLI" -m "$WHISPER_MODEL" -f captions/clip-01.wav -l "$LANGUAGE" -osrt -of captions/clip-01
test -s captions/clip-01.srt
```

Répétez avec le numéro à deux chiffres correspondant, de 02 à 05, et des chemins distincts. Conservez chaque fichier brut `captions/clip-NN.srt`. Le monteur compare chaque segment de sous-titre à l’extrait, corrige mots, noms et chiffres, vérifie synchronisation et lisibilité, puis enregistre `captions/clip-NN.checked.srt`. Un segment dépassant la durée de l’extrait bloque le rendu. Reliez l’empreinte de chaque SRT à celle de son extrait. Si la coupe change, régénérez ou revérifiez les sous-titres sur le nouveau fichier.

## 5. Recadrer, exporter et accepter les cinq vidéos

Invoquez `/video-vertical`. Pour chaque extrait accepté, examinez l’image décodée, l’orientation, le rapport de pixel et le mouvement. Le monteur choisit pour chaque extrait ses propres entiers pairs `CROP_W`, `CROP_H`, `CROP_X`, `CROP_Y`. Le rectangle doit tenir dans l’image décodée. Un recadrage fixe ne suit pas un sujet mobile ; s’il perd du contenu essentiel, choisissez un cadrage vérifié par mise à l’échelle et ajout de marges ou modifiez la coupe. Une rotation ou des coordonnées incertaines bloquent le rendu. Le [manuel des filtres FFmpeg](https://ffmpeg.org/ffmpeg-filters.html) décrit le recadrage, la mise à l’échelle, les marges et le filtre de sous-titres utilisant libass.

Depuis le dossier de travail établi, définissez `CLIP` avec le vrai numéro à deux chiffres et les quatre variables de recadrage avec les entiers approuvés pour cet extrait. La commande est un modèle, pas un exemple testé. Conservez le chemin relatif simple des sous-titres indiqué ici ; les caractères spéciaux des noms nécessitent un échappement propre au graphe de filtres. Répétez séparément pour 02 à 05.

```shell
set -e
setopt noclobber
CLIP=01
CROP_W=<CHECKED_EVEN_INTEGER>
CROP_H=<CHECKED_EVEN_INTEGER>
CROP_X=<CHECKED_EVEN_INTEGER>
CROP_Y=<CHECKED_EVEN_INTEGER>
test ! -e "shorts/short-${CLIP}.mp4"
test ! -e "probes/short-${CLIP}.json"
ffmpeg -i "clips/clip-${CLIP}.mp4" -map 0:v:0 -map 0:a:0 -vf "crop=${CROP_W}:${CROP_H}:${CROP_X}:${CROP_Y},scale=1080:1920:force_original_aspect_ratio=decrease:force_divisible_by=2:reset_sar=1,pad=1080:1920:(ow-iw)/2:(oh-ih)/2,subtitles=captions/clip-${CLIP}.checked.srt" -c:v libx264 -pix_fmt yuv420p -c:a aac -n "shorts/short-${CLIP}.mp4"
test -s "shorts/short-${CLIP}.mp4"
ffprobe -v error -show_entries format=duration:stream=index,codec_type,codec_name,width,height,sample_aspect_ratio -of json "shorts/short-${CLIP}.mp4" > "probes/short-${CLIP}.json"
test -s "probes/short-${CLIP}.json"
```

Pour chacun des cinq fichiers JSON d’analyse, exigez un flux vidéo 1080 × 1920 au rapport de pixel 1:1, un flux audio et une durée positive compatible avec la coupe approuvée, après arrondi d’encodage ou d’image. Une valeur absente ou inconnue reste à résoudre. [La sortie JSON de ffprobe](https://ffmpeg.org/ffprobe.html) vérifie les propriétés du fichier, pas la qualité du montage. Rouvrez et regardez chaque MP4 en entier, en le comparant à l’intervalle source, à la coupe acceptée et au SRT vérifié. Examinez les limites des phrases, les sous-titres et leur placement sûr, le cadrage pendant les mouvements, la synchronisation audio, les faits et les droits. Consignez acceptation, révision ou rejet avec l’heure UTC dans le manifeste. Cinq fichiers acceptés, chacun relié à son empreinte source, intervalle approuvé, empreinte d’extrait, empreinte SRT vérifiée et analyse JSON, terminent la tâche. Quatre ne suffisent pas.

## Limites et récupération

L’accès à Claude Code peut dépendre d’un abonnement ou de frais API et de limites d’utilisation. Un modèle local téléchargé, la transcription, le réencodage et les révisions consomment stockage et calcul. Consignez les frais réels si le compte les expose ; un coût inconnu n’est pas nul. Aucun résultat de vitesse, précision, qualité des sous-titres, économie ou popularité n’a été mesuré pour cette recette.

Conservez l’original et les éléments acceptés. En cas de modèle manquant, option incompatible, mauvaise transcription, rendu raté ou écriture incertaine, vérifiez les empreintes exactes et le fichier existant avant toute modification. Réparez la cause précise, donnez un nouveau chemin à la révision, puis recommencez l’analyse et le visionnage intégral. Ne téléversez ni ne partagez une vidéo terminée avant que le monteur ait accepté son contenu et ses droits.

## Sources

- [Compétences Claude Code](https://code.claude.com/docs/en/skills) — Anthropic documente les fichiers de projet SKILL.md, l’invocation manuelle et le fait que allowed-tools autorise temporairement les outils sans confirmation. Cela ne démontre aucun résultat de montage vidéo.
- [Autorisations Claude Code](https://code.claude.com/docs/en/permissions) — Anthropic documente un système d’autorisation distinct. Le texte des compétences n’impose aucune frontière d’accès aux médias ou d’envoi ; les utilisateurs doivent vérifier les réglages du compte et du projet, y compris les lectures pouvant se produire sans confirmation.
- [README de whisper.cpp](https://github.com/ggml-org/whisper.cpp/blob/master/README.md) — Les instructions des mainteneurs sur la compilation et les modèles et l’exemple whisper-cli actuel décrivent le prérequis WAV 16 bits et sa conversion FFmpeg. Vérifiez séparément la compilation installée et le modèle.
- [README CLI de whisper.cpp](https://github.com/ggml-org/whisper.cpp/blob/master/examples/cli/README.md) — Le CLI des mainteneurs répertorie -m, -f, -l, -osrt, -oj, -of et -tr. Le guide définit une langue vérifiée et laisse la traduction désactivée ; la transcription locale ne garantit ni les mots ni les repères temporels.
- [Documentation en ligne de commande FFmpeg](https://ffmpeg.org/ffmpeg.html) — Référence pour la recherche dans l’entrée, -t, -map explicite, le réencodage et -n. Les bornes et sorties réelles doivent être inspectées ; la copie directe de flux n’est pas la méthode prescrite.
- [Documentation des filtres FFmpeg](https://ffmpeg.org/ffmpeg-filters.html) — Référence pour crop, scale, pad et subtitles. Ce dernier nécessite libass et ses bibliothèques ; vérifiez que la compilation installée expose les options scale requises.
- [Documentation ffprobe](https://ffmpeg.org/ffprobe.html) — Référence sur les sorties de flux et de format lisibles par machine. Une analyse ne détermine ni contexte de coupe, lisibilité des sous-titres, synchronisation, exactitude factuelle ni droits.
- [Retrouver le passage prononcé avant de monter une vidéo](https://bigchange.ai/blog/find-spoken-moment-before-video-editing) — Cet article BIG CHANGE connexe localise les passages transcrits horodatés. Le présent guide poursuit jusqu’à cinq coupes approuvées, aux sous-titres locaux, au rendu vertical et à l’examen complet : une tâche distincte, pas une suite datée.
