Bodie AI Skills

Skills are saved instructions or workflows that Bodie — Uncountable’s AI assistant — can load and follow. Instead of re-explaining your process each session, you define it once as a skill, and Bodie knows exactly what to do whenever you need it.

You can find and manage skills from within Bodie’s sidepanel by clicking … > Skills.

When a skill is invoked, Bodie loads its instructions and follows them to complete the task — whether that’s generating a report, drafting a value spec, editing a recipe, or summarizing experiment results.

Why Use Skills?

Skills are useful any time you have a workflow that should work the same way every time — or when Bodie needs context about how your team works that would otherwise be tedious to explain each session.

Common use cases:

• Generating structured reports or summaries from experiment data
• Drafting or reviewing value specs with consistent evaluation context
• Creating or editing recipes according to a standard process
• Building plots and visualizations from Explore Data
• Teaching Bodie team-specific terminology (e.g. your team calls experiments “Batches”)

Creating New Skills

To create a new skill, access the Skills page and click + New Skill.

For each skill, fill out:

1. Name — short, human-readable, Title Case, 2–4 words ideal
   • e.g. Experiment Report Generator, Pilot Kickoff Brief, Recipe Cleanup Helper
2. Reference — lowercase hyphenated slug, no spaces, no special characters
   • e.g. experiment-report-generator, pilot-kickoff-brief, recipe-cleanup-helper
3. Description (most important) — This is the primary triggering mechanism. Bodie decides whether to use a skill almost entirely based on this text.
   • Write it to bias toward triggering; under-triggering is the more common failure mode.
   • Include both (a) what the skill does and (b) explicit trigger phrases the user is likely to say.
   • Aim for 2–4 sentences and include concrete trigger phrases.
4. Content — The full skill body, written in Markdown. Write it like instructions to a capable-but-forgetful teammate. Use imperative voice.
5. Loaded by Default — Toggle that determines whether or not the skill loads on demand. Default to No when uncertain.

Not every section is needed — a lightweight skill might just need purpose + instructions + one example. Bodie can also create skills for you. Simply describe the workflow and ask Bodie to draft it.

Skill “Content” Writing Tips

• Imperative over descriptive. “Ask the user for X” beats “The agent should probably ask for X.”
• Explain the why when behavior is non-obvious — it helps Bodie generalize beyond exact examples.
• Examples are gold. One good example often replaces three paragraphs of rules.
• Keep it under ~500 lines unless the skill genuinely needs more. Long skills dilute their own instructions.
• Don’t over-specify. Teach principles, then show 1–2 examples of applying them. Rules that cover every edge case make the skill brittle.
• Avoid MUST/ALWAYS spam. Reserve it for genuine hard rules; everything else should be framed as guidance with reasoning.

Using Skills

Once you’ve added skills, you can either reference them explicitly in your prompt, or (if they’re set to load by default) rely on Bodie to pull them in automatically when relevant.

How skills get used in practice:

• Invoke a skill directly: Ask Bodie to use it by name — e.g. “Use the experiment report skill.”
• Auto-reference (Loaded by Default): If a skill is set to load by default, Bodie can use it automatically without you calling it out.
• Reference examples/files: A skill can instruct Bodie to look at supporting materials (including files in the platform’s file system). Notebooks are typically indexed better than uploaded files.
• Encode team knowledge: Skills are a good place to capture customer/team-specific terminology, how to find SOPs by keyword, or how to interpret your team’s tags/field conventions.

Note: Explicit /command-style skill invocation isn’t supported yet (a ticket has been filed).

Example Skills

Each example below shows the full set of fields used to create the skill, so you can use these as templates when building your own.

Writing and Evaluating Value Specs

Content:

# Writing and Evaluating Value Spec
Help the user draft, refine, or troubleshoot value specs with a consistent workflow.

## When to use this
- User asks to write, create, or draft a value spec
- User asks to review, edit, or improve an existing value spec
- User asks about base entity types or evaluation expressions
- User says a value spec "isn't working" or wants to debug it

## What to do
1. Identify the base entity type for the context (e.g. Recipe, Experiment). Set it correctly before drafting.
2. Ask the user what they are trying to evaluate if it isn't clear.
3. Draft or refine the value spec expression based on their goal.
4. If debugging, read the current value spec and explain what it does before suggesting changes.

## Output format
Return the value spec expression in a code block. Include a plain-language explanation of what it evaluates and why.

## Edge cases / gotchas
- The base entity type must match the context — a mismatch is the most common source of errors.
- If the user hasn't specified an output or metric, ask before drafting.

For example, in the Value Spec editor, Bodie AI can use this skill to:

• Set the correct base entity type for the context (A)
• Draft or refine the value spec you’re trying to build (B)

Editing Recipes

Content:

# Editing Recipes
Use this workflow any time the user asks to edit or iterate on a recipe through the helpbot tools.
For creating a recipe from scratch, use the Creating Recipes workflow instead.

## What to do first
Before making any edit, call `get_recipes_content` to see the recipe's current state: its workflow
steps, recipe step ids, and the inputs already on each step. You need these identifiers to target
edits, and you need to know which inputs exist before deciding whether an action is an add,
a modification, or a removal.

