From Library to Live Projects: How to Work with Skills in Rakenne

When you first open Rakenne, it can feel like there are two layers:

• Projects, where you do your day‑to‑day work with clients and documents.
• Skills, which are reusable workflows that teach the AI how to act like a specialist in your domain.

This article explains the full lifecycle of a skill from an end‑user point of view:

1. What the Skill Library is and how to find the right skill
2. How to install a skill into a project and start using it
3. How updates and versions work
4. How to fork a skill when you need your own flavor
5. How to publish and share skills across projects and clients

No code, no implementation details — just how to use this as a consultant, analyst, or compliance lead.

New to skills? If you haven’t read it yet, start with What Is a Rakenne Skill? for the foundational concepts — what skills are, how they differ from raw chat, and how they fit into projects and sessions.

1. What is the Skill Library?

A skill is a guided workflow written in plain language that tells the AI:

• When it should be used (typical triggers)
• What steps to follow, in what order
• Which documents, templates, and tools to use along the way

Examples:

• “ISO 27001 Asset Inventory”
• “Clinical Study Report (CSR) – Key Sections”
• “Food Labeling Claims Review – US Market”

The Skill Library is where those skills live:

• System skills: pre‑built skills that ship with Rakenne
• Tenant skills: skills created and shared inside your organization
• Your own skills: drafts and published skills you authored or forked

You can think of it as an app store for workflows. Projects don’t automatically get every skill; you pick the ones you want.

2. Finding the right skill

Before you start a new project, it’s worth spending a few minutes exploring the library.

2.1 Common ways to browse

Most library views support:

• Search: type a keyword like “SOC 2”, “clinical”, “asset inventory”, or “labeling”.
• Filters / tags: narrow down by:
  • Domain (e.g. Information Security, Life Sciences, Food & Beverage)
  • Use case (e.g. “Risk Assessment”, “Policy Drafting”, “Readiness”, “Data Extraction”)
• Sorting:
  • Most installed / popular: what other teams rely on most
  • Recently updated: skills that are actively maintained

As a rule of thumb:

• Start broad: search by your framework or regulation (“ISO 27001”, “ISO 14971”, “SOC 2”, “CVM FIDC”).
• Then refine by document type (“SoA”, “Risk Register”, “Readiness”, “Prospectus”, “Clinical Report”).

2.2 Reading a skill before you use it

Click into a skill to see:

• What it produces: documents, structured data, checklists, summaries…
• When to use it: typical starting prompts or situations
• Inputs required: what you need ready (existing PDFs, a policy set, client facts, etc.)
• Expected outputs: examples of what the session will create

Treat this like checking the product label before you buy: if the skill’s outputs don’t match your deliverable, keep searching.

3. Installing a skill into a project

Skills live in the library, but they only become usable when you attach them to a specific project.

3.1 Why installation matters

When you install a skill into a project, Rakenne:

• Makes that skill’s workflow available to the project’s AI agent
• Brings along any supporting skills it depends on (for example, common ISO 27001 helpers)
• Ensures the right tools and templates are available behind the scenes

This keeps projects clean: each project only sees the skills it actually needs.

3.2 Typical installation flow

1. Open your project.
   For example: “Client A – ISO 27001 ISMS”, “Fund Alpha – FIDC Documents”, or “ACME – Product Labeling”.

2. Go to the project’s Skills section.
   Look for a “Skills”, “Add skills”, or “Skill library” entry in the project navigation.

3. Browse or search the library from inside the project.
   You’ll see the same skills as in the global library, plus indicators for:

   • Already installed skills
   • Skills that are compatible with your project template

4. Install the skill.

   • Click Install (or equivalent) on the skill you want.
   • If the skill requires helpers (other skills it builds on), they are installed together.
   • Installation usually takes a few seconds.

5. Confirm availability in the project.
   After install, the skill:

   • Appears in the project’s Installed Skills list
   • Becomes available in the chat (see next section)

From this point on, everyone with access to the project can use that skill.

4. Using an installed skill in a session

Once a skill is installed, you don’t need to think about the library anymore — you just talk to the agent.

4.1 Invoking a skill

There are two common patterns:

• Natural language
  Start a session and describe what you want:

  “Help me run an ISO 27001 asset inventory workshop for ACME.”
  “I need to extract all key data from this FIDC prospectus PDF.”

  If your project has a relevant skill installed, the agent will often route your request into that skill automatically.

• Explicit selection
  In some UIs, you can pick a skill from a menu or use a specific trigger syntax.
  This is useful when:

  • You know exactly which skill you want
  • You’re working in a project that has multiple similar skills

4.2 What a skill‑driven session feels like

Compared to chatting with a generic AI, a skill session is:

• Structured — the agent walks you through clear steps:
  • Gather certain inputs (documents, facts, parameter choices)
  • Run extraction or analysis
  • Produce documents, checklists, or structured data
• Repeatable — if you run the same skill on a different client, the flow is almost identical.
• Traceable — you can usually tell which step you’re on and what’s coming next.

You don’t need to remember the technical details. You only need to:

• Pick the right skill
• Provide the inputs it asks for
• Review and approve the outputs

5. How skill versions and updates work

Skills evolve over time: a better checklist, a tighter template, an improved interpretation of a standard.

Rakenne handles this through versions.

5.1 What versions mean for you

For you as an end‑user:

• Each skill has a current version (e.g. “v1.0”, “v1.1”…)
• A project typically uses one version per skill at a time
• When a new version is released, you’ll see it as an update opportunity, not a surprise change

Key behaviors:

• Existing projects stay stable.
  If a project is on v1.0, it stays on v1.0 until you choose to move.
• New projects can start on the latest version.
  When you install a skill in a brand‑new project, you’ll usually get the latest version by default.

5.2 Deciding when to update

When a new version is available, you may see:

• A banner or indicator on the skill in the project
• Release notes describing what changed (new sections, better coverage, bug fixes, improved guidance)

Good practice:

• Update early when:
  • You’re starting a new client engagement
  • The release notes fix errors, gaps, or mapping issues you care about
• Delay or test when:
  • You are in the middle of a sensitive regulatory deliverable
  • Your internal reviewers have signed off on a specific version

A simple workflow for regulated work:

1. Create a sandbox project.
2. Install the skill and upgrade it to the latest version there.
3. Run a trial session with a sample client.
4. Only then, upgrade the skill in your production client projects.

6. Forking a skill: creating your own flavor

Sometimes a standard skill gets you 80% of the way there, but your organization:

• Has its own checklists or approval thresholds
• Uses different terminology (e.g. internal control names, role titles)
• Needs extra steps for internal governance

In those cases, you can fork a skill instead of starting from scratch.

6.1 What “forking” means in practice

From an end‑user perspective, forking means:

• You start a special project (often from a Skill Workshop template) that contains:
  • A copy of the original skill
  • Any supporting references and examples
• You adapt the workflow to your reality:
  • Rephrase questions and instructions in your language
  • Add or remove steps
  • Point to your own internal document styles, examples, and policies
• You end up with a new skill that:
  • Is clearly based on the original
  • Belongs to your organization
  • Can be installed in your projects like any other skill

6.2 When to fork vs. when to configure

• Configure (don’t fork) when:

  • The skill already has inputs/parameters for your choices (e.g. jurisdiction, sector)
  • You only need to change data (client facts), not the workflow

• Fork when:

  • Your review process is meaningfully different from the default
  • Your internal teams would be confused by the standard wording
  • You need extra steps that will be reused across many clients

Forking is how you turn Rakenne from “generic best practice” into your house method.

7. Publishing and sharing your skills

Once you have a customized skill that works well, you can publish it so others can use it.

From an end‑user point of view, publishing does three things:

1. Freezes a version of the skill that others can rely on.
2. Adds it to the library visible to your organization (or a subset, depending on your governance).
3. Makes it installable into regular projects, just like system skills.

Typical sharing patterns:

• Within a team
  Example: The Security team publishes “ACME – ISO 27001 Gap Assessment” tailored to how ACME interprets certain controls.

• Across lines of business
  Example: A GRC consulting squad publishes “SOC 2 Readiness – Consulting Edition” so any consultant can run the same workflow with their clients.

• Per client segment
  Example: “Clinical Reports – Oncology Sponsors” vs “Clinical Reports – Device Sponsors”.

You can always keep iterating:

• Create v1.1 with minor improvements
• Migrate new projects to the latest version
• Decide case‑by‑case if existing projects should be upgraded

8. Multi‑client and multi‑tenant scenarios

If you’re a consultant or managed service provider, you may:

• Serve multiple clients from the same Rakenne tenant
• Want each client to have their own projects, but share common skills

The normal pattern is:

1. Author / fork your consulting‑grade skills once.
2. Publish them into your tenant’s library.
3. For each client:
   • Create client‑specific projects
   • Install the same skills into those projects
4. Use client‑specific data (projects and documents) with the same underlying workflows.

This gives you:

• Consistent methodology across clients
• Project‑level data isolation
• A single place (the skill) to update your approach when regulations or best practices change

9. Putting it all together: a concrete example

Imagine you’re a GRC consultant preparing several clients for ISO 27001 certification.

A realistic flow might look like this:

1. Find skills in the library

   • Search for “ISO 27001” and identify:
     • “ISO 27001 Asset Inventory”
     • “ISO 27001 SoA”
     • “ISO 27001 Risk Assessment”
     • “ISO 27001 ISMS Scope and Context”
     • “ISO 27001 Management Review”

2. Install skills into a client project

   • Create a project: “Client A – ISO 27001 ISMS”.
   • Install those ISO skills into the project.

3. Run sessions with the client

   • Use the Scope and Context skill to define the ISMS boundaries.
   • Use the Asset Inventory skill to run workshops with stakeholders.
   • Use the Risk Assessment and SoA skills to generate structured outputs.

4. Tune the approach

   • Notice that your firm has an extra management review checklist.
   • Fork the Management Review skill, add your checklist and presentation style, then publish it as “GRC Firm – Management Review”.

5. Scale to other clients

   • For “Client B – ISO 27001 ISMS”, install your firm‑specific Management Review skill instead of the default.
   • All projects now share the same improved workflow.

You never touched internal APIs or code — you just worked with skills, projects, and the library UI.

10. Next steps

If this is your first time working with skills in Rakenne:

• Step 1: Open a project you’re already using and look at its Installed Skills list.
• Step 2: Visit the Skill Library and find one new skill to try in that project.
• Step 3: For a process you repeat across clients, consider whether it deserves its own forked skill.

Over time, your Skill Library becomes a living catalog of how your organization actually works, not just how the standards are written. That’s where Rakenne shines.

Further reading

• What Is a Rakenne Skill? — the foundational concepts behind skills and how they fit into Rakenne.
• Creating Skills with the Skill Workshop — step-by-step guide to authoring your own skills when forking isn’t enough and you need to build from scratch.
• Understanding Projects — how projects, sessions, and skills relate to each other.