Przejdź do treści
Biblioteka skilli
Marketing i treści · Automatyzacja

skill-improver

/skill-improver

Zamienia uwagi do gotowego wideo w trwałe reguły stylu lub skilla, sprawdza podobne reguły i zapisuje je po zatwierdzeniu.

Licencja
MIT
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zamienia uwagi do gotowego wideo w trwałe reguły stylu lub skilla, sprawdza podobne reguły i zapisuje je po zatwierdzeniu.

Wyzwalacze z opisu

skills SKILL.md under
Oryginalny opis (EN)

Turns the feedback on a finished video into lasting rules in the style or skill that made it. Collects the video's notes (review-page notes, preview fixes, chat corrections), keeps only the ones meant for every future video, finds the style or skill behind the edit, checks for a similar rule and sharpens it instead of adding a twin, writes each rule as one short line with its reason and date, shows the exact lines and file, and saves only after the user says yes. A skill style (style.json "skill") gets the rules in that skill's SKILL.md under "## Learned rules" with a short log; a settings sty

Jak działa

  1. 1. Collect the notes
  2. 2. Keep only notes for every future video
  3. 3. Find the target
  4. 4. Check for a twin or a conflict
  5. 5. Show the lines, then ask
  6. 6. Save
  7. Files
Sekcje z nagłówków SKILL.md, w oryginale · 120 linii, 946 słów
Podgląd SKILL.md
---
name: skill-improver
description: Turns the feedback on a finished video into lasting rules in the style or skill that made it. Collects the video's notes (review-page notes, preview fixes, chat corrections), keeps only the ones meant for every future video, finds the style or skill behind the edit, checks for a similar rule and sharpens it instead of adding a twin, writes each rule as one short line with its reason and date, shows the exact lines and file, and saves only after the user says yes. A skill style (style.json "skill") gets the rules in that skill's SKILL.md under "## Learned rules" with a short log; a settings style gets them in its own rules and overrides. Runs the review page's "Teach your style from this video". Use when the user says "teach my style from this video", "turn my notes into rules", "make this feedback stick", "update my editing skill from this video" or "learn from this video's notes". Not for one correction said in the moment (taste), and not for fixing the editor for every user (improve).
license: MIT
compatibility: Python 3.9+, standard library only. Runs from the full ai-editor plugin folder (uses its lib/).
---

# Skill improver

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.

taste saves one correction the moment the user says it. This skill works on a whole finished video: it reads
every note, keeps the lasting ones and writes them into the style or skill that made the video.

`K="${CLAUDE_PLUGIN_ROOT}/lib/ai_editor/skillrules.py"`, `R="${CLAUDE_PLUGIN_ROOT}/lib/ai_editor/review.py"`,
`T="${CLAUDE_PLUGIN_ROOT}/skills/taste/scripts/taste.py"`. Run them with `python3` on Mac and Linux, `py` on Windows.

Copy this checklist and tick it off:

```
- [ ] 1. Notes collected
- [ ] 2. One-offs left with the video
- [ ] 3. Target found
- [ ] 4. Each rule checked for a twin or a conflict
- [ ] 5. Lines shown, user said yes
- [ ] 6. Saved, log written
```

## 1. Collect the notes

- Review-page notes and your replies: `edits/<name>/review.json` (`comments`). After the final approve, `wait`'s
  `LEARN:` block already lists them.
- Preview fixes: `edits/<name>/corrections.jsonl`.
- Corrections the user typed in this chat about this video.

## 2. Keep only notes for every future video

A note about one moment stays with the video. A note about how edits should look becomes a rule.

| note | rule? |
|---|---|
| "cut the um at 0:12" | no: one moment |
| "the Notion card covers my chin" (said twice) | yes: "Cards sit above the chin, never over the face" |
| "captions are tiny again" | yes: "Captions one size bigger" (with `set` captions.size_pct when the settings table in taste maps) |
| "wrong logo for Jev" | no: one asset (the logo-pack skill fixes it) |

Write the behaviour, not the instance: "Cards fill the space they have", not "make the router card bigger".

## 3. Find the target

```bash
python3 "$K" target edits/<name>
```

- `"kind": "skill"` with a `path`: a skill style. Rules go into that SKILL.md under `## Learned rules`.
  No `path`: the skill is not in the user's skill folders; say so and stop. A skill inside a plugin is never
  written (an update replaces it); save those rules with taste instead.
