Creating Rakenne Skills with the Skill Workshop

Rakenne skills are document-elaboration workflows that the agent can run when users describe a task. The Skill Workshop is a dedicated project type that lets you create and publish your own skills through conversation with the agent — no code required. This tutorial walks you through the full workflow: from creating a workshop project to publishing a skill to your organization’s library.

Prerequisites: This is an intermediate tutorial. If you’re new to skills, read What Is a Rakenne Skill? first. If you want to understand how skills are discovered, installed, and managed in projects, see From Library to Live Projects .

What you’ll need

• Access to a Rakenne instance where you can create projects.
• A clear idea of a domain workflow you want to turn into a skill (e.g. “draft meeting notes from transcripts”, “review contracts against our playbook”, “build a compliance checklist from regulation X”).

Step 1: Create a Skill Workshop project

1. In Rakenne, start Create project (or equivalent in your UI).
2. When choosing a project type, select Skill Workshop.
3. Give the project a name (e.g. “My skill authoring”) and create it.

The workspace comes pre-configured with a skill-creator workflow that guides you through the authoring process, and an output/ folder where every skill you create will live (one subdirectory per skill).

You use the same workspace you already know: chat with the agent, browse the file tree, and preview documents. The only difference is the template and the goal: producing skills instead of a single document.

Step 2: Start the authoring conversation

Open the project and, in chat, say what you want to build. For example:

• “I want to create a skill that turns meeting transcripts into structured notes with decisions and action items.”
• “We need a skill that helps draft privacy impact assessments using our internal template and PIPEDA.”

The agent will use the skill-creator skill and will not create any files until it has understood your workflow. It will ask you questions in a structured way (this is the Elicit phase).

Step 3: Answer the elicitation questions

The agent will ask about:

1. What the workflow is for — Domain and task (e.g. meeting notes, contract review, compliance).
2. What triggers it — When someone would use this skill (e.g. “when the user has a transcript and wants structured notes”).
3. What steps are involved — The sequence (e.g. receive input → extract decisions and actions → confirm ambiguities → produce document).
4. What the output looks like — Document type, sections, format (e.g. executive summary, decision log, action items).
5. Domain knowledge — Regulations, standards, templates, or reference material the agent should use.
6. Other skills it builds on — Whether this workflow relies on or extends another skill already in the library (e.g. “it uses the Create Professional Documents skill for formatting”).

Answer in plain language. If your skill depends on another, say so (e.g. “this skill should run after the user has run the report-templates skill” or “it builds on Create Professional Documents”). The agent will record that as a dependency in metadata so the library can install both when someone adds your skill to a project. The agent will turn your answers into a structured skill; you don’t need to know any special syntax. If you have templates or reference docs, you can add them later or describe them so the agent can reference placeholders.

Step 4: Let the agent scaffold and write the skill

Once the agent has enough information, it will create a new skill folder under output/ with a meaningful name (e.g. meeting-notes, contract-review-playbook). Inside, it will:

1. Write the workflow definition — The steps, rules, and trigger language so the agent knows when to activate this skill and how to run it.
2. Add reference files — Domain knowledge, regulations, or standards that the agent should consult during the workflow.
3. Add asset files — Output templates or examples the agent uses when producing the final document.

All of this happens in the chat; you can watch the file tree and open files to review. Skills are only written under output/.

Step 5: Validate and refine

Before considering the skill ready, the agent will validate it automatically. It checks for:

• Description quality — The description includes trigger language (e.g. “Use when…”, “Use for…”) so the agent knows when to activate the skill.
• Workflow length — The workflow definition is concise; detailed domain content belongs in reference files.
• Reference integrity — All links to reference and asset files point to files that actually exist.
• Library metadata — The skill has the information needed for discovery in the library (or warns that it’s missing; you’ll add it in the next step).

If something fails, the agent will suggest fixes (e.g. add trigger language, fix a broken link, move content to a reference file). You can refine in chat and re-validate until all checks pass.

Step 6: Prepare metadata for the library

When you’re happy with the skill content, the agent will prepare it for publishing to the library:

