Create a Skill in one message: spell out your DaVinci Resolve OGraf conventions, then let it get smarter with every chat

Hi, I am KernelKun.

The goal: in your very first message, state the project conventions, build rules and contract you have already worked out, and let the agent create a Skill from them. Anything missing or unclear gets filled in by follow-up questions. Once the Skill exists, every time you use it or correct it, have it write that habit back into the recipe. It gets smarter the more you use it, and that is where a Skill earns its keep. The first version does not have to be perfect.

This post is for beginners, and the example throughout is: create a Skill that generates DaVinci Resolve OGraf templates. The structure of the conventions follows common OGraf authoring rules (folders, development vs production, what the Inspector exposes, canvas, writing back what you learn). Change the paths and scripts to your own; do not copy private paths from someone else's repository.

Status of this post (draft)

Main line: create a Skill in one message → generate templates by the conventions → evolve through chat
Included: a copyable "super first message", a contract checklist, a folder layout, phrases for evolving it
Still to come: screenshots, a walkthrough video, a real before/after of evolution

What you will find here

Why the first message should say everything (instead of drip-feeding)
A ready-to-copy "one-message" prompt (conventions + rules + contract)
The official docs: Help → Documentation → Developer; local paths on Windows and Mac; how to copy them into references; where the template project goes
How to make the Skill evolve in later chats
(Optional) Connect it to LmBox Bridge Motion graphics / Blueprint lab

1. In plain words: a Skill + self-improvement

A Skill = a recipe an agent uses again and again.
Self-improvement = after each job, or each correction, the new habit is written back into the recipe and followed automatically next time.

Only "can generate"	A Skill that is actually useful
You repeat size, style and no-gos every time	Written into the contract in message one, followed by default afterwards
A mistake only fixes this one output	A mistake also fixes the recipe, so it does not happen again
The more you use it, the more tired you get	The more you use it, the better the recipe knows you

So this post stresses two things:

When creating: say all the conventions in one message
When using: keep writing back, so it gets smarter

2. What goes into the first message? (conventions × build rules × contract)

Think of it as three layers, ideally squeezed into one message:

1) Project conventions (where things go)

Which folder the Skill lives in
Where template source and packed files go
How categories are named (for example a human-readable category name + a technical folder name)
How it relates to the official Developer docs (compare against them; never edit the originals in system folders)

2) Build rules (what the output looks like)

Based on OGraf rules commonly used in practice (the human-readable version):

Production mode by default (for final output); build a development version only when you need to debug
Fixed pixel layout on the canvas (usually a 1920-wide canvas; main sizes in px, not drifting vw)
Text and colors the editor will change go into the DaVinci Resolve Inspector, not hard-coded
Write in/out animation into the conventions: in/out (or a hold section), duration and what the Inspector can adjust; if the style is not decided yet, ask first or use the default from the living document
The development version may have a debug panel; the production version must not keep any debug UI
Deliveries come with a checklist: a pair of source files (script + manifest) plus a packed file when needed

3) Project contract (when to use it, what success means, non-goals, evolve, calibrate)

How to trigger it in one sentence later (for example "Make a promo price tag with the OGraf recipe")
What counts as done (parameters change visibly in DaVinci Resolve, folders are clear, there is a checklist)
What it will not do: change the timeline on its own, tie into undocumented internal tools, build types out of scope for this version
Mandatory rule: after every job, write new taste, copy and no-go rules back into the "habits" living document
Calibrate when using it: when making a template with the recipe and something is unclear, ask the user first (motion, copy, colors and so on), then build; write stable preferences back into the living document

Where to find the official OGraf developer docs

Recommended entry point (Windows and Mac): open DaVinci Resolve → top menu Help → Documentation → Developer.
From there you can reach the official developer documentation on your computer (including OGraf HTML Templates).

Local folder paths (read-only reference, do not edit the originals):

System	Usual path of the OGraf developer docs
macOS	`/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/OGraf HTML Templates`
Windows	`C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\Developer\OGraf HTML Templates`

If your version or install method changes the path slightly, trust the location opened by Help → Documentation → Developer. When creating the Skill, you can copy the README and Documentation from that folder into references/official-ograf/.