- `"kind": "settings"`: rules go to that style (`style` path) or, with `style` null, to My style, through
  `styleskill.learn` (rules.json, `style.overrides.json`, and the style's own skill rebuilt).

## 4. Check for a twin or a conflict

Skill style: `python3 "$K" similar <SKILL.md> "<rule>"` lists the learned rules that look alike.
Settings style: `python3 "$T" report` lists the rules saved so far.

- Same meaning, vaguer: sharpen the old line (`replace`), never add a second one.
- Opposite meaning ("logos bigger" vs a saved "logos small"): ask in the question box which wins, quoting
  both: `The new note (Recommended)` / `The saved rule`. Keep only the winner (`replace`). Never keep both.
- Nothing alike: a new line.

## 5. Show the lines, then ask

Each rule is one line: the rule, `Why:` the reason, and the date. Example, note to line:

```
note:  "the logo is on my face again" (rounds 1 and 2)
line:  - Logos sit beside the head, never over the face. Why: two notes said a logo covered the chin. (2026-10-13)
file:  ~/.claude/skills/my-edit/SKILL.md, ## Learned rules
```

Show every line exactly as it will be saved and the file it goes in. Then ask in the question box:
`Save these (Recommended)` / `Change one` / `Don't save`. Save nothing before the yes.

## 6. Save

**From the review page** (the final approve's "Teach <style> from this video" panel): post the rules, and
the boxes the user ticks are the yes:

```bash
python3 "$R" edits/<name> learn --propose '[{"rule": "Logos sit beside the head, never over the face", "section": "visuals", "why": "two notes said a logo covered the chin", "replace": "Logos beside the head"}]'
python3 "$R" edits/<name> learn --done      # after `wait` prints the ticked rules
```

`why` and `replace` are optional; `set` (a taste setting) only for a settings style. `--done` writes a skill
style's rules into its SKILL.md and a settings style's through `styleskill.learn`. A round's
`learn --scope this-style` does the same for a skill style (the note is the reason).

Each saved rule shows on the review page as a receipt, "Saved to <style>: <rule>. Undo", and on the style's
page under "Learned rules" with its day and the video it came from, where the user can Remove it. Undo and
Remove take the line out again (`taste.py forget`, `skillrules.py remove`); never put it back by hand.

**From the Skills page** ("Improve with feedback", `JOB skill-change`): no video, only the user's words. Steps 3-6
the same; the target is the `path=` the job names. `start/references/home.md` has the status lines.

**From the chat**, after the yes:

```bash
python3 "$K" add <SKILL.md> "<rule>" --why "<reason>" [--replace "<old rule>"] --edit edits/<name>   # skill style
python3 "$T" add <section> "<rule>" [--set key=value] --style <style.json> --edit edits/<name>       # settings style
python3 "$T" add <section> "<rule>" [--set key=value] --edit edits/<name>                           # My style
```

`add` prints `duplicate` when the same rule is already there (nothing written), `sharpened` when it replaced
one, `added` otherwise. It also appends one line to `## Log` at the end of the SKILL.md (the last 20 kept).
A settings style's log is rules.json: `taste.py report` shows each rule's count and dates.

Tell the user in one line what was saved and where.

## Files

- `${CLAUDE_PLUGIN_ROOT}/lib/ai_editor/skillrules.py`: `target`, `similar`, `add`, `remove`, `list`, `demo`.
- `${CLAUDE_PLUGIN_ROOT}/lib/ai_editor/review.py`: `learn --propose` / `--done` (the Teach panel).
- `${CLAUDE_PLUGIN_ROOT}/lib/ai_editor/styleskill.py`: `learn`, a settings style's rules and skill.

Wersje

RepozytoriumWynikLicencja
Ta strona · nextwork-projects/ai-video-editor-cooked100MIT
trailofbits/skills100CC-BY-SA-4.0
FrancoStino/opencode-skills-collection100MIT
sickn33/agentic-awesome-skills100MIT
alex20-create/thinking-skills100MIT
Galaxy-Dawn/claude-scholar100MIT

Migawka bazy z 13.11.2026 · wersja paczki 5e6091544ee2 (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

  • 90draft-review
    Przegląda reakcje na historię i wideo tutorialu, kieruje uwagi do właściwej roli, stosuje poprawki i zapisuje trwałe preferencje stylu.
  • 96ai-content-improver
    Prawdopodobnie poprawia i ulepsza roboczy szkic tekstu z pomocą AI.
  • 90apply-video-review
    Wdraża uwagi z przeglądu wideo zrobionego narzędziem AI Video Review z pliku REVIEW.md lub notes.json.
  • 100learnings
    Pokazuje, cofa i porządkuje reguły, których nauczył się z poprawek twórcy, np. zasady dla napisów lub hashtagów.
  • 90draft-review
    Przeprowadza przegląd wideo i szkiców tutoriali, rozdziela uwagi między role, ponownie renderuje tylko potrzebne części i zapisuje preferencje.
  • 100improve
    Zamienia poprawki użytkowników edytora wideo AI w trwałe naprawy w repozytorium, wymuszone kodem i testami: czyta sugestie, powtarzane reguły gustu, korekty podglądu, notatki z przeglądu i zgłoszenia GitHub.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.