## Editing recipe inputs

Two tools edit recipe inputs:
- `set_recipe_inputs`: Generally should be used for mutating existing recipe inputs — change values,
  associate a lot, or remove an input. In some cases this can be used to add recipe inputs.
- `edit_recipe_inputs`: Generally should be used for adding new recipe inputs, instructions,
  or unstructured steps onto a recipe workflow step.

### Adding inputs
Use `edit_recipe_inputs`, resolve ingredient names with `batched_reverse_id_sources` and target
the workflow step with `recipe_workflow_step_identifier`. Then `add_input` resolved ingredients,
`add_step` unresolved ones as unstructured steps, and `add_instructions` for free-text directions.

### Modifying input values
Use `set_recipe_inputs`, targeting the existing `input_id`. Pass `recipe_step_id` to target a
specific step, `set_actual_value` to edit the actual rather than the set value, and `lot_recipe_id`
to associate a lot.

### Removing inputs
Use `set_recipe_inputs` with `remove` set to `true`.

### Swapping one input for another
A swap is a removal then an add, both via `set_recipe_inputs`:
1. Find the `recipe_step_id` recipe input A lives on, from `get_recipes_content`.
2. Remove recipe input A (`remove` set to `true`).
3. Add recipe input B on the same `recipe_step_id`.

## Editing recipe steps and workflow steps
Use `edit_recipe_steps` to edit recipe steps in batch. Use `upsert_recipe_workflow_step`
to add or modify workflow steps.

## Editing recipe fields and entity details
Edit via `edit_entities` the same way as any entity.

For example, from a recipe page, Bodie AI can use this skill to:

• Add, modify, or remove inputs on the correct recipe step
• Swap one ingredient for another while keeping it on the same workflow step
• Edit recipe steps, workflow steps, and entity fields in batch

Plotting Workflow

Content:

# Plotting Workflow
Use this workflow when building or editing Explore Data plots with `create_plot` or
`edit_explore_viz`.

## Tool usage
- Use `create_plot` for plot creation requests.
- Pass `notebook_id` when the user explicitly wants the graph added to a notebook.
- If no notebook target is requested, omit `notebook_id` to create a detached explore save.

## Default execution pattern (strict)
1. Resolve x-axis entity id and y-axis entity id unless you already have them.
2. Resolve project scope (`project_id` or `recipe_ids`) unless you already have it.
3. Build canonical axis options (`ingred_<id>`, `output_<id>`, `oc_<cp_id>`, etc.).
4. Call `create_plot` once with final resolved inputs.

Do not call `create_plot` until axis ids and scope are fully resolved.

## Editing existing explore visualizations
- If frontend context includes `explore_viz_frontend_context`, prefer editing the current
  visualization in place with `edit_explore_viz`.
- Use `create_plot` instead of `edit_explore_viz` when the user explicitly asks for a new plot.

## Surface plot requests
- For DOE surface-plot analysis requests, use `get_surface_plot`.
- Resolve `doe_run_id` from current page/entity context before calling the tool.

## Project scope
- Provide either `project_id` or `recipe_ids`.
- If the user says "this project", use current page/project context id directly.
- For a broad plot with no specific project named, use `project_id=0`.

## How to find ids
Never guess ids. Use structured-query tools:
1. `discover_structured_targets` to select the relevant target.
2. `discover_structured_column_catalog` to find searchable columns.
3. `run_structured_query` to resolve the id by name.

For example, from an Explore Data page, Bodie AI can use this skill to:

• Resolve the correct x- and y-axis variables by name before building a plot
• Edit an existing visualization in place using the current page context
• Generate DOE surface plots by resolving the run ID from context

Finding and Reading Files

Content:

# Finding and Reading Files
Use this workflow when the user asks to find files, list files in a folder, read files,
summarize files, compare files, or search for files mentioning specific terms.

## Goal
Minimize tool calls.
- Use `global_search` to find files by their contents.
- Do not use the current page folder id unless the user says "this folder" or "here".

## Pick the right path
- If the user asks for the contents of a specific folder → use the named-folder path below.
- If the user asks to find files mentioning a term → use `global_search`.
- If the user asks to summarize or compare files matching a term → `global_search` first,
  then pass matching files into `read_files`.

## Named-folder path
1. Resolve the folder with `run_structured_query` on base=`file_folder`.
2. List folder contents with `run_structured_query` on base=`file_folder_membership`.
3. If the user wants to read or summarize files, call `read_files`.
4. Answer from the file list or file contents.

## General file discovery
Use `global_search` when the user wants to find files by keywords or contents.
- If the user only wants to find files: return matching results, do not call `read_files`.
- If the user wants to summarize or compare: call `global_search`, then `read_files` with
  matching `text_document_id` refs.

## Summarizing multiple files
- Batch whenever possible — call `read_files` once with all matching ids.
- Do not call `read_files` if the user only asked to find or list files.

For example, when asked about files, Bodie AI can use this skill to:

• Resolve a folder by name and list its contents
• Search across the platform for files mentioning specific terms
• Batch-read and summarize multiple files in a single step