Background reading: DaVinci Resolve 21: OGraf and Lottie

3. Copy this: create the Skill in one message (well, one short block)

Send the whole block below to the agent as your first message. Replace the two [path] placeholders first (or use the lazy defaults below). Say as many known conventions as you can at once; anything missing can still be asked.

Working protocol (use with the one-message prompt)

One message = all the information at once, not zero confirmation.
Reasonable defaults are allowed → it must restate three points (when to trigger / which folders it writes to / what this version will not do) → you reply "confirm" or fix the paths, and only then are files written.
If the path placeholders were not changed, the agent only produces a draft and must not claim it wrote to your project.
The official references can start as "to be copied" and do not block creating the Skill. Version one is the recipe plus an empty living document; template samples can wait for round two.

Lazy paths (you can put these straight into the first message): the Skill goes in .cursor/skills/make-davinci-ograf/ in your project; the template project goes in ograf-templates/ in your project.

text

Please create a Skill (a reusable recipe) for "generating DaVinci Resolve OGraf templates".
For the [project conventions / build rules / contract] I have spelled out below, follow the working protocol: restate three points → write files only after I confirm.
Anything unclear, conflicting, or needing my decision: keep asking, and write that part only once it is settled.
The Skill will keep improving as I use it. Version one only needs the recipe and an empty living document; do not pretend it is perfect.

[Project conventions · folders]
- Skill folder: [change to your path, or use the default project/.cursor/skills/make-davinci-ograf/]
- Template project: [change to your path, or use the default project/ograf-templates/]
  - Source: src/ → <category>/<TechName>/ → TechName.js + TechName.ograf.json
  - Packed: packed/ → <category>/ → TechName.ograf
  - Optional: a category register (category name ↔ technical name)
- Naming: category names are for humans; technical folders use PascalCase; display names in the manifest are in plain English
- Compare against the official OGraf Developer docs on this computer (open with DaVinci Resolve "Help → Documentation → Developer"; macOS: `/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/OGraf HTML Templates`; Windows: `C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\Developer\OGraf HTML Templates`; reference only, never edit the system originals)
- Put the official README + Documentation (or a summary of the key points) into references/official-ograf/; a "to be copied" note is fine at first and does not block creating the Skill

[Build rules]
- Deliver "production mode" by default: no debug panel, no development logs; build a separate development version when debugging is needed
- Lay out the canvas in fixed px on a 1920-wide canvas; main sizes must not drift with vw
- Copy, colors and switches the editor may change must be exposed in the DaVinci Resolve Inspector; never hard-code them as the only source of data
- Write the font strategy into the recipe: if unknown, leave a placeholder in the living document and ask "can fonts be changed in the Inspector?"; then split Inspector vs preview host by what the product can do
- [In/out animation · must be written into the Skill] Support in and out animation by default (or a looping hold section); align duration with `animDuration` / the clip length in the conventions; expose "animation duration" and similar in the Inspector; if I have not chosen a motion style, ask first (slide in / fade in / pop in, etc.) or use the default from the living document and restate it; never claim full in/out animation for a still frame
- You may look at public HTML/CSS examples before building, but deliveries must not carry "reference source" traces
- Write the delivery checklist into the Skill: source files, packed file (if needed), self-check items

[Project contract]
- Trigger phrase: from now on, when I say "make XX with the OGraf recipe", use this Skill
- Success criteria: folders follow the conventions; changing the Inspector on the DaVinci Resolve timeline takes effect; there is a plain-language delivery checklist
- Non-goals: do not change the timeline or project automatically; do not tie into undocumented internal paths; no Lottie conversion in this version
- Self-improvement (must be written into the Skill):
  1. Read the "habits and style" living document before every job
  2. After I correct layout, copy or no-gos, write it back into the living document at the end of the delivery
  3. Only record reusable preferences; never write keys or private absolute paths of this computer into anything shared
