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

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".
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
```
).
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)
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").

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.
Then redo the edit with it.
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

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).

taste

NPX Install

Tags

SKILL.md Content

Taste

When the user reacts to an edit

Learn from a past edit

Is it learning

Before any edit

Show, change, forget

Files