Skip to content
Back to search

HearYourVOICE

The complete, repeatable workflow for short Thai documentary/explainer videos — from a topic to a finished MP4, in whatever format you ship.

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/killernay--hearyourvoice/badge.svg)](/listings/killernay--hearyourvoice)

HTML

<a href="/listings/killernay--hearyourvoice"><img src="/api/listings/killernay--hearyourvoice/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

One plugin covers both: the skill works in chat, and the whole team wakes up in Cowork.

1. **[Download the plugin zip](https://github.com/killernay/HearYourVOICE/releases/latest)** from the latest release. 2. **Claude → Customize → Plugins → upload** that zip. 3. **Use it** — just ask. In Cowork, hand it a backlog: > *"/hearyourvoice ทำ 3 เรื่องนี้พร้อมกัน: ค่าไฟแพง, ฝุ่น PM2.5, หนี้ครัวเรือนไทย — เอาแค่ research + เขียนบท + ดีเบต hook"*

`hyv-producer` picks it up and fans the specialists across all three.

> **Uploading to *Skills* instead of *Plugins*?** That channel takes a different shape and carries no agents, so the release doesn't ship it — build it yourself with `node bin/build-bundles.mjs`, which also emits `hearyourvoice-skill-<v>.zip`. You get the method, not the team. Install **one or the other**, not both, or you'll end up with `hearyourvoice` and `hearyourvoice:hearyourvoice` side by side and won't know which one is answering. > > **Changing the skill yourself?** `node bin/build-bundles.mjs` packs your working tree into both zips on your Desktop — that's the path for edits the release doesn't have yet.

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.

README.md · README · 675 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <a id="english"></a>
  2. # 🎙️ HearYourVOICE
  3. **English** · [ภาษาไทย ↓](#thai)
  4. **The complete, repeatable workflow for short Thai documentary/explainer videos — from a topic to a finished MP4, in whatever format you ship.**
  5. HearYourVOICE is an **agent skill + a 16-strong subagent team** — a `SKILL.md`, its `references/` and `scripts/`, and the `hyv-*` specialists that do the work. Drop a topic in, and it walks the whole loop: research → script → an adversarial *agent debate* over the hook/punchline → ElevenLabs voiceover → gather visuals (self-shot, found Creative-Commons, or generative) → lay timecoded inserts on an editor timeline → validate → **package one clean `delivery/<slug>/` folder**.
  6. ## The point: the harness, not the model
  7. Stop asking *"which LLM is smarter."* It's the wrong question.
  8. **You** are the one in command. You define the format, the process, the standard — and the model follows it. An LLM is just a brain you can swap out: Claude today, something else tomorrow. What stays is the **harness** — the skill, the scripts, the guardrails that reliably *do the work you guide them to do.*
  9. A good AI agent isn't the one that wins a chat-window argument about which model is best. It's the one with a harness complete enough to pick up a real task and finish it. If your AI ability ends at chatting and ranking models, you're about two years behind where this is already going.
  10. HearYourVOICE is that harness for video. `SKILL.md` is production know-how made executable — and any brain in the world can run it.
  11. ## The team — run it solo, or delegate the whole thing
  12. Run the phases yourself, or hand them to the team that ships with the skill. `hyv-producer` is the director: it delegates to the specialists, holds the gates, and is the only one that talks to you about them.
  13. ```
  14. hyv-producer ← the director: delegates, holds gates, never decides taste
  15. ├─ hyv-researcher phase 0 · real WebSearch, every claim ≥2 sources
  16. ├─ hyv-scriptwriter phase 1 · script + TTS-ready narration
  17. ├─ hyv-script-reviewer phase 1 · strict pass/fail against the brief
  18. ├─ hyv-storyboard phase 1 · shot-by-shot, at the config's aspect
  19. ├─ debate panel phase 1 · hook-maximalist vs skeptic-editor vs target-viewer
  20. │ └─ hyv-judge synthesizes · RECOMMENDS, never rules
  21. ├─ hyv-shotlister phase 1 · the 5-sheet shotlist.xlsx backbone
  22. ├─ hyv-voiceover phase 2 · ElevenLabs + ffprobe = the master clock
  23. │
  24. │ ⟨ phase 3 · filming your own shots — no agent here. That part is you. ⟩
  25. │
  26. ├─ hyv-cc-scout phase 4 · finds CC footage, verifies the license itself
  27. ├─ hyv-veo-prompt-smith phase 4 · prompts for the gaps · spends nothing
  28. ├─ hyv-veo-runner phase 4 · renders generative clips · costs money
  29. └─ hyv-assembler phase 5–6 · timeline → editor → delivery/
  30. ```
  31. *(Phase 3 has no agent on purpose — an AI can't hold your camera. Shoot, cut exact-timestamp selects, drop them in the pool, and `hyv-assembler` picks them up like any other clip.)*
  32. **Two rules the team never breaks.** Creative authority is human: `hyv-judge` recommends and flags a split, but *you* pick the hook and punchline. And every gate stops for you — output spec, topic lock, split debate, and any spend (voiceover or generative credits).
  33. Fan them out to scale: one `hyv-researcher` per topic in parallel, then one `hyv-producer` per video — each in its own `src/<slug>/`, no collisions. Full roster + decision chain: [`references/subagents.md`](skills/hearyourvoice/references/subagents.md).
  34. ## Nothing is hardcoded
  35. Aspect, resolution, fps, and editor live in `src/<slug>/project.config.json` — confirmed with you before anything is produced. **9:16 is the default, not a law**: 16:9, 1:1, 4:5, and custom work the same way, and every script takes `--aspect/--width/--height/--fps`.
  36. **Your editor is a config value too.** Phase 5 exports one universal timeline — `ep*-timeline.json` (frames + SMPTE timecode) and `ep*-timeline.csv` (one row per clip) — and `hyv-assembler` reads `editor` to take the right path:
  37. | `editor` | What happens |
  38. |---|---|
  39. | `capcut` · `premiere` · `davinci` | You get the CSV/JSON and drop each clip at its `start_tc` in the NLE you already know. Nothing to install. |
  40. | `remotion` | **The code path.** `new-project.mjs --remotion` scaffolds a starter composition and config; the timeline JSON drives it directly, and `remotion-best-practices` loads for the render. Pick this when you want the cut to be reproducible from source, or when you're generating many videos from one template. |
  41. The recipe is identical wherever you take it: voiceover on one audio track (the master clock), every clip **muted** at its start timecode, at the config's aspect and fps. Full recipe: [`references/assembly-and-validation.md`](skills/hearyourvoice/references/assembly-and-validation.md).
  42. ## The loop — seven phases
  43. ```
  44. 0 Research → 1 Script + punchline debate → ══ you lock the hook ══
  45. │
  46. ┌───────────┴───────────┐ CC + graphics never touch the
  47. ▼ ▼ audio — start them together
  48. 2 Voiceover 3 Mock shots (optional)
  49. master clock 4 Footage: find CC · graphics
  50. │ │
  51. └───────────┬───────────┘
  52. ▼
  53. 4' Generative shots (optional) — waits: the prompt
  54. has to state its exact seconds
  55. │
  56. ▼ join: measured clock + clip pool
  57. 5 Inserts onto TC → 6 Validate + package
  58. → delivery/<slug>/ (manifest.json: status ready)
  59. └─→ back to 0 for the next topic
  60. ```
  61. Each phase has one job, one owner, and one artifact it must hand the next. That contract is the whole trick — it's what lets you stop anywhere, hand off, or fan out without the thing falling apart.
  62. **The numbers are a data order, not a queue.** Finding CC footage and building graphics never need the audio, so they start *with* the voiceover, not after it — one is a slow API call, the other slow web search, and doing them back to back just pays for both. Two things genuinely wait: generative shots (a Veo prompt must say "exactly N seconds", and N comes from the measured audio) and phase 5 (the timeline joins the clock to the clips). Across topics nothing is shared at all: three topics means three producers at once, not three in a row.
  63. | Phase | What happens | Hands over | Runs in |
  64. |---|---|---|---|
  65. | **0 · Research** | Pick one topic and build a factual brief: thesis, the one surprising insight, key facts with sources — every claim verified against **≥2 independent sources**. Locks the **subject** so later prompts and visuals never drift onto a look-alike. | `research.md` + a slug | any tier |
  66. | **1 · Script + punchline debate** | Draft the script, then the part that gives this skill its name: **agents argue over the hook and punchline.** Hook Maximalist pushes for stopping power, Skeptic/Editor attacks clickbait the body can't pay off, Target Viewer asks "do I care?". `hyv-judge` synthesizes and flags a split — **it recommends, it never rules. You pick.** Then rewrite into TTS-ready narration. | `voiceover-v1.md` (locked hook) | any tier |
  67. | **1e · Shotlist** | The planning backbone: one row per unique shot, how to capture or source it, the licence, which episodes reuse it, and a live `status` column. Build it here and phases 3–5 get easy. | `shotlist.xlsx` | **Production** — needs Python |
  68. | **2 · Voiceover** | Generate the narration, then **measure it with `ffprobe`**. This is the master clock. | `ep*.mp3` + `voiceover-durations.json` | **Production** |
  69. | **3 · Mock shots** *(optional)* | Film the bespoke shots yourself. Review and cut **exact-timestamp selects** only — loose clips are rejected. Many projects skip this. | silent selects | **Production** |
  70. | **4 · Footage** | Fill every beat from whatever fits: found **Creative-Commons** (licence verified by hand — YouTube's CC filter lies), generative clips, your own selects, or motion graphics. Graphics are the always-available fallback. | a reviewed clip pool + `ATTRIBUTION.md` | **Production** |
  71. | **5 · Inserts onto TC** | Lay each clip on the measured clock — contiguous timecodes, final end == target length — and export an **editor-neutral timeline** (JSON + CSV) you assemble in CapCut, Premiere, DaVinci, or code. | `ep*-timeline.json` + `.csv` | **Production** |
  72. | **6 · Validate + package** | `ffprobe` confirms resolution, fps, duration and that audio matches video; you eyeball a few frames; then everything scattered across `src/`, `public/` and `out/` is gathered into one folder. | `delivery/<slug>/` · `status: ready` | **Production** |
  73. **Three invariants hold across every phase:**
  74. 1. **The voiceover is the master clock.** Every timecode comes from *measured* audio, never from the script's guessed length. A guessed number silently breaks everything downstream and you don't find out until the render is wrong.
  75. 2. **All visual clips are silent.** Narration is the only audio track. Ambience, if any, is one continuous bed underneath.
  76. 3. **The output spec is read, never assumed** — from `project.config.json`, confirmed with you first.
  77. **Where the tiers cut:** phases 0–1 are pure reasoning, so Basic and Advance do them fine. From the shotlist onward every phase shells out to a real binary or ends in your editor — that's Production. Note **1e is a phase-1 step that still needs Claude Code**: the line is drawn by tool dependency, not by phase number.
  78. **Money only moves in two places** — phase 2 (voiceover) and phase 4 (generative). Both scripts refuse to spend without `--yes`, and both have a free twin (`--emit-md`) that hands you the prompts to generate anywhere you like.
  79. ## What you get out (the output format)
  80. One folder, not scattered files:
  81. ```
  82. delivery/<slug>/
  83. manifest.json ← canonical index (per-episode checks + status)
  84. README.md ← human summary
  85. video/ ← final renders
  86. voiceover/ ← narration mp3s
  87. script/ ← voiceover-v1.md + shotlist.xlsx
  88. briefs/ ← per-episode insert plans
  89. attribution/ ← credits & licenses
  90. thumbnails/
  91. ```
  92. "Done" = `manifest.json` reports `status: "ready"`.
  93. ## What's inside
  94. ```
  95. skills/hearyourvoice/
  96. SKILL.md the orchestrator (phases 0–6)
  97. references/ pipeline-loop · research-brief · script+VO spec ·
  98. punchline-debate · subagents · shotlist-format ·
  99. footage-sources · veo-prompt-guide ·
  100. assembly+validation · output-format · naming · examples/
  101. scripts/ new-project · new-shotlist · gen-voiceover ·
  102. measure-voiceover · gen-veo-briefs · veo-generate ·
  103. check-insert-plan · export-timeline · package-delivery
  104. agents/ the 16 hyv-* subagents
  105. ```
  106. Editor-agnostic: it exports a universal timeline (JSON + CSV) you assemble in **CapCut, Premiere, DaVinci Resolve, or a code renderer** — then packages a clean delivery folder. It can optionally orchestrate `veo-insert-planner` (generative footage) and `remotion-best-practices` (only if you assemble in code).
  107. ## Three ways to run this
  108. This loop has two halves, and they have very different needs:
  109. - **The thinking half** — research, script, the punchline debate, storyboard, shotlist planning. Pure reasoning. No binaries, no keys, no money.
  110. - **The machine half** — measuring the voiceover with `ffprobe`, pulling footage with `yt-dlp`, building the workbook with Python, and cutting in **your** CapCut/Premiere/DaVinci. This needs a real shell on a real machine with your files on it.
  111. Which half you get depends on where you run it. Pick your tier:
  112. | | **Basic** | **Advance** | **Production** |
  113. |---|---|---|---|
  114. | **Where** | Chat — web or the app's Chat tab | **Cowork** | **Claude Code** — CLI or the app's Code tab |
  115. | **Install** | the plugin | the plugin | `npx hearyourvoice install` |
  116. | **The team** | ❌ agents are greyed out in chat | ✅ **all 16 fan out in parallel** | ✅ all 16 |
  117. | **Thinking half** | ✅ | ✅ | ✅ |
  118. | **Machine half** | ❌ no shell | ❌ — see below | ✅ |
  119. | **Good for** | one topic, thinking it through | **researching and scripting a whole backlog at once** | finishing an actual video |
  120. **Basic** gives you one Claude with the whole method loaded — plenty for taking one idea from topic to a debated hook.
  121. **Advance** is where it gets interesting: hand Cowork three topics and `hyv-producer` fans the specialists out across all of them at once — researchers verifying sources in parallel, the debate panel arguing each hook, `hyv-judge` flagging where it's split. No terminal required. *(Verified by running it: the team spawns and works in parallel in Cowork.)*
  122. **Production** is the only tier that finishes a video, because only your own machine has your ffmpeg, your footage, and your editor.
  123. They compose. Think and debate in Cowork across a backlog, then bring the winners into Claude Code to produce.
  124. ### Why Cowork can't do the machine half
  125. Cowork's shell "execute[s] inside a dedicated Linux VM, isolated from the host operating system by the platform's hypervisor" — so even in local mode it cannot reach the ffmpeg installed on *your* Mac, and Anthropic doesn't document what's preinstalled in that VM. Either way, the final cut happens in your editor, on your machine.
  126. That's not a wall — it's the seam. Cowork does the thinking half well; Claude Code does the rest.
  127. <details>
  128. <summary>What we tested, and what's still unverified</summary>
  129. **Observed:** the plugin installs in Cowork, `hyv-producer` is invoked by name, and the specialists fan out in parallel across multiple topics.
  130. **Not tested:** whether Cowork's VM has `node`/`ffmpeg`/`python` at all, and how the paid steps behave there. The spending gates are enforced in the scripts themselves (they refuse without `--yes`), but that behaviour hasn't been watched on Cowork's VM — so treat phase 2+ as Claude Code's job until someone checks.
  131. Earlier versions of this README claimed Cowork couldn't run any of this. That was wrong, and it was written from docs rather than from running it.
  132. </details>
  133. <details>
  134. <summary>The old table, if you're mapping surfaces</summary>
  135. | Where | Thinking half | Machine half |
  136. |---|---|---|
  137. | **Claude Code CLI** (`claude` in a terminal) | ✅ | ✅ |
  138. | **Claude app → Code tab → Environment: Local** | ✅ | ✅ — same `~/.claude/`, all 16 agents |
  139. | Claude app → Code tab → Environment: **Remote/cloud** | ✅ | ❌ — cloud sessions are sandboxed |
  140. | **Cowork** (plugin) | ✅ + the team, in parallel | ❌ — isolated VM |
  141. | Claude app → **Chat** tab · **claude.ai** web (plugin) | ✅ — no team | ❌ — no shell |
  142. Two things from the docs explain the shape of that table:
  143. 1. **Why the team only lives in Cowork:** plugins "bundle skills, connectors, and sub-agents", and "the skills bundled in a plugin work across all three. **Hooks and sub-agents run only in Cowork**, so they appear greyed out in chat." That's why Basic gets the method but not the roster.
  144. 2. **Why the Code tab is Claude Code:** "the desktop app reads the same settings files as the CLI", so one `npx hearyourvoice install` serves both.
  145. </details>
  146. **Rule of thumb:** think in Cowork, finish in Claude Code. If Claude can't reach your ffmpeg and your editor, it cannot finish a video — no matter how good the skill is.
  147. ## Install — Basic & Advance (the plugin, no terminal at all)
  148. One plugin covers both: the skill works in chat, and the whole team wakes up in Cowork.
  149. 1. **[Download the plugin zip](https://github.com/killernay/HearYourVOICE/releases/latest)** from the latest release.
  150. 2. **Claude → Customize → Plugins → upload** that zip.
  151. 3. **Use it** — just ask. In Cowork, hand it a backlog:
  152. > *"/hearyourvoice ทำ 3 เรื่องนี้พร้อมกัน: ค่าไฟแพง, ฝุ่น PM2.5, หนี้ครัวเรือนไทย — เอาแค่ research + เขียนบท + ดีเบต hook"*
  153. `hyv-producer` picks it up and fans the specialists across all three.
  154. > **Uploading to *Skills* instead of *Plugins*?** That channel takes a different shape and carries no agents, so the release doesn't ship it — build it yourself with `node bin/build-bundles.mjs`, which also emits `hearyourvoice-skill-<v>.zip`. You get the method, not the team. Install **one or the other**, not both, or you'll end up with `hearyourvoice` and `hearyourvoice:hearyourvoice` side by side and won't know which one is answering.
  155. >
  156. > **Changing the skill yourself?** `node bin/build-bundles.mjs` packs your working tree into both zips on your Desktop — that's the path for edits the release doesn't have yet.
  157. ## Install — Production (Claude Code)
  158. You never have to open a separate terminal — the app has one built in.
  159. 1. **Download the app** — [macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect) or [Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect), then sign in. *(Windows also needs [Git for Windows](https://git-scm.com/downloads/win); restart the app after installing it.)* Or just use the `claude` CLI.
  160. 2. **Click the `Code` tab** (not Chat, not Cowork).
  161. 3. **Set Environment to `Local`** — this is the step people get wrong. Remote runs in the cloud and can't touch your files.
  162. 4. **Pick your project folder** — the folder where your videos will live.
  163. 5. **Open the built-in terminal** — `Ctrl` + `` ` `` — and paste one line:
  164. ```bash
  165. npx hearyourvoice install
  166. ```
  167. 6. **Check what's missing** — `npx hearyourvoice doctor` reports Node / Python / ffmpeg and which API keys are set (never their values).
  168. 7. **Use it** — type `/hearyourvoice` and describe the video. It delegates to the team on its own; you don't have to name `hyv-producer`.
  169. That's it — the CLI and the app share the same install, so doing this once covers both.
  170. ### Where to install it: global or project
  171. Both are Claude Code installs — this is only about *scope*.
  172. **Global — whole machine** (available in every session):
  173. ```bash
  174. npx hearyourvoice install # skill → ~/.claude/skills/ · agents → ~/.claude/agents/
  175. npx hearyourvoice install codex # → ~/.codex/skills/hearyourvoice (skill only)
  176. npx hearyourvoice install hermes # → ~/.hermes/skills/hearyourvoice (skill only)
  177. ```
  178. **Project-level — only the repo you're working in** (run from its root):
  179. ```bash
  180. cd ~/path/to/your-video-repo
  181. npx hearyourvoice install project # → ./.claude/skills/ + ./.claude/agents/
  182. ```
  183. The installer only ever touches its own `hyv-*.md` files — your other agents are left alone. Codex and Hermes get the skill only, since `.claude/agents/` is a Claude Code construct.
  184. ### Global or project — which should you pick?
  185. | | **Global** (`install`) | **Project** (`install project`) |
  186. |---|---|---|
  187. | Lives in | `~/.claude/skills/` + `~/.claude/agents/` | `./.claude/` inside the repo |
  188. | Works in | every session on the machine | only that repo |
  189. | Goes into git | no | yes, if you commit `.claude/` |
  190. | Version | one, for everything | pinned per repo |
  191. | Best for | your own machine, many videos, one version | a team sharing one repo, or running versions side by side |
  192. **Default to global.** It's one command, it's there in every session, and updating it updates everything: `npx hearyourvoice install`.
  193. **Choose project when** your teammates should get the exact same version by cloning the repo (commit `.claude/` and they have it — no install step), or when different repos need different versions.
  194. ### The one gotcha: skills and agents resolve in *opposite* directions
  195. Claude Code doesn't treat these two the same, and it will surprise you:
  196. - **Skills** — a **global skill wins over a project skill** of the same name. ("Enterprise overrides personal, and personal overrides project.")
  197. - **Agents** — a **project agent wins** a name clash, but global agents still load in *every* project — they add on top rather than being replaced.
  198. Two practical consequences:
  199. 1. **A global install silently defeats a project install.** If HearYourVOICE is installed globally, a project copy of the skill is ignored — *even if the project's is newer*. Installing per-repo versions only works when there is **no global copy**.
  200. 2. **Global agents follow you everywhere.** Install the team globally and `hyv-*` shows up in every project, including ones where you wanted the skill alone.
  201. So: **pick one scope and stay in it.** If you need per-repo versions (or want to demo two versions side by side), keep the global install off entirely and use `install project` in each.
  202. Check your toolchain anytime: `npx hearyourvoice doctor` (Node / Python / ffmpeg).
  203. > From a local checkout it's the same, via `npx .`:
  204. > `cd HearYourVOICE && npx . install project` • or use the bash fallback `./install.sh <target>`.
  205. Then start a session and say *"produce a video about &lt;topic&gt; with HearYourVOICE"*, or hand it straight to the team: *"ให้ hyv-producer ผลิตวิดีโอเรื่อง &lt;topic&gt;"*. See **INSTALL.md** for details, dependencies, and the full **Environment & API keys** list.
  206. ## Requirements
  207. - **Node 18+** (the `.mjs` tools), **Python 3** + `openpyxl` (shotlist), **ffmpeg/ffprobe** (timing & render checks).
  208. - The subagent team needs **Claude Code v2.1.172+** (nested subagents). The skill itself runs anywhere.
  209. - For the final cut: **a video editor of your choice** (CapCut, Premiere, DaVinci, or a code renderer), an **ElevenLabs** API key (voiceover), and — only if you use generative footage — your own **Veo** provider plugin.
  210. ## 💸 Cost & ethics — read before phase 4
  211. ### You can ship a whole video for ฿0
  212. This is worth saying plainly, because the expensive path is the one people assume they need:
  213. | Phase | The paid way | The free way that also works |
  214. |---|---|---|
  215. | **2 · Voiceover** | ElevenLabs API | `gen-voiceover.mjs --emit-md` → voice it in ElevenLabs' own UI, another TTS, a local model, or read it yourself |
  216. | **4 · Footage** | generative clips | **real Creative-Commons photos** — `fetch-cc-images.mjs` pulls them from Openverse + Wikimedia, licence-checked, with your line over the top. Graphics are the fallback under that |
  217. ```bash
  218. node scripts/fetch-cc-images.mjs --slug pm25-dust --query "air pollution bangkok" --limit 5
  219. ```
  220. A video built from **licensed photos with type over them** is a complete, legitimate output — not a downgrade. Explainers have been made that way for decades, and it's often *clearer* than stock footage that only vaguely matches what you're saying. The code renderer gives each still a slow push so it reads as video rather than a slideshow, and `hyv-assembler` treats it like any other clip.
  221. **The licence is read, never filtered for.** Google Images' "CC" filter has the same false positives as YouTube's — it filters the open web, it doesn't read a licence. Every image's licence comes from its source's metadata; ND is rejected outright (cutting it into a video *is* a derivative), NC unless you opt in, and creator + licence + URL land in `ATTRIBUTION.md` as each file downloads.
  222. **Generative is one optional source, not the default.** Most videos never need it.
  223. ### If you do reach for it
  224. **Generative footage (Google Veo) is expensive.** At roughly **$0.75 per second (≈ ฿30/sec)**, a single 6-second insert is about **$4.5 (≈ ฿180)**, and a 90-second episode made *entirely* of Veo clips runs about **$67 (≈ ฿2,700)**. *(Pricing changes over time — check the current rate before you commit.)*
  225. Don't reach for it unless a shot is impossible to film, find, or draw. And you can't spend by accident: both paid scripts **refuse to run without `--yes`** — they print exactly what would be billed and exit. `hyv-veo-runner` shows the estimate and waits for your approval before spending a baht.
  226. **Where this skill earns its keep:** if your goal is producing content *at scale* — say a hundred pieces a day — a repeatable harness is exactly what makes that volume possible without quality collapsing. That's who this is built for.
  227. **Don't steal anyone's footage.** For found footage, search **Creative Commons (CC / NC) only** — verify the license yourself (YouTube's "CC" filter gives false positives), record credit + source URL in `ATTRIBUTION.md`, and discard anything you can't clear. `hyv-cc-scout` does exactly this and drops whatever it can't clear. Ripping someone's work is not a footage strategy.
  228. ## License
  229. MIT — see `LICENSE`.
  230. ## Origin — in memory of VOICE TV
  231. The name **HearYourVOICE** is a tribute to **VOICE TV** — a station that "planted ideas" (*ปลูกความคิด*) in Thai society for 15 years (2009–2024).
  232. I, **Chanon Ngernthongdee**, started there in my very first role: *Head of Research and Development*, from the day the station was founded. This project is an attempt to take the *know-how* we used in the VOICE TV newsroom and production floor and turn it into a `SKILL.md` — so the way we made quality content becomes something *repeatable* in the age of AI.
  233. Yesterday I spoke with **Khun Songsak Premsuk**, the station's co-founder and managing director. He told me, *"If we'd had AI back then, the world of TV could have gone so much further."* It's true that VOICE TV no longer broadcasts today — but its way of thinking and working doesn't have to end with it, because `SKILL.md` can be carried on by **any brain in the world**, human or AI.
  234. I hope the structure of this project helps anyone pick it up and bring quality content and quality issues into Thai society.
  235. > *Hear your voice — because every good idea deserves a place to be heard.*
  236. ---
  237. <a id="thai"></a>
  238. # 🎙️ HearYourVOICE — ภาษาไทย
  239. [English ↑](#english) · **ภาษาไทย**
  240. **เวิร์กโฟลว์ครบวงจรและทำซ้ำได้ สำหรับคลิปสารคดี/อธิบายความภาษาไทยสั้น ๆ — จากแค่ "หัวข้อ" ไปจนเป็นไฟล์ MP4 ที่เสร็จสมบูรณ์ ในสัดส่วนไหนก็ได้ที่คุณจะปล่อย**
  241. HearYourVOICE คือ **agent skill + ทีม subagent 16 ตัว** — ประกอบด้วย `SKILL.md` พร้อม `references/`, `scripts/` และทีม `hyv-*` ที่ลงมือทำจริง แค่โยนหัวข้อเข้าไป มันจะเดินครบทั้งลูป: research → เขียนสคริปต์ → ให้ *agent ดีเบต* แย้งกันเรื่อง hook/punchline → ทำเสียงพากย์ด้วย ElevenLabs → หาภาพ (ถ่ายเอง, Creative-Commons, หรือ generative) → วาง insert ตาม timecode บน timeline ของ editor → ตรวจสอบ → **แพ็กเป็นโฟลเดอร์ `delivery/<slug>/` ที่สะอาดหนึ่งชุด**
  242. ## หัวใจ: harness ไม่ใช่ตัวโมเดล
  243. เลิกถามว่า *"LLM ตัวไหนเก่งกว่ากัน"* — มันคือคำถามที่ผิด
  244. **คุณ** ต่างหากที่เป็นคนสั่ง คุณคือคนกำหนด format กำหนดกระบวนการ กำหนดมาตรฐาน แล้วโมเดลทำตาม LLM เป็นแค่ "มันสมอง" ที่สลับเปลี่ยนได้ — วันนี้ Claude พรุ่งนี้อาจเป็นตัวอื่น สิ่งที่อยู่คงทนคือ **harness** — ตัว skill, สคริปต์, และ guardrail ที่ *หยิบงานไปทำตามที่เรา guide ได้จริงอย่างเชื่อถือได้*
  245. AI agent ที่ดี ไม่ใช่ตัวที่ชนะการเถียงในหน้าแชตว่าโมเดลไหนเก่งกว่า แต่คือตัวที่มี harness สมบูรณ์พอจะหยิบงานจริงไปทำจนจบ ถ้าความสามารถด้าน AI ของคุณจบอยู่แค่การแชตและจัดอันดับโมเดล คุณกำลังช้ากว่าโลก AI ไปแล้วประมาณสองปี
  246. HearYourVOICE คือ harness ตัวนั้นสำหรับงานวิดีโอ — `SKILL.md` คือ know-how การผลิตที่ถูกทำให้ "สั่งทำงานได้จริง" และมันสมองใด ๆ ในโลกก็รันมันต่อได้
  247. ## ทีมงาน — ทำเองก็ได้ หรือมอบให้ทีมทั้งสาย
  248. จะเดินทีละเฟสเองก็ได้ หรือโยนให้ทีมที่มากับสกิล `hyv-producer` คือผู้กำกับ — มอบงานให้ลูกทีม คุม gate และเป็นคนเดียวที่คุยกับคุณเรื่อง gate
  249. ```
  250. hyv-producer ← ผู้กำกับ: มอบงาน คุม gate ไม่ตัดสินรสนิยมเอง
  251. ├─ hyv-researcher เฟส 0 · ค้นจริง ทุกข้ออ้าง ≥2 แหล่ง
  252. ├─ hyv-scriptwriter เฟส 1 · บท + narration พร้อมลงเสียง
  253. ├─ hyv-script-reviewer เฟส 1 · ตรวจบท pass/fail เทียบ brief
  254. ├─ hyv-storyboard เฟส 1 · แตกช็อต ตาม aspect ใน config
  255. ├─ ทีมดีเบต เฟส 1 · hook-maximalist vs skeptic-editor vs target-viewer
  256. │ └─ hyv-judge สังเคราะห์ · แนะนำ ไม่ชี้ขาด
  257. ├─ hyv-shotlister เฟส 1 · shotlist.xlsx 5 sheet
  258. ├─ hyv-voiceover เฟส 2 · ElevenLabs + ffprobe = master clock
  259. │
  260. │ ⟨ เฟส 3 · ถ่ายเอง — ไม่มี agent ตรงนี้ ตรงนี้คือคุณ ⟩
  261. │
  262. ├─ hyv-cc-scout เฟส 4 · หาภาพ CC + ตรวจสัญญาอนุญาตเอง
  263. ├─ hyv-veo-prompt-smith เฟส 4 · ร่าง prompt เฉพาะช็อตที่ขาด · ไม่เสียเงิน
  264. ├─ hyv-veo-runner เฟส 4 · เรนเดอร์ generative · เสียเงิน
  265. └─ hyv-assembler เฟส 5–6 · timeline → editor → delivery/
  266. ```
  267. *(เฟส 3 ไม่มี agent โดยตั้งใจ — AI ถือกล้องแทนคุณไม่ได้ ถ่ายเอง ตัด select ตาม timestamp เป๊ะ ๆ โยนเข้าพูล แล้ว `hyv-assembler` จะหยิบไปใช้เหมือนคลิปอื่นทุกประการ)*
  268. **กฎ 2 ข้อที่ทีมไม่มีวันฝ่าฝืน:** อำนาจสร้างสรรค์เป็นของคน — `hyv-judge` แค่แนะนำและบอกว่า "เสียงแตก" แต่ **คุณ** เป็นคนเลือก hook/punchline และทุก gate ต้องหยุดถามคุณ — ยืนยัน output spec, ล็อกหัวข้อ, ดีเบตเสียงแตก, และทุกครั้งที่จะจ่ายเงิน (ค่าเสียง/generative)
  269. ยิงขนานเพื่อสเกล: `hyv-researcher` หนึ่งตัวต่อหนึ่งหัวข้อพร้อมกัน แล้ว `hyv-producer` หนึ่งตัวต่อหนึ่งคลิป — แต่ละตัวมี `src/<slug>/` ของตัวเอง ไม่ชนกัน ดูรายชื่อเต็ม + สายการตัดสินใจที่ [`references/subagents.md`](skills/hearyourvoice/references/subagents.md)
  270. ## ไม่มีอะไรถูก hardcode
  271. aspect, resolution, fps และ editor อยู่ใน `src/<slug>/project.config.json` — ยืนยันกับคุณก่อนเริ่มผลิตเสมอ **9:16 เป็นแค่ค่าเริ่มต้น ไม่ใช่กฎ**: 16:9, 1:1, 4:5 และ custom ใช้ได้เหมือนกันหมด และทุกสคริปต์รับ `--aspect/--width/--height/--fps`
  272. **โปรแกรมตัดต่อก็เป็นค่า config เหมือนกัน** เฟส 5 export timeline กลางออกมาชุดเดียว — `ep*-timeline.json` (เฟรม + SMPTE timecode) กับ `ep*-timeline.csv` (หนึ่งแถวต่อหนึ่งคลิป) — แล้ว `hyv-assembler` อ่านค่า `editor` เพื่อเลือกทาง:
  273. | `editor` | เกิดอะไรขึ้น |
  274. |---|---|
  275. | `capcut` · `premiere` · `davinci` | คุณได้ CSV/JSON ไปวางคลิปตาม `start_tc` ในโปรแกรมที่คุณใช้เป็นอยู่แล้ว ไม่ต้องลงอะไรเพิ่ม |
  276. | `remotion` | **ทางโค้ด** — `new-project.mjs --remotion` วางโครง composition + config ให้, timeline JSON สั่งงานมันได้ตรง ๆ และ `remotion-best-practices` จะถูกโหลดมาช่วยตอนเรนเดอร์ เลือกทางนี้เมื่ออยากให้ตัวตัดต่อ**สร้างซ้ำจากซอร์สได้** หรือตอนต้องปั๊มวิดีโอหลายตัวจากเทมเพลตเดียว |
  277. สูตรเหมือนกันหมดไม่ว่าเอาไปทำที่ไหน: เสียงพากย์อยู่แทร็กเสียงเดียว (คือ master clock), ทุกคลิป **ปิดเสียง** วางตาม start timecode, ที่ aspect/fps ตาม config ดูสูตรเต็มที่ [`references/assembly-and-validation.md`](skills/hearyourvoice/references/assembly-and-validation.md)
  278. ## ลูปการทำงาน — 7 เฟส
  279. ```
  280. 0 Research → 1 เขียนสคริปต์ + ดีเบต punchline → ══ คุณล็อก hook ══
  281. │
  282. ┌───────────┴───────────┐ CC + กราฟิก ไม่แตะเสียงเลย
  283. ▼ ▼ → เริ่มพร้อมกันได้
  284. 2 เสียงพากย์ 3 ถ่าย mock (ถ้าต้องการ)
  285. master clock 4 ภาพ: หา CC · กราฟิก
  286. │ │
  287. └───────────┬───────────┘
  288. ▼
  289. 4' ภาพ generative (ถ้าต้องการ) — ตัวนี้ต้องรอ
  290. เพราะ prompt ต้องระบุจำนวนวินาทีเป๊ะ ๆ
  291. │
  292. ▼ join: นาฬิกาที่วัดแล้ว + คลิปพูล
  293. 5 วาง insert ลง TC → 6 ตรวจ + แพ็ก
  294. → delivery/<slug>/ (manifest.json: status ready)
  295. └─→ วนกลับไป 0 เรื่องต่อไป
  296. ```
  297. แต่ละเฟสมีหน้าที่เดียว เจ้าของเดียว และมี "ของ" ที่ต้องส่งต่อชิ้นเดียว — **สัญญาการส่งต่อนี่แหละคือกลไกทั้งหมด** มันคือสิ่งที่ทำให้หยุดตรงไหนก็ได้ ส่งต่อให้ใครก็ได้ หรือแตกงานขนานได้ โดยงานไม่พัง
  298. **ตัวเลขคือลำดับของข้อมูล ไม่ใช่คิวเข้าแถว** — การหาภาพ CC และการทำกราฟิกไม่ต้องใช้เสียงเลย เพราะงั้นต้องเริ่ม**พร้อม**เสียงพากย์ ไม่ใช่รอให้เสียงเสร็จก่อน อันหนึ่งรอ API ช้า อีกอันรอค้นเว็บช้า ทำเรียงกันคือจ่ายค่าช้าสองต่อฟรี ๆ **มีสองอย่างที่รอจริง**: ภาพ generative (prompt ของ Veo ต้องบอกว่า "เอา N วินาทีเป๊ะ" ซึ่ง N มาจากเสียงที่วัดแล้ว) กับเฟส 5 (timeline ต้องเอานาฬิกามาต่อกับคลิปพูล) ส่วนข้ามหัวข้อยิ่งไม่มีอะไรใช้ร่วมกันเลย — 3 หัวข้อ = producer 3 ตัวพร้อมกัน ไม่ใช่ 3 ตัวเรียงคิว
  299. | เฟส | ทำอะไร | ส่งต่ออะไร | ทำได้ที่ |
  300. |---|---|---|---|
  301. | **0 · Research** | เลือกหนึ่งหัวข้อ แล้วทำ brief ข้อเท็จจริง: thesis, insight ที่คนไม่รู้มาก่อน, ข้อมูลสำคัญพร้อมแหล่ง — ทุกข้ออ้าง**ยืนยัน ≥2 แหล่งอิสระ** และ **ล็อก subject** ไว้ ไม่ให้ prompt/ภาพหลุดไปเป็นของคล้าย ๆ ทีหลัง | `research.md` + slug | ทุกชั้น |
  302. | **1 · เขียนบท + ดีเบต punchline** | ร่างบท แล้วถึงท่าไม้ตายที่เป็นที่มาของชื่อสกิล: **agent เถียงกันเรื่อง hook กับ punchline** — Hook Maximalist ดันให้สะดุดตาที่สุด, Skeptic/Editor ไล่บี้ว่า clickbait ที่เนื้อจ่ายคืนไม่ได้, Target Viewer ถามว่า "กูแคร์ไหม" แล้ว `hyv-judge` สรุปพร้อมบอกว่าเสียงแตกไหม — **มันแนะนำ ไม่ได้ชี้ขาด คุณเลือกเอง** จบด้วยการเขียนใหม่เป็น narration พร้อมลงเสียง | `voiceover-v1.md` (hook ที่ล็อกแล้ว) | ทุกชั้น |
  303. | **1e · Shotlist** | กระดูกสันหลังของการวางแผน: หนึ่งแถวต่อหนึ่งช็อต, จะถ่ายเองหรือหาจากไหน, สัญญาอนุญาต, ตอนไหนใช้ซ้ำบ้าง และคอลัมน์ `status` ที่อัปเดตตลอด ทำตรงนี้ให้ดี เฟส 3–5 จะง่ายหมด | `shotlist.xlsx` | **Production** — ต้องมี Python |
  304. | **2 · เสียงพากย์** | ทำเสียง แล้ว**วัดจริงด้วย `ffprobe`** นี่คือ master clock | `ep*.mp3` + `voiceover-durations.json` | **Production** |
  305. | **3 · ถ่าย mock** *(ถ้าต้องการ)* | ถ่ายช็อตเฉพาะเอง รีวิวแล้วตัดเป็น select **ตาม timestamp เป๊ะ ๆ** เท่านั้น คลิปลอย ๆ ไม่รับ หลายโปรเจกต์ข้ามเฟสนี้ไปเลย | select ที่เงียบแล้ว | **Production** |
  306. | **4 · หาภาพ** | เติมทุกบีตจากแหล่งที่เหมาะ: **Creative-Commons** (ตรวจสัญญาอนุญาตเอง — ตัวกรอง CC ของ YouTube โกหก), คลิป generative, select ที่ถ่ายเอง หรือ motion graphic กราฟิกคือทางออกที่มีเสมอ | คลิปพูลที่รีวิวแล้ว + `ATTRIBUTION.md` | **Production** |
  307. | **5 · วาง insert ลง TC** | วางทุกคลิปบนนาฬิกาที่วัดจริง — timecode ต่อเนื่องไม่มีรู, ตัวสุดท้ายจบพอดีความยาวเป้าหมาย — แล้ว export **timeline กลาง** (JSON + CSV) เอาไปประกอบใน CapCut/Premiere/DaVinci หรือโค้ดก็ได้ | `ep*-timeline.json` + `.csv` | **Production** |
  308. | **6 · ตรวจ + แพ็ก** | `ffprobe` ยืนยันความละเอียด/fps/ความยาว/เสียงตรงกับภาพ · คุณดูฟุตสองสามเฟรมด้วยตา · แล้วรวบของที่กระจายอยู่ใน `src/`, `public/`, `out/` มาไว้โฟลเดอร์เดียว | `delivery/<slug>/` · `status: ready` | **Production** |
  309. **กฎเหล็ก 3 ข้อ ที่ทุกเฟสห้ามฝ่าฝืน:**
  310. 1. **เสียงพากย์คือ master clock** — timecode ทุกตัวมาจากเสียงที่**วัดจริง** ไม่ใช่จากความยาวที่เดาจากบท ตัวเลขที่เดามาจะทำให้ทุกอย่างหลังจากนั้นเพี้ยนแบบเงียบ ๆ แล้วคุณจะรู้ตัวตอนเรนเดอร์ออกมาผิดแล้ว
  311. 2. **คลิปภาพเงียบทั้งหมด** — narration เป็นแทร็กเสียงเดียว ถ้าจะมีเสียงบรรยากาศ ก็เป็นเบดยาวต่อเนื่องอันเดียวอยู่ข้างใต้
  312. 3. **output spec ต้องอ่าน ห้ามเดา** — จาก `project.config.json` และยืนยันกับคุณก่อนเสมอ
  313. **เส้นแบ่งชั้นอยู่ตรงไหน:** เฟส 0–1 เป็นการคิดล้วน ๆ Basic กับ Advance ทำได้สบาย แต่ตั้งแต่ shotlist เป็นต้นไป ทุกเฟสต้องเรียก binary จริงหรือไปจบที่โปรแกรมตัดต่อ — นั่นคือ Production **สังเกตว่า 1e อยู่ในเฟส 1 แต่ต้องใช้ Claude Code** เพราะ**เส้นแบ่งขีดด้วย "ต้องใช้เครื่องมืออะไร" ไม่ใช่เลขเฟส**
  314. **เงินขยับแค่ 2 จุด** — เฟส 2 (เสียง) กับเฟส 4 (generative) ทั้งคู่สคริปต์**ปฏิเสธที่จะจ่ายถ้าไม่มี `--yes`** และทั้งคู่มีฝาแฝดฟรี (`--emit-md`) ที่ยื่น prompt ให้คุณเอาไป gen ที่ไหนก็ได้
  315. ## สิ่งที่ได้ออกมา (รูปแบบผลลัพธ์)
  316. หนึ่งโฟลเดอร์ ไม่ใช่ไฟล์กระจัดกระจาย:
  317. ```
  318. delivery/<slug>/
  319. manifest.json ← ดัชนีหลัก (เช็กรายตอน + สถานะ)
  320. README.md ← สรุปสำหรับคนอ่าน
  321. video/ ← ไฟล์เรนเดอร์สุดท้าย
  322. voiceover/ ← ไฟล์เสียงพากย์ mp3
  323. script/ ← voiceover-v1.md + shotlist.xlsx
  324. briefs/ ← แผน insert รายตอน
  325. attribution/ ← เครดิตและสัญญาอนุญาต
  326. thumbnails/
  327. ```
  328. "เสร็จ" = `manifest.json` รายงาน `status: "ready"`
  329. ## ข้างในมีอะไร
  330. ```
  331. skills/hearyourvoice/
  332. SKILL.md ตัว orchestrator (phase 0–6)
  333. references/ pipeline-loop · research-brief · script+VO spec ·
  334. punchline-debate · subagents · shotlist-format ·
  335. footage-sources · veo-prompt-guide ·
  336. assembly+validation · output-format · naming · examples/
  337. scripts/ new-project · new-shotlist · gen-voiceover ·
  338. measure-voiceover · gen-veo-briefs · veo-generate ·
  339. check-insert-plan · export-timeline · package-delivery
  340. agents/ ทีม subagent hyv-* ทั้ง 16 ตัว
  341. ```
  342. ไม่ผูกกับ editor ตัวใดตัวหนึ่ง: มัน export timeline กลาง (JSON + CSV) ที่คุณเอาไปประกอบใน **CapCut, Premiere, DaVinci Resolve, หรือ code renderer** ก็ได้ — แล้วแพ็กเป็นโฟลเดอร์ส่งมอบที่สะอาด สามารถเรียกใช้ `veo-insert-planner` (ภาพ generative) และ `remotion-best-practices` (เฉพาะถ้าประกอบด้วยโค้ด) เป็น option ได้
  343. ## 3 วิธีรันสกิลนี้
  344. ลูปนี้มี **สองครึ่ง** ที่ต้องการคนละอย่างกันมาก:
  345. - **ครึ่งที่คิด** — research, เขียนบท, ดีเบต punchline, storyboard ใช้แค่การให้เหตุผล **รันที่ไหนก็ได้**
  346. - **ครึ่งที่ใช้เครื่อง** — วัดเสียงด้วย `ffprobe`, ดึงฟุตเทจด้วย `yt-dlp`, ทำ shotlist ด้วย Python, ตัดต่อใน **CapCut/Premiere/DaVinci ของคุณ** อันนี้ต้องมี shell จริงบนเครื่องจริงที่มีไฟล์คุณอยู่
  347. ได้ครึ่งไหนขึ้นกับว่ารันที่ไหน — เลือกชั้นที่ใช่:
  348. | | **Basic** | **Advance** | **Production** |
  349. |---|---|---|---|
  350. | **ที่ไหน** | Chat — เว็บ หรือ tab Chat ในแอป | **Cowork** | **Claude Code** — CLI หรือ tab Code |
  351. | **ติดตั้ง** | plugin | plugin | `npx hearyourvoice install` |
  352. | **ทีม** | ❌ agent เป็นสีเทาในแชท | ✅ **ครบ 16 ตัว แตกงานขนานกัน** | ✅ ครบ 16 ตัว |
  353. | **ครึ่งที่คิด** | ✅ | ✅ | ✅ |
  354. | **ครึ่งที่ใช้เครื่อง** | ❌ ไม่มี shell | ❌ — ดูเหตุผลข้างล่าง | ✅ |
  355. | **เหมาะกับ** | หัวข้อเดียว คิดให้ตกผลึก | **research + เขียนบท ทีละหลายเรื่องพร้อมกัน** | ทำวิดีโอให้เสร็จจริง |
  356. **Basic** = Claude ตัวเดียวที่มีวิธีการทั้งหมดอยู่ในหัว พอสำหรับพาหนึ่งไอเดียจากหัวข้อไปจนได้ hook ที่ผ่านการดีเบต
  357. **Advance** = จุดที่สนุก โยน 3 หัวข้อให้ Cowork แล้ว `hyv-producer` แตกลูกทีมออกไปทำทั้ง 3 เรื่องพร้อมกัน — researcher ยืนยันแหล่งข่าวขนานกัน ทีมดีเบตเถียงเรื่อง hook ของแต่ละเรื่อง `hyv-judge` บอกว่าเรื่องไหนเสียงแตก **ไม่ต้องมี terminal เลย** *(ทดสอบจริงแล้ว: ทีมแตกงานขนานกันใน Cowork ได้)*
  358. **Production** = ชั้นเดียวที่ทำวิดีโอจบได้ เพราะมีแต่เครื่องคุณเท่านั้นที่มี ffmpeg ของคุณ ฟุตเทจของคุณ และโปรแกรมตัดต่อของคุณ
  359. **และมันต่อกันได้** — คิดกับดีเบตหลายเรื่องรวดใน Cowork แล้วเอาเรื่องที่ชนะเข้า Claude Code เพื่อผลิตจริง
  360. ### ทำไม Cowork ทำครึ่งที่ใช้เครื่องไม่ได้
  361. shell ของ Cowork *"execute[s] inside a dedicated Linux VM, isolated from the host operating system by the platform's hypervisor"* — ต่อให้เป็นโหมด local มันก็เอื้อมไม่ถึง ffmpeg ที่ลงไว้บน **Mac ของคุณ** และ Anthropic ไม่เคยระบุว่าใน VM นั้นมีอะไรติดมาบ้าง ยังไงขั้นตัดต่อสุดท้ายก็จบที่โปรแกรมบนเครื่องคุณอยู่ดี
  362. **นี่ไม่ใช่กำแพง แต่คือรอยต่อ** — Cowork เก่งครึ่งที่คิด Claude Code รับช่วงที่เหลือ
  363. <details>
  364. <summary>ทดสอบอะไรไปแล้ว และอะไรที่ยังไม่รู้</summary>
  365. **เห็นกับตา:** plugin ติดตั้งใน Cowork ได้ · `hyv-producer` ถูกเรียกด้วยชื่อจริง · ลูกทีมแตกงานขนานกันหลายหัวข้อ
  366. **ยังไม่ได้ทดสอบ:** VM ของ Cowork มี `node`/`ffmpeg`/`python` ไหม และขั้นที่เสียเงินจะเป็นยังไงบนนั้น — gate เรื่องเงินอยู่ในตัวสคริปต์แล้ว (ไม่มี `--yes` = ไม่จ่าย) แต่ยังไม่มีใครเห็นพฤติกรรมนั้นบน VM ของ Cowork เพราะงั้นถือว่า phase 2 เป็นต้นไปเป็นงานของ Claude Code ไปก่อน
  367. README เวอร์ชันก่อนหน้าเคยเขียนว่า Cowork ทำอะไรไม่ได้เลย — **อันนั้นผิด** และมันเขียนจากการอ่าน docs ไม่ใช่จากการลองจริง
  368. </details>
  369. **จำง่าย ๆ: คิดใน Cowork ทำให้จบใน Claude Code** ถ้า Claude เอื้อมไม่ถึง ffmpeg กับโปรแกรมตัดต่อของคุณ มันก็ทำวิดีโอไม่จบ ต่อให้สกิลดีแค่ไหนก็ตาม
  370. ## ติดตั้ง — Basic & Advance (ใช้ plugin ไม่ต้องแตะ terminal เลย)
  371. plugin ตัวเดียวได้ทั้งสองชั้น: skill ทำงานในแชท และทีมทั้งกองตื่นขึ้นมาใน Cowork
  372. 1. **[โหลดไฟล์ plugin zip](https://github.com/killernay/HearYourVOICE/releases/latest)** จาก release ล่าสุด
  373. 2. **Claude → Customize → Plugins → upload** ไฟล์ zip นั้น
  374. 3. **ใช้งาน** — สั่งเป็นภาษาคนได้เลย ถ้าอยู่ใน Cowork โยนหลายเรื่องรวดได้:
  375. > *"/hearyourvoice ทำ 3 เรื่องนี้พร้อมกัน: ค่าไฟแพง, ฝุ่น PM2.5, หนี้ครัวเรือนไทย — เอาแค่ research + เขียนบท + ดีเบต hook"*
  376. `hyv-producer` จะรับงานแล้วแตกลูกทีมไปทำทั้ง 3 เรื่อง
  377. > **ถ้าจะอัปเข้าช่อง *Skills* แทน *Plugins*:** คนละโครงกัน และ**ไม่พา agent ไปด้วย** release เลยไม่แนบมาให้ — สร้างเองด้วย `node bin/build-bundles.mjs` มันสร้าง `hearyourvoice-skill-<v>.zip` ให้ด้วย ได้วิธีการแต่ไม่ได้ทีม **เลือกอย่างใดอย่างหนึ่ง อย่าอัปทั้งคู่** ไม่งั้นจะมี `hearyourvoice` กับ `hearyourvoice:hearyourvoice` ซ้อนกัน แล้วคุณจะไม่รู้ว่าตัวไหนกำลังตอบ
  378. >
  379. > **ถ้าแก้ skill เอง:** `node bin/build-bundles.mjs` จะแพ็กโค้ดในเครื่องคุณเป็น zip ทั้งสองแบบไว้บน Desktop — ทางนี้สำหรับของที่แก้แล้วแต่ release ยังไม่มี
  380. ## ติดตั้ง — Production (Claude Code)
  381. ไม่ต้องเปิด terminal แยกเลย เพราะแอปมี terminal ในตัวอยู่แล้ว
  382. 1. **โหลดแอป** — [macOS](https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect) หรือ [Windows](https://claude.ai/api/desktop/win32/x64/setup/latest/redirect) แล้วล็อกอิน *(Windows ต้องลง [Git for Windows](https://git-scm.com/downloads/win) ด้วย แล้วรีสตาร์ทแอป)* หรือใช้ `claude` CLI ก็ได้
  383. 2. **กด tab `Code`** (ไม่ใช่ Chat ไม่ใช่ Cowork)
  384. 3. **ตั้ง Environment เป็น `Local`** — ข้อนี้คนพลาดกันบ่อยสุด ถ้าเลือก Remote มันจะไปรันบนคลาวด์ แตะไฟล์ในเครื่องคุณไม่ได้
  385. 4. **เลือกโฟลเดอร์โปรเจกต์** — โฟลเดอร์ที่จะเก็บงานวิดีโอของคุณ
  386. 5. **เปิด terminal ในแอป** — กด `Ctrl` + `` ` `` แล้ววางบรรทัดเดียว:
  387. ```bash
  388. npx hearyourvoice install
  389. ```
  390. 6. **เช็กว่าขาดอะไร** — `npx hearyourvoice doctor` บอกทั้ง Node / Python / ffmpeg และ API key ตัวไหนตั้งแล้วบ้าง (ไม่พิมพ์ค่า key ออกมา)
  391. 7. **ใช้งาน** — พิมพ์ `/hearyourvoice` แล้วบอกว่าจะทำวิดีโอเรื่องอะไร มันแตกทีมให้เอง ไม่ต้องเรียกชื่อ `hyv-producer`
  392. จบแล้ว — CLI กับแอปใช้ที่ติดตั้งร่วมกัน ทำครั้งเดียวได้ทั้งสองทาง
  393. ### จะลงไว้ตรงไหน: global หรือ project
  394. ทั้งคู่คือการติดตั้งของ Claude Code เหมือนกัน — ต่างกันแค่ *ขอบเขต*
  395. **ทั้งเครื่อง (global)** — ใช้ได้ทุก session:
  396. ```bash
  397. npx hearyourvoice install # skill → ~/.claude/skills/ · agents → ~/.claude/agents/
  398. npx hearyourvoice install codex # → ~/.codex/skills/hearyourvoice (เฉพาะ skill)
  399. npx hearyourvoice install hermes # → ~/.hermes/skills/hearyourvoice (เฉพาะ skill)
  400. ```
  401. **ระดับโปรเจค** — เฉพาะ repo ที่กำลังทำ (รันจาก root ของมัน):
  402. ```bash
  403. cd ~/path/to/your-video-repo
  404. npx hearyourvoice install project # → ./.claude/skills/ + ./.claude/agents/
  405. ```
  406. ตัวติดตั้งแตะเฉพาะไฟล์ `hyv-*.md` ของตัวเอง — agent ตัวอื่นของคุณไม่ถูกแตะต้อง ส่วน Codex/Hermes ได้เฉพาะ skill เพราะ `.claude/agents/` เป็นของ Claude Code
  407. ### เลือก global หรือ project ดี?
  408. | | **Global** (`install`) | **Project** (`install project`) |
  409. |---|---|---|
  410. | อยู่ที่ | `~/.claude/skills/` + `~/.claude/agents/` | `./.claude/` ใน repo |
  411. | ใช้ได้ที่ | ทุก session ในเครื่อง | เฉพาะ repo นั้น |
  412. | ขึ้น git ไหม | ไม่ | ได้ ถ้า commit `.claude/` |
  413. | เวอร์ชัน | ตัวเดียว ใช้ทุกที่ | pin แยกต่อ repo |
  414. | เหมาะกับ | เครื่องตัวเอง ทำหลายคลิป เวอร์ชันเดียว | ทีมที่แชร์ repo เดียวกัน หรืออยากรันหลายเวอร์ชันคู่กัน |
  415. **ไม่รู้จะเลือกอะไร → เอา global** คำสั่งเดียว ใช้ได้ทุก session อัปเดตทีเดียวได้หมด: `npx hearyourvoice install`
  416. **เลือก project เมื่อ** อยากให้เพื่อนร่วมทีมได้เวอร์ชันเดียวกันเป๊ะแค่ clone repo (commit `.claude/` ไปด้วย เขาไม่ต้องติดตั้งเลย) หรือเมื่อคนละ repo ต้องใช้คนละเวอร์ชัน
  417. ### กับดักข้อเดียวที่ต้องรู้: skill กับ agent ตัดสินกลับด้านกัน
  418. Claude Code ปฏิบัติกับสองอย่างนี้ไม่เหมือนกัน และมันจะทำให้คุณงงถ้าไม่รู้:
  419. - **skill** — **global ชนะ project** ถ้าชื่อซ้ำกัน (docs: *"enterprise overrides personal, and personal overrides project"*)
  420. - **agent** — **project ชนะ** ถ้าชื่อชนกัน แต่ agent ที่ลง global ยัง**โผล่ในทุกโปรเจกต์** — มันเพิ่มเข้าไป ไม่ได้ถูกแทนที่
  421. ผลที่ตามมาจริง 2 ข้อ:
  422. 1. **ลง global ทีเดียว = ลบล้าง project แบบเงียบ ๆ** ถ้ามี HearYourVOICE ตัว global อยู่ สกิลที่ลงไว้ใน project จะถูกมองข้าม — **ต่อให้ตัวใน project ใหม่กว่าก็ตาม** การลงแยกเวอร์ชันต่อ repo จะได้ผลก็ต่อเมื่อ**ไม่มีตัว global เลย**
  423. 2. **agent ตัว global ตามคุณไปทุกที่** ถ้าลงทีมแบบ global แล้ว `hyv-*` จะโผล่ในทุกโปรเจกต์ รวมถึงอันที่คุณอยากได้แค่ skill เปล่า ๆ
  424. สรุป: **เลือก scope เดียวแล้วอยู่กับมัน** ถ้าต้องการเวอร์ชันแยกต่อ repo (หรืออยากเดโมสองเวอร์ชันเทียบกัน) ให้**ไม่ลง global เลย** แล้วใช้ `install project` ในแต่ละที่แทน
  425. เช็ก toolchain ได้ทุกเมื่อ: `npx hearyourvoice doctor` (Node / Python / ffmpeg)
  426. > ใช้จาก local checkout ก็เหมือนกัน ผ่าน `npx .`:
  427. > `cd HearYourVOICE && npx . install project` • หรือใช้ bash fallback `./install.sh <target>`
  428. จากนั้นเปิด session แล้วพิมพ์ *"ทำวิดีโอเรื่อง &lt;หัวข้อ&gt; ด้วย HearYourVOICE"* หรือโยนให้ทีมเลย: *"ให้ hyv-producer ผลิตวิดีโอเรื่อง &lt;หัวข้อ&gt;"* ดูรายละเอียด, dependency, และรายการ **Environment & API keys** ฉบับเต็มได้ใน **INSTALL.md**
  429. ## สิ่งที่ต้องมี
  430. - **Node 18+** (เครื่องมือ `.mjs`), **Python 3** + `openpyxl` (shotlist), **ffmpeg/ffprobe** (วัดเวลา & ตรวจเรนเดอร์)
  431. - ทีม subagent ต้องใช้ **Claude Code v2.1.172+** (รองรับ subagent ซ้อน) ส่วนตัว skill รันที่ไหนก็ได้
  432. - สำหรับตัดต่อขั้นสุดท้าย: **editor ที่คุณถนัด** (CapCut, Premiere, DaVinci, หรือ code renderer), **ElevenLabs** API key (เสียงพากย์), และ — เฉพาะถ้าใช้ภาพ generative — Veo provider plugin ของคุณเอง
  433. ## 💸 ต้นทุน & จริยธรรม — อ่านก่อนทำ phase 4
  434. ### ทำวิดีโอจบได้ด้วย ฿0
  435. ต้องพูดให้ชัด เพราะทางที่แพงคือทางที่คนมักคิดว่าจำเป็น:
  436. | เฟส | ทางที่จ่าย | ทางฟรีที่ก็ได้งานเหมือนกัน |
  437. |---|---|---|
  438. | **2 · เสียงพากย์** | ElevenLabs API | `gen-voiceover.mjs --emit-md` → เอาไปพากย์ใน UI ของ ElevenLabs เอง, TTS เจ้าอื่น, โมเดลในเครื่อง หรืออ่านเองเลยก็ได้ |
  439. | **4 · หาภาพ** | คลิป generative | **ภาพถ่าย Creative-Commons จริง** — `fetch-cc-images.mjs` ดึงจาก Openverse + Wikimedia ตรวจสัญญาอนุญาตให้ แล้วเอาข้อความคุณซ้อนบนภาพ ส่วนกราฟิกเป็นทางสำรองรองลงมา |
  440. ```bash
  441. node scripts/fetch-cc-images.mjs --slug pm25-dust --query "ฝุ่น" --source wikimedia --limit 5
  442. ```
  443. วิดีโอที่สร้างจาก **ภาพถ่ายที่มีลิขสิทธิ์ถูกต้อง + ตัวหนังสือซ้อน คือผลงานที่สมบูรณ์ ไม่ใช่ของตกเกรด** — คลิปอธิบายความทำแบบนี้กันมาหลายสิบปีแล้ว และหลายครั้ง**ชัดกว่า**ฟุตเทจสต็อกที่เข้ากับสิ่งที่พูดแบบเลือน ๆ ด้วยซ้ำ ตัวเรนเดอร์แบบโค้ดจะใส่ซูมช้า ๆ ให้ภาพนิ่ง มันจะได้ดูเป็นวิดีโอไม่ใช่สไลด์โชว์ และ `hyv-assembler` ก็ปฏิบัติกับมันเหมือนคลิปอื่นทุกประการ
  444. **สัญญาอนุญาตต้อง "อ่าน" ไม่ใช่ "กรอง"** — ตัวกรอง CC ของ Google Images มี false positive เหมือนของ YouTube เป๊ะ เพราะมันกรองเว็บเปิด ไม่ได้อ่าน license จริง ทุกภาพที่นี่อ่าน license จาก metadata ต้นทาง · **ND ตัดทิ้งทันที** (เอาไปตัดต่อ = ดัดแปลง) · NC ตัดทิ้งเว้นแต่สั่งเอง · และ creator/licence/URL ถูกเขียนลง `ATTRIBUTION.md` ตั้งแต่ตอนโหลด
  445. **generative เป็นแค่แหล่งภาพหนึ่งที่เป็น option ไม่ใช่ค่าตั้งต้น** งานส่วนใหญ่ไม่ต้องใช้เลย
  446. ### ถ้าจะใช้จริง ๆ
  447. **ภาพ generative (Google Veo) แพงมาก** ราคาประมาณ **$0.75 ต่อวินาที (≈ ฿30/วินาที)** หมายความว่า insert สั้น ๆ แค่ 6 วินาที ก็ตกราว **$4.5 (≈ ฿180)** และถ้าทำคลิปยาว 90 วินาทีด้วย Veo *ล้วน ๆ* จะตกราว **$67 (≈ ฿2,700)** *(ราคาเปลี่ยนได้ตามเวลา — เช็กเรตปัจจุบันก่อนตัดสินใจเสมอ)*
  448. อย่าคว้ามาใช้ถ้าช็อตนั้นยัง**ถ่ายได้ หาได้ หรือวาดได้** และคุณ**จ่ายพลาดโดยไม่ตั้งใจไม่ได้** — สคริปต์ที่เสียเงินทั้งสองตัว**ปฏิเสธที่จะรันถ้าไม่มี `--yes`** มันจะพิมพ์ราคาที่จะโดนชาร์จแล้วหยุด ส่วน `hyv-veo-runner` จะโชว์ราคาประเมินและรอคุณอนุมัติก่อนจ่ายทุกบาท
  449. **แต่ skill นี้คุ้มตรงไหน:** ถ้าเป้าหมายคุณคือผลิตคอนเทนต์ *ปริมาณมาก* — เช่นวันละร้อยชิ้น — harness ที่ทำซ้ำได้คือสิ่งที่ทำให้ปริมาณระดับนั้นเป็นไปได้โดยคุณภาพไม่พัง นี่แหละคือคนที่ skill นี้ถูกสร้างมาเพื่อ
  450. **อย่าขโมย footage ใคร** ภาพที่ไปหามา ให้ค้นเฉพาะ **Creative Commons (CC / NC) เท่านั้น** — ตรวจสัญญาอนุญาตด้วยตัวเอง (ตัวกรอง "CC" ของ YouTube ให้ผลหลอกได้), บันทึกเครดิต + URL ต้นทางไว้ใน `ATTRIBUTION.md`, และทิ้งทุกอย่างที่เคลียร์สิทธิ์ไม่ได้ — `hyv-cc-scout` ทำแบบนี้เป๊ะ ๆ และทิ้งทุกอย่างที่เคลียร์ไม่ได้ การก๊อปงานคนอื่นมาใช้ ไม่ใช่กลยุทธ์หา footage
  451. ## สัญญาอนุญาต
  452. MIT — ดูที่ `LICENSE`
  453. ## ที่มา — ระลึกถึง VOICE TV
  454. ชื่อ **HearYourVOICE** ตั้งขึ้นเพื่อระลึกถึง **VOICE TV** — สถานีที่ "ปลูกความคิด" ให้สังคมไทยตลอด 15 ปี (พ.ศ. 2552–2567)
  455. ผม **ชานนท์ เงินทองดี** เริ่มต้นที่นี่ในตำแหน่งแรกคือ *Head of Research and Development* ตั้งแต่วันก่อตั้งสถานี โปรเจคนี้คือความตั้งใจถอด *know-how* ที่เราใช้กันในห้องข่าวและงานโปรดักชันของ VOICE TV ออกมาเป็น `SKILL.md` — เปลี่ยนวิธีคิดและกระบวนการทำคอนเทนต์คุณภาพ ให้กลายเป็นสิ่งที่ "ทำซ้ำได้" ในยุค AI
  456. เมื่อวานผมได้คุยกับ **คุณทรงศักดิ์ เปรมสุข** ผู้ร่วมก่อตั้งและกรรมการผู้อำนวยการสถานี ท่านบอกว่า — *"ถ้าวันนั้นเรามี AI โลกของทีวีคงไปได้ไกลกว่านี้อีกเยอะ"* จริงอยู่ที่วันนี้ VOICE TV ไม่ได้ออกอากาศแล้ว แต่วิธีคิดและวิธีทำงานของมันไม่จำเป็นต้องจบลงตามไปด้วย เพราะ `SKILL.md` สืบทอดต่อได้ด้วยมันสมองใด ๆ ก็ได้ในโลก ไม่ว่าจะเป็นของคนหรือของ AI
  457. หวังว่าโครงสร้างของโปรเจคนี้ จะช่วยให้ใครก็ตามหยิบไปสร้างคอนเทนต์และประเด็นคุณภาพ ออกสู่สังคมไทยได้ต่อไป
  458. > *Hear your voice — เพราะทุกความคิดที่ดี ควรมีพื้นที่ให้ได้ยิน*

Ratings and comments

Sign in to rate this skill.

Sign in

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