- [Calibrate when using · must be written into the Skill] Every time this recipe is used to make a template: if information is missing, conflicting, or uncertain in a way that affects the result (copy, colors, in/out style or duration, variants, whether to pack, etc.), ask me first, then generate; do not guess. Write stable preferences back into the living document once settled. Follow the same rule while creating this Skill: write down what is known, keep asking about the rest.
- Please produce: SKILL.md main recipe + references (summary of the official docs) + the habits living document (an empty skeleton is fine)
- First restate three points: when to trigger, which folders you will write to (if paths are not filled in, list the defaults you will use and ask me to change them), and what this version will not do; write files only after I confirm; the recipe can keep changing as I use it

Why "say everything", yet still allow questions?

Conventions scattered across a chat get lost; only what is written into the Skill counts, so say as many known conventions as you can in message one.
But a Skill is alive: when something is missing, unclear or needs your call, the agent should keep asking, and the recipe gets refined as you use it, instead of pretending version one is perfect.

Placeholder: screen recording of "paste the first message → folder created" to come.

4. How to lay out the Skill folder (easy to extend, reference and evolve)

Yes, and it is recommended: copy or summarize DaVinci Resolve's official OGraf reference docs into the Skill's references/ (or reference/) as local study material.
The system's Developer/OGraf HTML Templates folder (see the Windows/Mac paths in the table above, or open it from "Help → Documentation → Developer") is read-only for comparison; never edit the originals. What goes into the Skill is a copy or summary that you and the agent can open anytime.

Recommended layout (extensible)

text

make-davinci-ograf/                 # Skill root (folder name = id, can change)
  SKILL.md                          # main recipe: when to use, main steps, contract, delivery checklist, evolution rules
  habits-and-style.md               # the living document name used in this tutorial (not an official requirement of any editor): layout / copy / no-gos
  references/                       # read-only reference: long docs, official material, lookup tables (the main file only points here)
    official-ograf/                 # docs/samples copied from the local Developer folder (or a trimmed summary)
      README.txt
      Documentation/                # 01–07 and so on
      # or just your own "official-key-points.md" to keep it small
    resolve-checklist.md            # optional: self-check before going into DaVinci Resolve
    naming-and-layout.md            # optional: naming and folder rules in detail
  snippets/                         # optional: small copyable snippets (manifest field examples, etc.)
  scripts/                          # optional: packing, validation and other mechanical steps
  assets/                           # optional: diagrams and sample images (not finished templates)

What each layer is for (so it stays tidy later)

Location	What goes in	What stays out
`SKILL.md`	A short, executable main flow and contract	Long stretches of official text
`habits-and-style.md`	Preferences that settle after your corrections (changes often)	Keys, one-off temporary options
`references/`	Official copies/summaries, long rules, lookup tables (changes rarely)	Finished templates still being iterated
`snippets/`	Small pasteable examples	Complete template projects
`scripts/`	Scripts that run deterministically	"Should we do it this way" decisions
`assets/`	Illustrations	DaVinci Resolve timeline projects

How the official docs get into `references/`

You can add one line to your first message, for example:

text

Please copy the README and Documentation from the local "Developer/OGraf HTML Templates" folder
(or summarize them into key points) into this Skill's references/official-ograf/
for reference when generating templates later; do not modify the originals in the system install folder.

Key points:

Full copy: complete for lookups, but a bigger folder
Summary: small and easy to share; do not drop the important chapters (interfaces / Inspector / packing)
Either way, SKILL.md should say: "Read references/official-ograf/… before generating"

Keep finished templates separate from the Skill

text

ograf-templates/                    # project output, not the Skill itself
  src/<category>/<TechName>/
    <TechName>.js
    <TechName>.ograf.json
  packed/<category>/
    <TechName>.ograf

Skill = how to make it + reference material + evolving habits; project folder = the templates it makes. Kept apart, upgrading the recipe never gets tangled with finished files.

If the structure the agent generates does not match your first message, just say: "Change the Skill and the folders to follow the folder conventions in my first message", so it fixes the recipe and not just the files this once.

5. Getting smarter with use: what to say so it evolves

Creating it is only the start; evolving is the daily routine. After each template, wrap up with something like:

text