1. Preview the library listing — The agent shows you how the skill will appear in the skill library, including title, description, and tags.
2. Refine the listing together — You and the agent will set:
   • Title — Human-readable name for the library.
   • Description — Short summary of what the skill does.
   • Tags — Domain-oriented categories (e.g. “Productivity”, “Meetings”, “Legal”, “Compliance”).
   • Examples — Two or three example prompts that users might type to invoke the skill (e.g. “Structure my meeting transcript into actionable notes”).
   • Dependencies (optional) — If your skill builds on other skills, tell the agent: “Add a dependency on [skill name].” See Declaring dependencies below.
3. Final validation — The agent runs a final check to ensure everything is complete and consistent.

After this, the agent will tell you the skill is ready to publish.

Declaring dependencies

If your skill relies on another skill (e.g. a formatting skill or a shared template skill), you can instruct the agent to add it as a dependency. When someone installs your skill on a project, the system will install the dependencies first so everything works together.

How to ask: In chat, during the metadata step (or when you first mention the dependency in Elicit), say something like:

• “This skill depends on Create Professional Documents — add that as a dependency.”
• “Add a dependency on the report-templates skill from our org library.”
• “This skill builds on our compliance-checklist skill.”

The agent will record the dependency for you. You can reference:

• Built-in skills — Use the skill’s name (e.g. “Create Professional Documents”).
• Your organization’s skills — Reference them by name (e.g. “our report-templates skill”). The agent will resolve the correct identifiers.

At publish time, the system checks that every dependency exists and is visible to your organization. If a reference is wrong, publish fails with a clear error. After publishing, the library shows “Depends on” and “Used by” on skill details, and installing your skill will automatically install its dependencies on the project.

Step 7: Publish to your library

1. In the project workspace toolbar, click Publish Skill.
2. A dialog lists the skills in your output/ directory. Select the skill you want to publish.
3. Confirm. The skill is copied to your organization’s skill library and registered in the catalog.
4. You’ll see a success message (e.g. “Skill published to library”). The skill is now available when installing skills on any project in your organization. Republishing the same skill updates the existing version in place.

What’s inside a skill folder

Each skill you create lives in its own folder under output/. You’ll see these files in the file tree:

• Workflow definition — The core file that describes the skill: what it does, when to activate it, and the step-by-step workflow the agent follows.
• Library metadata — Title, description, tags, example prompts, and dependencies. This is what appears in the skill library when others browse or install the skill.
• references/ — Optional. Text files with domain knowledge (regulations, standards, playbooks) that the agent consults during the workflow.
• assets/ — Optional. Templates or static assets the agent uses when producing the final document (e.g. a meeting notes template).

The skill-creator workflow keeps the main definition concise and moves detailed domain content into references/ so the agent gets a clear, scannable workflow plus rich context when needed.

Tips

• One workflow per skill — If you have several distinct workflows, create one skill per workflow; you can author multiple skills in the same workshop project (each in its own folder under output/).
• Trigger language matters — The agent uses the skill’s description to decide when to activate it. Phrases like “Use when the user wants to…”, “Use for drafting…”, or “Use to generate…” help the agent match user intent.
• Tell the agent about dependencies — If your skill builds on another (built-in or your org’s), say so in the Elicit phase or when preparing metadata. For example: “Add a dependency on Create Professional Documents” or “This skill depends on our report-templates skill.” The agent will record the dependency so the library and install flow work correctly.
• Iterate in the workshop — You can reopen the project anytime, edit files or chat with the agent to change the skill, re-validate, and Publish Skill again to update the library copy.
• Domain skills only — The Skill Workshop is for content-driven skills (workflow definitions, references, and assets). Custom programmatic extensions are out of scope for this guided workflow.

Next steps

• Install and test your skill on a document-elaboration project — see From Library to Live Projects for the full install, update, and versioning workflow.
• Use Session Management and Context Hygiene so each authoring task stays in a focused session.
• Read Rakenne 0.2.0 — Skill Workshop and More for the full feature set and skill library improvements.