How to Create, Lock, and Test a Skill
There is no single correct way to make a Skill.
You can create one from a prompt, a chat instruction, a finished output, a whole board process, a workflow document, a successful experiment, or an existing Skill you want to customize. The best creation method depends on where your workflow starts.
Sometimes you already know the workflow and want to define it from scratch. Sometimes you discover the workflow by accident after a great result. Sometimes the workflow is spread across a board, with prompts, inputs, intermediate steps, and final outputs all showing how the process works.
Luma Skills are designed to capture all of those cases.
The goal is always the same: turn a useful creative process into a repeatable workflow that can be tested, refined, saved, and reused.
The main ways to create a Skill
There is no single correct way to make a Skill. Luma supports several paths, depending on where the workflow starts.
1. Create a Skill from a prompt text box
You can write a prompt directly on the board as a text asset.
Once the prompt exists as an asset, select it and ask the agent to turn it into a Skill.
This is useful when you already know the workflow you want, but you have not run it yet. It lets you draft the process first, then convert it into a reusable tool.
Example:
Turn this into a Skill.
Use this when your workflow is already described clearly in text.
2. Create a Skill from a plain chat instruction
You can also create a Skill directly from chat.
For example:
Create a Skill that repaints any object in a matte color.
Luma will turn that request into a structured Skill. This is often the fastest way to start when you know the outcome you want but do not need to base it on an existing output.
This method works well for simple, general-purpose Skills, such as:
- Material swaps
- Style applications
- Product transformations
- Format conversions
- Brand treatments
- Social variant generation
The agent may ask follow-up questions if it needs to lock down the Skill’s intent, inputs, or defaults.
3. Create a Skill from an output
Every generated asset carries information about how it was made.
For example, a generated image can include the input asset, model, resolution, and exact prompt used to produce it. Because that information is attached to the output, you can select the finished asset and ask Luma to turn it into a Skill.
This is useful when you get a result you love and want to capture the recipe behind it.
Example:
Turn this into a Skill.
Luma can inspect the output’s footprint and reconstruct the workflow that produced it.
Use this when the final output is the clearest example of what the Skill should do.
4. Create a Skill from an entire process on the board
If you have built a more complex workflow on the board, you can select the relevant assets, prompts, examples, and steps, then ask Luma to distill the process into a Skill.
Example:
Distill this entire process into a Skill.
This is useful when the process matters as much as the result. For example, you may have a board that shows input images, intermediate edits, prompt notes, reference examples, and final outputs. Luma can use that structure to understand the workflow from start to finish.
This approach works best when your board is organized enough for the process to be readable. Clear text prompts, labeled steps, and visible before-and-after examples make the Skill easier to create.
5. Create a Skill from a workflow document
You can also write a workflow document that describes the repeatable process, then turn that document into a Skill.
This is useful when you want to define a Skill carefully before testing it.
A workflow document might describe:
- What the Skill is for
- What input assets it needs
- What the user should select before running it
- What the Skill should preserve
- What the Skill should change
- What model or settings it should use
- What output format it should create
- How the user should trigger the run
Once the document is ready, select it and ask:
Turn this process into a Skill.
This is a good option for production workflows, brand systems, or any Skill where clarity matters.
6. Save a workflow you just nailed
Sometimes the best time to create a Skill is right after you get something working.
If you have just finished a workflow that required tuning, correction, or experimentation, you can simply ask Luma to save it.
Example:
Save this as a Skill.
This captures the workflow while the successful setup is still present: the assets, prompts, model choices, and settings that made the output work.
This is especially useful for workflows that were difficult to discover but easy to reuse once saved.
7. Fork or customize an existing Skill
Some Skills may be built-in or shared with you. If a Skill is read-only, you cannot edit it directly.
Instead, you can fork it.
Forking creates your own editable copy. You can then adjust the workflow, defaults, model choices, prompt language, references, or presets without changing the original.
Use this when a Skill is close to what you need but not quite right.
Example:
Fork this Skill and change the default output to vertical.
8. Build a brand or product-specific Skill
Skills can also be built around specific brand or product assets.
For example, you might upload:
- Product packshots
- Logos
- Color palettes
- Typography references
- Brand guidelines
- Packaging images
- Campaign examples
- Character references
Luma can use those references to create a Skill that consistently pulls from real brand assets.
This is useful for teams that need repeatable creative output without drifting away from approved visual identity.
The Skill creation flow
When Luma creates a Skill from an output, process, or board workflow, it may narrate what it is doing.
It will look for the important parts of the workflow: the subject, structure, composition, pose, material, style, camera framing, visual treatment, model choice, and anything else that should be preserved or repeated.
Then it may ask locking questions.
Locking questions are used to clarify what the Skill should do every time versus what should change from run to run.
For example, Luma might ask:
What is the core reusable intent of this Skill?
Should the subject identity be preserved, automatically changed, or specified by the user?
Should the original composition stay locked?
Should the Skill always use the same model?
Should the background change or remain consistent?
Which details should be treated as required?
Which details are optional?
These questions are important because they turn a loose example into a reusable system.
A Skill should not merely imitate one output. It should understand what made the output useful and how to apply that logic to new inputs.
Testing before saving
A Skill is not fully useful until it has been tested.
When creating a Skill, Luma may run a test before saving it. This gives you a chance to see whether the Skill actually performs the workflow correctly.
You can let Luma choose test assets, or you can provide your own.
Testing is especially important for Skills that need to preserve specific details, such as:
- Pose
- Product shape
- Composition
- Character identity
- Material behavior
- Framing
- Brand elements
- Camera angle
- Motion logic
- Final output format
Do not approve a Skill if the test does not match your intent.
Instead, give direct feedback.
For example:
Before you save it, edit this Skill so the pose stays identical.
Before you save it, make the subject larger in frame.
Before you save it, make sure it preserves the object shape.
Before you save it, make sure it only uses this model for final outputs.
Luma can update the Skill, run another test, and continue iterating until the result is reliable.
The goal is not just to make a Skill that works once. The goal is to make a Skill that works predictably.
Best practices for creating reliable Skills
Start with a real workflow whenever possible. Skills are strongest when they capture something that has already worked.
Be clear about the reusable intent. The Skill should know what job it performs, not just what one example looked like.
Separate what changes from what stays fixed. This is the heart of a good Skill.
Test before saving. A Skill that has not been tested is still just a hypothesis.
Use your own test assets when accuracy matters. This helps reveal whether the Skill generalizes.
Give feedback before approving. If the test is wrong, edit the Skill before saving it.
Lock down important model choices. If consistency depends on a specific model, make that part of the Skill.
Use presets for common variations. Presets make Skills easier to run and share.
Keep descriptions practical. A good Skill description should help someone else understand when and how to use it.
Fork before customizing read-only Skills. Do not fight the original; make your own editable version.
Treat Skills as living workflows. Update them as your process improves.
Quick reference: creating a Skill
To create a Skill
From chat:
Create a Skill that does [outcome].
From a prompt on your board as a text box:
Select the text box, then say: Turn this into a Skill.
From an output:
Select the finished image or video, then say: Turn this into a Skill.
From a board process:
Select the relevant workflow, then say something like: Distill this entire process into a Skill.
From a workflow document:
Select the document, then say something like: Turn this process into a Skill.
From a successful workflow:
Save this as a Skill.
To test or refine a Skill
Run another test before saving.
Use this asset as the test input.
Before you save it, edit the Skill so it preserves the pose more accurately and consistently.
Before you save it, make the product larger in frame.
Before you save it, make sure it only uses this model for final outputs.
Run another test on this [image].
Save it.
A helpful reminder
Do not rush the moment between creating a Skill and saving it.
That is where the Skill becomes reliable. Use the test run to find out whether the workflow actually preserves the right details, changes the right variables, and generalizes beyond the original example.
If the test is wrong, edit the Skill before saving. A few clear corrections at this stage can make the difference between a one-off recipe and a dependable creative tool.
Key takeaway
You can create Skills from prompts, chat instructions, outputs, board processes, workflow documents, successful experiments, or existing Skills. The strongest Skills are locked around clear intent, tested before saving, and refined until they behave predictably.
What Skills Are and Why They Matter
A Skill is a repeatable creative workflow you can build once and run again whenever you need it.
Instead of rebuilding the same prompt, model choice, asset setup, sequence of steps, and creative constraints every time, you can turn that workflow into a Skill. A Skill captures what worked: the instructions, the defaults, the references, the settings, and the intent behind the process.
Think of a Skill like a saved creative recipe.
It is not just a single image, video, or output. It is the reusable process behind that output. Once saved, you can run it on new assets, adjust it with custom instructions, edit it over time, chain it with other Skills, and share it with teammates or collaborators.
Skills are especially useful when you have found a workflow that you know you will want to use again: a product reskin, a brand treatment, a character transformation, a video generation sequence, a campaign format, a recurring style, or a multi-step production process.
What a Skill is
A Skill is a reusable workflow that lives on your Luma board.
It can be simple or complex.
A simple Skill might do one thing very well, such as turning any object into glass, gold, wood, ceramic, or matte plastic.
A more complex Skill might take a product image, apply a specific art direction, generate a set of lifestyle images, then turn the best one into a video with a consistent camera move.
A Skill can also be chained with other Skills. One Skill might generate the still image treatment, another might animate it, and another might create social crops or campaign variants.
At its core, a Skill is made from instructions. When you open a Skill, you can see its name, description, and body. The body is the actual repeatable workflow. It tells Luma what to do, what to preserve, what to change, what models or settings to use, and how to interpret future inputs.
A strong Skill usually captures:
- The core purpose of the workflow
- The required inputs
- The steps to perform
- The creative rules to follow
- The defaults to use
- The model or settings choices that matter
- The things that should stay consistent across runs
- The things that can change each time
- Optional presets or variations
The best Skills feel less like one-off prompts and more like reliable creative tools.
Why Skills matter
Skills help you move from isolated generations to repeatable systems.
Without Skills, you may find a great workflow but still need to remember how you made it. You have to reconstruct the prompt, find the source image, remember the model, choose the right settings, and repeat the same creative logic every time.
With Skills, the workflow becomes reusable.
That means you can:
- Save a process the moment it works
- Run the same creative treatment on new assets
- Keep brand, product, or character logic consistent
- Share a proven workflow with teammates
- Turn one successful experiment into a repeatable production method
- Build libraries of creative capabilities over time
Skills are most powerful when a workflow has value beyond the first output. If you would want to repeat it, teach it, share it, scale it, or improve it over time, it is probably a good candidate for a Skill.
When to create a Skill
Create a Skill when you notice a workflow becoming reusable.
A good signal is that you have done the same kind of task more than once. Another signal is that a workflow took real tuning: multiple attempts, careful prompts, specific model choices, or important preservation rules.
You might create a Skill when:
You finish a workflow that worked especially well.
You build a repeatable visual style.
You create a product treatment you want to apply to multiple objects.
You discover a prompt-and-model combination that reliably produces a specific result.
You make a process that involves multiple steps and would be annoying to recreate manually.
You want teammates to use the same method without needing to understand every detail.
You need a brand, product, or campaign workflow that uses the same references every time.
You want to turn a board process into a reusable recipe.
The practical rule is simple: if the workflow is useful once, keep the output. If it is useful twice, turn it into a Skill.
What makes a good Skill
A good Skill is clear, reusable, and specific about what matters.
It should not be so vague that every run feels random. It should also not be so rigid that it only works for one asset.
The best Skills define the relationship between consistency and flexibility.
For example, a material reskin Skill might always preserve object shape, camera angle, and composition. But the material can change every run.
A character portrait Skill might always preserve character identity and facial structure. But the setting, wardrobe, lighting, or mood can change.
A social campaign Skill might always produce a set of platform-specific outputs. But the product, message, and audience can change.
When building or editing a Skill, ask yourself:
What should always stay the same?
What should the user provide each time?
What can be customized?
What should the Skill infer automatically?
What should the Skill never change?
What examples or references should it rely on?
What does a successful output look like?
A Skill gets stronger when those answers are built directly into the workflow.
Practical Skill patterns
Here are some common ways to use Skills in creative work.
Example: Material transformation Skill
Use this to apply a material or surface treatment to an object.
Examples:
- Turn any object into gold
- Repaint a product in matte black
- Make a toy look like ceramic
- Transform a statue into glass
- Apply a soft rubber finish
Useful defaults might include preserving the original object shape, camera angle, composition, and lighting direction.
Example: Product lifestyle Skill
Use this to place product images into repeatable lifestyle environments.
Examples:
- Put a packshot into a premium bathroom scene
- Turn a product into a rainy street ad
- Create a luxury tabletop campaign image
- Generate a clean ecommerce hero shot
- Make seasonal product scenes
Useful presets might include studio white, golden hour, night street, luxury editorial, or social vertical.
Example: Character consistency Skill
Use this to preserve or transform a recurring character.
The Skill can define which parts of the character should remain consistent, such as face, proportions, wardrobe, silhouette, or personality, and which parts can change, such as environment, pose, lighting, or scene concept.
Example: Multi-step image-to-video Skill
Use this when the workflow involves more than one generation step.
For example:
- Start with a product image
- Generate a styled campaign still
- Select the strongest still
- Turn it into a short video
- Preserve the product identity and camera framing
This kind of Skill is useful for repeatable video production workflows.
Example: Campaign variation Skill
Use this to scale one idea into multiple versions.
A campaign Skill might generate:
- Different audiences
- Different platforms
- Different aspect ratios
- Different copy directions
- Different visual treatments
- Different seasonal versions
- Different languages or regional adaptations
This is where Skills become especially powerful: one workflow can become a repeatable creative system.
A helpful reminder
A Skill is not just a shortcut. It is a way to turn a creative discovery into a reusable capability.
When you get a result you love, do not only save the output. Save the method. Capture the prompt, the model choice, the preservation rules, the settings, the references, and the logic that made the workflow work.
The more clearly you define what should stay consistent and what should change, the more useful the Skill becomes.
Use Skills whenever a creative workflow deserves to happen more than once. A Skill turns a one-time creative process into a reusable system you can run, adapt, improve, and share.
How to Run, Edit, Share, and Troubleshoot Skills
Once a Skill is created, it becomes part of your creative toolkit.
You can run it on new assets, customize each run with extra instructions, use presets, edit the Skill as your workflow improves, share it with teammates, and troubleshoot it when the output does not match your intent.
A Skill is not frozen forever. It is a living workflow.
The more you use it, the more you learn which parts should be locked down, which parts should stay flexible, and which instructions make the results more consistent.
This article covers how to use Skills after they exist: how to run them, customize them, edit them, organize them in the Skills library, share them across boards, and fix common issues.
How to run a Skill
Running a Skill is simple.
First, select the asset you want to use as the input. Then open chat and type @ to bring up available Skills on the board. Choose the Skill you want, add any required input, and tell it to run.
A basic flow looks like this:
Select asset → @skillname → input asset → submit
For example, if you have a material reskin Skill named "Material Reskin", you might select a product image and type:
@material-reskin gold
The Skill will apply its saved workflow to the selected asset.
If the Skill already has strong defaults, you may not need much extra instruction. Just provide the required input and run it.
Running a Skill with custom instructions
You can also run a Skill with extra direction.
Custom run instructions let you keep the structure of the Skill while changing specific details for that run.
For example:
@material-reskin gold. The eyes should be emeralds.
In this case, the Skill still follows its locked workflow. It preserves the composition and pose according to its instructions, applies the gold material, and also honors the extra instruction about emerald eyes.
The important thing to understand is that custom run instructions do not replace the Skill. They sit on top of it.
Anything you specify can override or guide the current run. Anything you do not specify falls back to the Skill’s saved defaults.
This makes Skills flexible. You can reuse the same workflow while still adapting it to the moment.
Running Skills with presets
Some Skills include presets.
A preset is a named variation inside the Skill. Instead of rewriting a long instruction, you can trigger a preset by name or number.
For example:
@skillname Run preset 3.
@skillname Run the Golden Hour preset.
@skillname Run the Studio White preset.
Presets are useful when a Skill has several common modes.
A product photography Skill might include presets such as:
- Studio white
- Golden hour
- Rainy night street
- Luxury tabletop
- Soft editorial
- Macro detail
- Social vertical crop
A brand Skill might include presets for different campaign styles, platforms, or audience segments.
If you are not sure what presets you could build into your Skill, ask the agent to show you some suggestions.
How to edit a Skill
Skills you create are editable.
You can change the workflow over time as you learn what works.
You might edit a Skill to:
- Add a step
- Remove a step
- Reorder the process
- Change the default model
- Change the default resolution
- Change the default aspect ratio
- Rewrite the prompt body
- Add preservation rules
- Update brand references
- Add or rename presets
- Make the output more consistent
- Make the Skill more flexible
- Lock down a model choice
- Improve the test behavior
You can describe edits in plain language.
For example:
In my lifestyle Skill, change the default aspect ratio to portrait.
Add a studio white preset.
Update the Skill so it preserves the original product label.
Make this Skill use the same model for all final outputs.
Change the prompt so it describes the final result instead of giving step-by-step commands.
For your own Skills, Luma can edit the Skill in place. For built-in or read-only Skills, fork the Skill first, then edit the copy.
How to share a Skill
Skills can be shared between boards.
Open the Skills library, choose the Skill, and use Share. Luma creates a magic link. You can paste that link into another board, open the import modal, and add the Skill to that board.
Once imported, the Skill lives alongside the other Skills on the board.
This makes it easy to pass workflows between teammates, collaborators, boards, and projects.
A shared Skill is more useful than a written explanation because the workflow travels with it. The steps, defaults, references, and instructions are already included.
You can also give a Skill a cover image, making it easier to recognize in a shared library.
The Skills library
You can open the Skills library from the puzzle-piece icon.
The library may include several groups:
Your Skills are the Skills created on the current board.
System Skills are built-in Skills available to you.
External Skills are Skills imported from another board through a shared link.
This library gives you a central place to find, open, inspect, run, share, and manage Skills.
If you are not sure what a Skill does, open it and inspect its name, description, and body. You can also ask Luma to explain the Skill’s workflow, defaults, required inputs, or presets before running it
Troubleshooting Skills
If a Skill does not behave the way you expected, do not assume the whole Skill is broken.
Usually, you need to clarify one part of the workflow.
The output changed too much
Add stronger preservation instructions.
For example:
Preserve the original composition, pose, object shape, and camera angle.
You may also need to lock down structure, identity, or source details depending on the workflow.
The output did not change enough
Make the transformation target more explicit.
For example:
Transform the object into polished translucent glass while preserving its exact silhouette.
A good Skill should know both what to preserve and what to change.
The Skill works on one asset but not another
The Skill may be too dependent on the original example.
Edit the Skill so it describes the general reusable intent, not just the original case.
You may also need to test with a wider range of inputs before saving.
The Skill is inconsistent
Check whether the model, settings, or prompt body are too loose.
If one model produced the original result and another model produced the test result, you may need to lock the Skill to the model that worked best.
You can say:
Before you save it, make sure this Skill only uses this model for final outputs.
The Skill ignores custom instructions
The Skill may have defaults that are too rigid, or your run instruction may not be specific enough.
Try naming the variable clearly.
For example:
Run this Skill with the material set to brushed steel, while keeping the default composition and lighting.
The Skill is hard for teammates to use
Improve the description, required input instructions, and presets.
A teammate should be able to open the Skill and understand:
- What it does
- What to select before running it
- What input to provide
- What defaults it uses
- What presets are available
- What kind of output to expect
A Skill is not only a workflow. It is also a handoff.
Quick reference: running, editing, and sharing
To run a Skill
Select the input asset.
Type @.
Choose the Skill.
Add the required input.
Type run.
Example:
@material-reskin gold run
To run with custom instructions
Add the extra direction after the main input.
Example:
@material-reskin gold. The eyes should be emeralds.
The Skill keeps its saved workflow while honoring the additional direction.
To use a preset (if you built it with presets)
Run preset 3.
Run the Golden Hour preset.
Run the Studio White preset.
Ask what presets are available if you are unsure.
To edit a Skill
In my Skill, change the default to portrait.
Add a studio white preset.
Update the references to use the new packaging.
Make the Skill preserve the original product label.
Change the model used for final outputs.
Rewrite the Skill so it is more general.
To share a Skill
Open the Skills library.
Select the Skill.
Click Share.
Copy the magic link.
Paste it into another board.
Click Add to board.
A helpful reminder
A Skill becomes more valuable the more clearly it can be reused by someone other than you.
Running a Skill is only one part of the workflow. Editing, presetting, sharing, and troubleshooting are what turn it into a dependable creative system for a team.
If a Skill produces the wrong result, look for the missing instruction: what should it preserve, what should it change, what should it infer, and what should the user provide?
Run Skills by selecting an asset, choosing the Skill with @, adding the needed input, and generating. Use custom instructions and presets for flexibility, edit Skills as your process improves, share them through the Skills library, and troubleshoot by clarifying what should stay fixed versus what should change.