# skillpack-creator

Adopt this skill: https://proskills.md/skills/other/creminiai-skillpack-skills-skillpack-creator

Page: https://proskills.md/skills/other/creminiai-skillpack-skills-skillpack-creator
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/skillpack-creator/SKILL.md
size: 4199
upstream: https://github.com/creminiai/skillpack/blob/main/skills/skillpack-creator/SKILL.md

````text
---
name: skillpack-creator
description: Create a reusable SkillPack from a successful completed task. Use when the user wants to convert a one-off research, coding, analysis, or content workflow into a distributable local SkillPack with `skillpack.json`, local skills under `skills/`, starter prompts, start scripts, and an optional zip package.
---

# Skillpack Creator

## Overview

Turn a successful task into a reusable SkillPack. Extract the stable workflow, decide what belongs in a local skill versus pack-level prompts, generate the pack structure, and package it only after the workflow is explicit and repeatable.

## Workflow

### 1. Normalize the source task

Reduce the finished task into a clean execution spec:

- Capture the user goal, concrete deliverable, and the final successful workflow (not the full exploratory transcript).
- List required skills, tools, files, secrets, and environment assumptions.
- Separate deterministic steps from heuristic steps; remove dead ends and debugging noise.
- If the task is still too broad, narrow the scope instead of writing a vague mega-skill. If key success conditions depend on hidden human judgment, mark the pack as a best-effort assistant workflow.

Ask for missing stable facts or infer only the low-risk pieces.

### 2. Decide what the pack should contain

- **Local skill** (`skills/`): reusable procedural knowledge. Keep scripts minimal unless reproducibility depends on exact file generation or repetitive shell steps.
- **Scripts** (`scripts/`): repeated shell or file-generation logic where reliability matters.
- **References** (`references/`): detailed schemas, API notes, or conventions that should not bloat `SKILL.md`.
- **Prompts** (`skillpack.json`): 1–3 pack-level starter inputs for the UI — not a DAG or state machine. See `references/skillpack-format.md` for exact pack semantics.

### 3. Create the pack specification

Before writing files, define the pack spec. Prefer one local orchestrator skill plus a small number of external skills. Example minimal manifest:

```json
{
  "name": "company-research",
  "description": "Research a company and produce a summary report",
  "version": "1.0.0",
  "prompts": ["Research {company} and create a report with financials and competitors"],
  "skills": [
    { "name": "research-orchestrator", "source": "./skills/research-orchestrator", "description": "Orchestrate company research across multiple sources" }
  ]
}
```

### 4. Create the local orchestrator skill

Create `skills/<skill-name>/SKILL.md` with frontmatter and imperative workflow instructions:

```yaml
---
name: research-orchestrator
description: "Orchestrate multi-source company research. Use when the user wants a structured company report covering financials, competitors, and market position."
---
```

- Write the stable workflow as imperative steps in the body.
- Add `scripts/` only for fragile or repeated operations; add `references/` only for detailed information.

### 5. Materialize the pack

Use `scripts/scaffold_skillpack.py` when you have the pack spec:

```bash
# Basic
python3 skills/skillpack-creator/scripts/scaffold_skillpack.py \
  --manifest /tmp/skillpack.json \
  --output /absolute/path/to/output-pack

# With zip
python3 skills/skillpack-creator/scripts/scaffold_skillpack.py \
  --manifest /tmp/skillpack.json \
  --output /absolute/path/to/output-pack \
  --zip
```

The script validates the manifest, writes `skillpack.json`, creates `skills/`, copies `start.sh`/`start.bat` from `templates/`, and optionally runs `npx -y @cremini/skillpack zip`.

### 6. Validate the result

Before handing the pack back, confirm:

- The manifest matches the intended pack scope
- Every declared skill has a valid `name`, `source`, and `description`
- Local skills are present under the target pack's `skills/`
- Starter prompts are concrete enough to reproduce the workflow
- Zip only after the pack runs as a directory

## Output Standard

Produce:

1. A short summary of the stabilized workflow.
2. The target pack structure and skill inventory.
3. The created or updated local skill files.
4. The generated `skillpack.json`.
5. Whether the pack was zipped and where the zip lives.
````

## File: README.md
upstream: https://github.com/creminiai/skillpack/blob/main/README.md

````text
# SkillPack — Pack and deploy local AI agents for your team in minutes

Skillpack helps teams turn AI skills into trusted local agents that can run in their own environment and be used directly from **Slack** and **Telegram**. Our vision is to achieve distributed intelligence network, much like cremini mushrooms that grow from a vast, interconnected mycelial network.

## What is SkillPack

