Skills Configuration

Overview

Skills let a Digital Employee follow a reusable operating guide for a specific task or domain.

This repository follows the AIP skills configuration model. For the canonical guide, see the AIP Skills Guide.

There are two supported usage patterns demonstrated by the examples:

• Remote GitHub-based skills

• Local path-based skills

Use remote skills when you want a deployable Digital Employee that references skills stored in GitHub. Use local skills when you want to develop and test skill behavior locally without deploying.

Key Concepts

What is a skill?

A skill is an instruction package that gives the Digital Employee a narrowly scoped behavior. In practice, the examples in this repository show two ways to provide a skill:

• A GitHub URL pointing to a skill directory

• A local filesystem path loaded with Skill.from_path(...)

How skills are attached

You attach skills when constructing DigitalEmployee:

from digital_employee_core import DigitalEmployee

DigitalEmployee(
    identity=identity,
    skills=skills,
)

You can also add skills later using digital_employee.add_skills(...) before deployment or execution.

Skill source types

Remote GitHub skills

In examples/skills_example.py, the skill source is a GitHub URL:

skills = ["https://github.com/coreyhaines31/marketingskills/tree/main/skills/copywriting"]

return DigitalEmployee(identity=identity, skills=skills)

This is the right choice when:

• You want skills stored in a versioned repository

• You want the Digital Employee to be deployed and run remotely

• You want to share the same skill source across environments

Local path-based skills

In examples/local_skills/local_skills_example.py, the skill source is loaded from disk:

from glaip_sdk.skills import Skill

local_skill = Skill.from_path(str(skill_path))
return DigitalEmployee(identity=identity, skills=[local_skill])

This is the right choice when:

• You are developing a skill locally

• You want deterministic testing during development

• You do not want to deploy the skill first

Remote GitHub Skills Example

The file examples/skills_example.py demonstrates the remote workflow.

1) Create the Digital Employee identity

from digital_employee_core import DigitalEmployee, DigitalEmployeeIdentity, DigitalEmployeeJob

job = DigitalEmployeeJob(
    title="Skills-enabled Assistant - Example",
    description="A digital employee using remote skills from GitHub",
    instruction="You are a helpful assistant.",
)

identity = DigitalEmployeeIdentity(
    name="skills_github_assistant",
    email="[e-mail]",
    job=job,
)

2) Attach a GitHub-hosted skill

skills = ["https://github.com/coreyhaines31/marketingskills/tree/main/skills/copywriting"]

github_de = DigitalEmployee(identity=identity, skills=skills)

3) Deploy before running

github_de.deploy()

message = "Write landing page copy for PulsePath."
result = github_de.run(message=message)

What this example shows

• The Digital Employee accepts a GitHub URL as a skill source

• Remote skills are used in the normal deployed workflow

• deploy() is called before run(...)

Private GitHub repositories

The example notes that public repositories work directly. For private repositories, you must provide one of these environment variables:

• GITHUB_PERSONAL_ACCESS_TOKEN

• GITHUB_TOKEN

• GH_TOKEN

Local Skills Example

The directory examples/local_skills/ demonstrates the local workflow.

1) Define the skill directory

Make a file in ./.agents/skills/haiku-standup/SKILL.md with the following content:

---
name: haiku-standup
description: >
  Format daily standup updates into the team's custom standup template.
  Use when the user mentions "standup", "daily update", "what I did yesterday",
  or asks to format their work status.
---

# Haiku Standup Formatter

Format every standup update using the exact structure below. Never skip sections.
Never reorder them. Always generate the haiku — do not ask the user to write one.

## Output Template

```text
📋 STANDUP — [TODAY'S DATE in YYYY-MM-DD]

🎋 [A haiku summarizing the update — must be valid 5-7-5 syllable structure]

🔥 BLOCKER [PRIORITY-CODE]
[Blocker description — what it is and what it's blocking]
(If no blockers, write: "☁️ ALL CLEAR — No blockers today")

✅ DONE
- [Completed item 1]
- [Completed item 2]

🎯 TODAY
- [Planned item 1]
- [Planned item 2]

Vibe Check: [MOON-RATING] ([N]/5)
```

2) Load the local skill

from pathlib import Path

skill_path = Path(__file__).parent / ".agents/skills/haiku-standup"

3) Load the local skill

from glaip_sdk.skills import Skill

local_skill = Skill.from_path(str(skill_path))

4) Attach the skill to a Digital Employee

job = DigitalEmployeeJob(
    title="Local Skills Assistant",
    description="A digital employee using local skills for deterministic development",
    instruction="You are a helpful assistant. Use the attached local skill as your operating guide.",
)

identity = DigitalEmployeeIdentity(
    name="skills_local_assistant",
    email="[e-mail]",
    job=job,
)

local_de = DigitalEmployee(identity=identity, skills=[local_skill])

5) Run locally without deployment

message = (
    "Standup: Yesterday I migrated the user table to the new schema and pair-programmed with Alex on the search "
    "feature. Today I'm writing tests for the migration. I'm stuck waiting on QA to finish their test plan."
)
result = local_de.run(message=message, local=True)

What this example shows

• A local skill is loaded from a filesystem path

• The skill folder is expected to exist before execution

• Path-based skills are intended for local execution only

• Local skills should be run with run(..., local=True)

• The example does not call deploy()

When to Use Which Approach

Use remote GitHub skills when

• You want a deployable Digital Employee

• Your skill definitions are stored in GitHub

• You want centralized version control for skill content

• You are building a remotely hosted assistant workflow

Use local skills when

• You are iterating on skill content locally

• You want quick testing without deployment

• You need local-only experimentation or deterministic development loops

• You already have a local skill folder with a valid SKILL.md

Best Practices

1. Keep skills narrowly scoped

Write each skill for a specific job, such as copywriting or standup formatting, rather than combining many unrelated behaviors into one skill.

2. Use deploy() only for remote workflows

Follow the examples:

• Remote GitHub skill example: call deploy() before run(...)

• Local path-based skill example: skip deploy and call run(..., local=True)

3. Validate the local path before running

The local example checks that the path exists before creating the employee. This is a good pattern when developing local skills.

4. Keep SKILL.md explicit

A strong skill file should clearly define:

• When the skill applies

• The expected output structure

• Rules and constraints

• What the model must infer versus what it must ask about

Troubleshooting

Local skill is not being found

Problem: The local skill does not load.

Solution:

• Verify the directory path is correct

• Verify SKILL.md exists at the root of the skill directory

• Verify you are calling Skill.from_path(str(skill_path))

Local skill does not behave as expected

Problem: The output ignores the intended format.

Solution:

• Make the instructions in SKILL.md more explicit

• Add stricter output templates and rules

• Ensure the employee instruction does not conflict with the skill behavior

Remote GitHub skill cannot be accessed

Problem: The Digital Employee cannot use the GitHub-based skill.

Solution:

• Verify the GitHub URL points to the correct skill directory

• If the repository is private, set GITHUB_PERSONAL_ACCESS_TOKEN, GITHUB_TOKEN, or GH_TOKEN

• Ensure you call deploy() before run(...)