taste
/taste
Zapamiętuje preferencje montażu wideo i zapisuje każdą poprawkę jako regułę, żeby nie powtarzać tej samej korekty.
- Autor
- nextwork-projects ↗
- Repozytorium
- ai-video-editor-cooked ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 27.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 4
- Skrypty
- 2
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
- 2 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
Skrypty: scripts/learn.py, scripts/taste.py
Co robi i kiedy
Zapamiętuje preferencje montażu wideo i zapisuje każdą poprawkę jako regułę, żeby nie powtarzać tej samej korekty.
Oryginalny opis (EN)
Remembers how the user likes their videos edited, so they never give the same correction twice. Saves every correction or preference about an edit (the cut, captions, visuals, sound, layout) into ~/.ai-video-editor/taste.md as a plain rule, and into taste.json when it maps to a setting the scripts read (pause length, fillers, caption size, words per caption, zooms, sound, layout), deduplicated, scoped to every video or just this one, and counted when applied; one that would help everyone goes to the maintainers. Every other cooked. skill reads both before it starts. Use whenever the user react
Jak działa
- When the user reacts to an edit
- Learn from a past edit
- Is it learning
- Before any edit
- Show, change, forget
- Files
Podgląd SKILL.md
---
name: taste
description: Remembers how the user likes their videos edited, so they never give the same correction twice. Saves every correction or preference about an edit (the cut, captions, visuals, sound, layout) into ~/.ai-video-editor/taste.md as a plain rule, and into taste.json when it maps to a setting the scripts read (pause length, fillers, caption size, words per caption, zooms, sound, layout), deduplicated, scoped to every video or just this one, and counted when applied; one that would help everyone goes to the maintainers. Every other cooked. skill reads both before it starts. Use whenever the user reacts to an edit ("too slow", "captions are too small", "fewer zooms", "I hate the whoosh", "that's perfect, keep it like that"), and when they ask "what do you know about my taste", "show my settings", "forget that rule" or "are you learning". Also learns how they cut from a raw take and their posted version ("I already edit by hand", "learn from my edit"). Not for a finished video's notes as a batch (skill-improver).
license: MIT
compatibility: Python 3.9+, standard library only. Runs from the full ai-editor plugin folder (uses its lib/).
---
# Taste
Paths: `${CLAUDE_SKILL_DIR}` means the folder containing this SKILL.md, and `${CLAUDE_PLUGIN_ROOT}` the plugin folder two levels above it.
Every question to the user goes in the question box: call the AskUserQuestion tool (2-4 options, the recommended one first). Only in an agent without that tool, ask numbered questions in text.
The user's own rules, kept outside the plugin (plugin updates never touch them):
```
~/.ai-video-editor/taste.md rules in plain words, one bullet each, by section
~/.ai-video-editor/taste.json settings the scripts read; they win over the creator's style.json
<library>/custom/ their own rule files, caption styles and template defaults (custom.py)
```
Never write a correction into the plugin's own files (a SKILL.md, a reference, a script): an update
replaces them. Everything the user teaches goes in the files above.
`S="${CLAUDE_SKILL_DIR}/scripts"`. Stdlib only, any `python3` (`py` on Windows).
## When the user reacts to an edit
1. Find the behaviour behind what they said, not the one instance. "The 'router' card is too
small" becomes "Cards fill the space they have", not "make the router card bigger".
2. Scope. After every correction, ask in the question box: "Is this about this video, your style, or
would it help everyone?" with the options `My style (Recommended)`, `Just this video` and
`Would help everyone`. When the edit used a creator's style (`edits/<name>/style.json` has a
`source`), add `This style (<its name>)` first, as the recommended one, by the name the home page shows ("50/50"),
never its folder or `@id`. Skip the question only when they already said it ("always", "just this one").
`Would help everyone` saves it to their style too, then step 6.
Notes sent from the review page never get this question: only the ones the user ticked "Keep as a
rule" become rules, saved without asking (style-edit `references/review.md`).
3. Save it with `add`, with the setting when one maps (table below) and the edit it was said on:
```bash
python3 "$S/taste.py" add captions "Captions bigger" --set captions.size_pct=6 --edit edits/<name>
python3 "$S/taste.py" add sound "Whooshes quieter on this one" --video edits/<name>
python3 "$S/taste.py" add visuals "Logos stay smaller than the captions" --edit edits/<name>
python3 "$S/taste.py" add captions "Captions smaller" --set captions.size_pct=4.5 --style edits/<name> --edit edits/<name>
```
`--style` (This style): the setting goes to that creator's `style.overrides.json` (style.json stays
as measured; a re-study keeps it), which wins over taste.json on that style, and the rule to the
"Learned from your feedback" section of its `edit-like-<handle>` skill. `My style` rules also
update the `my-style` skill.
The same rule said again (same setting, or near-identical words, same scope) edits the old
one instead of adding a copy. Every-video rules also land in taste.md (words) and taste.json
(the setting); this-video rules stay in rules.json and reach only that edit.
| they say | `--set` |
|---|---|
| cut is too slow / too rushed / too tight | `cut.max_pause=` (default 0.15 s; slower 0.25, faster 0.12); on a 16:9 YouTube video `cut.max_pause_wide=` (default 0.30 s) |
| captions too small / too big | `captions.size_pct=` (cap height, % of frame height) |
| more / fewer words on screen | `captions.words_per_caption=` |
| captions higher / lower | `captions.y_pct=` |
| caption colour / highlight colour | `captions.color=` / `captions.highlight_color=` (`"#RRGGBB"`) |
| fewer / more zooms | `zoom.per_min=` (0 turns zooms off) |
| no sound effects | `sfx=false` |
| always split / always overlay | `layout.mode=split` or `overlay` |
| keep my ums / don't cut fillers | `cut.keep_fillers=true` (retakes.py proposes no filler cuts) |
| a whole caption look they want kept | write `custom/captions/<name>.json` (a style.json captions block), then `captions.preset=<name>` |
No setting fits (card timing, a capture cropped wrong, a look), so it is a word rule: write it
so it can be followed next time ("Captures crop to the sentence that proves the point").
4. Tell the user in one line what was saved, so they can catch a wrong one:
`Saved to your taste: "Logos stay smaller than the captions" (visuals, every video)`.
If `add` prints `regression`, the rule was already applied and did not hold: say so, and
make it more concrete (a setting, a number) instead of saving the same words again.
5. Then redo the edit with it.
6. On `Would help everyone`, write it as a rule for every user of the editor, never about this video:
what was wrong, the general rule, the skill or check that should own it, and a small example
without their media, names or links (the script scrubs paths, file names, emails, handles and links too):
```bash
python3 "$S/taste.py" suggest "Zoom snapped in over 2 frames" "Zooms ease in over at least 0.5 s" --owner "style-edit quality.py zoom check" --example "a 1.2x punch at 0.07 s"
python3 "$S/taste.py" issue # shows the issue it would open
```
If `gh auth status` succeeds, ask in the question box: "Send it to the editor's maintainers as a
GitHub issue?" with `Yes, open an issue (Recommended)` / `No, keep it on my computer`. On yes:
`python3 "$S/taste.py" issue --yes`, and give them the issue link. No gh, or no: it stays in
`~/.ai-video-editor/suggestions.jsonl`, where the maintainers' `improve` skill reads it.
## Learn from a past edit
When the user already edits by hand (or says yes to setup's "Have a raw take and the version you
posted? I can learn how you cut."), ask for both paths and read `references/learn-from-edit.md`.
It runs `learn.py <raw> <posted>`, which saves their pause length, retake and filler habits as
rules with counts, so the first edit already cuts like them.
## Is it learning
```bash
python3 "$S/taste.py" report
```
Each rule with times applied, in how many edits, corrections, and the last edit where it
was said again after it was applied. Rules from review-page notes (`review.py learn`) say so.
On the final approve the review page offers the session's notes as rules to tick, saved into the
edit's style (the skill-improver skill: `review.py learn --propose` / `--done`).
Show it on "what have you learned", "are you learning", or after a regression.
## Before any edit
Every cooked. skill starts by reading the taste for the edit it is on:
```bash
python3 "$S/taste.py" show --edit edits/<name>
```
That also counts the word rules as applied to this edit. plan.py and build_timeline.py read the
settings themselves (`load_json()` in the plugin's `lib/ai_editor/taste.py`) and count them.
Follow every rule in taste.md. They beat the creator's style: the user chose them. If a rule and
the creator's style disagree, say so once and follow the rule.
## Show, change, forget
- "What do you know about my taste": `taste.py show`, then summarise it in a few lines.
- Forget a rule: `taste.py report` for its number, then `taste.py forget <id>` (its setting and
taste.md line go with it).
- Reset everything: delete taste.md, taste.json and rules.json (ask first).
## Files
- `scripts/learn.py`: a raw take and the user's posted cut of it in, their cut settings out; `demo`.
- `${CLAUDE_PLUGIN_ROOT}/lib/ai_editor/custom.py`: `path`, `rule "<rule>"` (a rule file in custom/rules/, which `show` prints), `list`.
- `scripts/taste.py`: `add`, `report`, `show`, `forget`, `rule`, `set`, `unset`, `get`, `suggest`, `issue`, `demo`. A thin
CLI over the plugin's `lib/ai_editor/taste.py`, whose `load_json()` and `merge()` are what plan.py
and the cut use to lay the taste over the defaults and style.json.
- `~/.ai-video-editor/rules.json`: every rule with its scope, corrections, times applied and
regressions (shape in the lib's docstring).
Pliki w paczce (4)
- SKILL.md 9 KB
- references/learn-from-edit.md 4 KB
- scripts/learn.py 21 KB
- scripts/taste.py 1 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · nextwork-projects/ai-video-editor-cooked | 100 | MIT |
| gosuda/dalcom-skills | 100 | Apache-2.0 |
| alebgl77/claude-inc | 100 | MIT |
| affaan-m/ECC | 100 | MIT |
| SHRIJANAGAIN/Nemo-Cli | 100 | Apache-2.0 |
| mikemoller/premium-ui | 100 | MIT |
| Mohit-Alive/explainer-studio | 100 | MIT |
| GMShadowe/THE-DAILY-4B | 100 | MIT |
| mfbz/taste-cli | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki f1628f24cdb6 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100video-captions
Dodaje wypalane napisy do wideo po lokalnej transkrypcji mowy, działa offline na Windows i macOS. - 100start
Zbiera raz odpowiedzi o platformie, twórcach, marce i zakazach, a potem prowadzi cały montaż wideo do zatwierdzenia przez użytkownika. - 100video-captions
Dodaje wypalane napisy do wideo, transkrybując mowę lokalnie, z domyślnym stylem lub szablonem pill. - 100kinetograph-taste-clone
Klonuje wybrany film referencyjny 1:1 lub wyciąga z niego styl, mierząc każdą klatkę i porównując wynik z oryginałem. - 90video-editor
Montuje, przycina i poprawia nagrania, dodaje napisy, grafiki i dźwięk, renderuje film i konfiguruje narzędzia. - 100sr-edit-plan
Zamienia wideo i transkrypcję w plan montażu: tempo mówienia, pauzy do wycięcia, napisy i listę cięć.