[skillpack.sh](https://skillpack.sh) is an open-source way to package AI skills into runnable local agents. If skills and tools are like LEGO pieces, a SkillPack is the finished product that assembles them into a complete solution.
Instead of juggling prompts, scripts, docs, and one-off automations, Skillpack gives you a simple way to:

- package AI skills into reusable agents
- run them locally
- keep sensitive data in your own environment
- use agents from tools your team already uses, like Slack and Telegram

Skillpack is built for teams that want AI Agents to be deployable, trusted, and easy to use.

---

## Quick Start

### 1. Run a skillpack

1. Download the example
- [Garry Tan SkillPack](https://github.com/CreminiAI/skillpack-examples/releases/download/v.0.0.3/garry-tan.zip)
- [Company Deep Research SkillPack](https://github.com/FinpeakInc/downloads/releases/download/v.0.0.1/Company-Deep-Research.zip)
2. Unzip it and Run ./start.sh on Mac OS, Or double click start.bat on Windows (see below), the server starts and opens http://127.0.0.1:26313 in your browser

```bash
# macOS / Linux
./start.sh

# Windows
start.bat
```

3. Enter an LLM API key (OpenAI or Claude API Key) in the left menu, use the prompt example to try it!
4. (Optional) Refer to the instructions **Slack/Telegram Integrations** below to integrate with Slack and Telegram.

### 2. Create a new skillpack

```bash
npx @cremini/skillpack create
```

Step by step:

1. Set the pack name and description.
2. Add skills from GitHub repos, URLs, or local paths.
3. Add prompts to tell the agent how to orchestrate those skills.
4. Optionally package the result as a zip immediately.

### 3. Create a new skillpack from an existing config

```bash
# From a local file
npx @cremini/skillpack create --config ./skillpack.json

# From a remote URL (no directory = current directory)
npx @cremini/skillpack create comic-explainer --config https://raw.githubusercontent.com/CreminiAI/skillpack/refs/heads/main/examples/comic-explainer.json
```

Ready to run using "Run a skillpack" part

### 4. Package a pack for distribution

```bash
npx @cremini/skillpack zip
```

Produces `<pack-name>.zip` in the current directory.

To package the skills already present in `skills/` without reinstalling them:

```bash
npx @cremini/skillpack zip --skip-skill-install
```

This faster mode still syncs skill descriptions from the existing `SKILL.md` files before packaging.

---

## Skill Source URL Formats

When adding skills through `create`, the source accepts:

```bash
# GitHub shorthand
vercel-labs/agent-skills --skill frontend-design

# Full GitHub URL
https://github.com/JimLiu/baoyu-skills/tree/main/skills --skill baoyu-comic

# Local path
./skills/my-local-skill
```

Multiple skill names from the same source can be listed comma-separated.

---

## Zip Output

The archive produced by `zip` is intentionally lightweight:

```text
<pack-name>/
├── skillpack.json       # Pack configuration
├── job.json             # Optional scheduled jobs shipped with the pack
├── AGENTS.md            # Optional pack policy
├── SOUL.md              # Optional pack persona
├── skills/              # Installed skills
├── start.sh             # One-click launcher for macOS / Linux
└── start.bat            # One-click launcher for Windows
```

The start scripts use `npx @cremini/skillpack run .` so Node.js `22.19.0+` is the only prerequisite — no pre-bundled server directory is included.

If present, `job.json` defines scheduled jobs that travel with the pack and are loaded by the scheduler at runtime.

If present, `AGENTS.md` and `SOUL.md` are read by SkillPack itself when a new chat session starts. SkillPack injects them into the runtime system prompt as pack-level policy and persona, without depending on the host machine's `AGENTS.md`, `.pi/SYSTEM.md`, or `APPEND_SYSTEM.md`.

## Slack/Telegram Integrations

Talk to your Agents on Slack and Telegram

### 5 mins to get Slack `App Token` and `Bot Token`
https://skillpack.gitbook.io/skillpack-docs/getting-started/slack-integration

### 1 min to get Telegram `Bot Token`
https://skillpack.gitbook.io/skillpack-docs/getting-started/telegram-integration

---

## Example Use Cases

The main use case is to **run local agents on your computer and integrate them with Slack or Telegram** so they can work for you and your team — operating entirely on your machine to keep all team data local and private, while continuously improving by learning new skills. Each SkillPack organizes skills around a well-defined job — for example: research a company by gathering information from multiple sources and produce a PowerPoint presentation from the findings.

Download [Company Deep Research](https://github.com/FinpeakInc/downloads/releases/download/v.0.0.1/Company-Deep-Research.zip) and try it! More examples can be found at [skillpack.sh](https://skillpack.sh)

## Questions?

Join our Discord at https://discord.gg/nj8Br4ePJc

## License

MIT
````