This one is confirmed: [for example: weather card about 1280 wide, corner radius 36, main color sky blue, city names without the country suffix].
Write this into the Skill's habits living document and make sure it is the default next time for this kind of template; do not only change this one output.

Or when correcting:

text

Wrong: the production version must not have debug info at the bottom. Fix the current template, and add this to the Skill's no-go list so production mode never shows it again.

When evolving, it helps to follow this:

Write back	Do not write back
Default layouts, color preferences, copy habits, no-gos per template type	Keys, tokens, private paths that only exist on your computer
"What to do by default next time"	One-off temporary options
Why it failed + the right way	Venting (turn it into an actionable no-go instead)

Check whether it is getting smarter: a few days later, just say "make another card of the same kind with the recipe". Does it still ask you to repeat the size and style? If not, the evolution is working.

6. Everyday use: the real "one sentence"

After the Skill is built and has evolved a few rounds, everyday requests can be as short as:

text

With the OGraf recipe, make a Black Friday price tag, main color red, headline "Flash Deal", production mode.

If it starts forgetting conventions again, do not only fix the output; add:

text

You missed the Inspector exposure / folder naming. After fixing it, add this to the Skill so it does not happen again.

7. (Optional) Connect it to LmBox Bridge

The Skill handles rules and evolution; on the product side you can optionally use:

Capability	Guide
Preview locally, tweak parameters, manage OGraf/Lottie	Motion graphics
Generate in one sentence, then import	Blueprint lab · OGraf generate

8. Acceptance checklist

[ ] The Skill was generated from just one first message (one block), with folders that match your project conventions
[ ] The recipe states the rules, contract and non-goals, and that habits must be written back
[ ] A template made with the recipe changes visibly when you tweak parameters in DaVinci Resolve
[ ] After you correct it once, the habit is written back; next time you do not repeat it for the same kind of template
[ ] You never have to hand-write the whole Skill each time just to get started

9. Suggested video storyboard

Paste the "super first message" from section 3
Open the generated Skill folder and point out the "habits" living document
Make a template → tweak parameters in DaVinci Resolve
Deliberately correct one style point → ask for it to be written back into the Skill
Give the next short instruction and show that it remembered

Video tutorial

Video coming soon

Create a Skill in one message: spell out your DaVinci Resolve OGraf conventions, then let it get smarter with every chat ​

1. In plain words: a Skill + self-improvement ​

2. What goes into the first message? (conventions × build rules × contract) ​

1) Project conventions (where things go) ​

2) Build rules (what the output looks like) ​

3) Project contract (when to use it, what success means, non-goals, evolve, calibrate) ​

Where to find the official OGraf developer docs ​

3. Copy this: create the Skill in one message (well, one short block) ​

4. How to lay out the Skill folder (easy to extend, reference and evolve) ​

Recommended layout (extensible) ​

What each layer is for (so it stays tidy later) ​

How the official docs get into references/ ​

Keep finished templates separate from the Skill ​

5. Getting smarter with use: what to say so it evolves ​

6. Everyday use: the real "one sentence" ​

7. (Optional) Connect it to LmBox Bridge ​

8. Acceptance checklist ​

9. Suggested video storyboard ​

Video tutorial ​

Further reading ​

Create a Skill in one message: spell out your DaVinci Resolve OGraf conventions, then let it get smarter with every chat

1. In plain words: a Skill + self-improvement

2. What goes into the first message? (conventions × build rules × contract)

1) Project conventions (where things go)

2) Build rules (what the output looks like)

3) Project contract (when to use it, what success means, non-goals, evolve, calibrate)

Where to find the official OGraf developer docs

3. Copy this: create the Skill in one message (well, one short block)

4. How to lay out the Skill folder (easy to extend, reference and evolve)

Recommended layout (extensible)

What each layer is for (so it stays tidy later)

How the official docs get into `references/`

Keep finished templates separate from the Skill

5. Getting smarter with use: what to say so it evolves

6. Everyday use: the real "one sentence"

7. (Optional) Connect it to LmBox Bridge

8. Acceptance checklist

9. Suggested video storyboard

Video tutorial

Further reading