https://github.com/dubsopenhub/copilot-skill-builder
🧰 Copilot Skill Builder — Turn any prompt into a ready-to-review GitHub Copilot CLI skill.
https://github.com/dubsopenhub/copilot-skill-builder
Last synced: 2 days ago
JSON representation
🧰 Copilot Skill Builder — Turn any prompt into a ready-to-review GitHub Copilot CLI skill.
- Host: GitHub
- URL: https://github.com/dubsopenhub/copilot-skill-builder
- Owner: DUBSOpenHub
- License: mit
- Created: 2026-06-08T16:32:16.000Z (about 2 months ago)
- Default Branch: main
- Last Pushed: 2026-06-22T23:05:55.000Z (about 1 month ago)
- Last Synced: 2026-07-07T22:21:29.241Z (23 days ago)
- Language: Shell
- Homepage:
- Size: 56.6 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Security: SECURITY.md
- Agents: AGENTS.md
Awesome Lists containing this project
README
# 🧰 Copilot Skill Builder
Turn any prompt into a ready-to-review GitHub Copilot CLI skill.
Many people can describe what they want an AI assistant to do, but they might not know how to package that idea into something reusable. They may not know the prompts, YAML, repo structure, install steps, or skill design. So their ideas stay trapped in one-off chats.
Copilot Skill Builder changes that. It turns any prompt into a ready-to-review GitHub Copilot CLI skill.
Example: You type: “Build me a helper that summarizes my GitHub issues every morning.” It asks a few simple questions, shows a short plan, then hands the approved build brief to Dark Factory so the skill is created through the factory line.
> **⚡ One Command. That's It**
>
> **Never used the CLI before? No problem.** Paste this into your terminal:
>
> ```bash
> curl -fsSL https://raw.githubusercontent.com/DUBSOpenHub/copilot-skill-builder/main/quickstart.sh | bash
> ```
>
> When Copilot opens, type:
>
> ```text
> skill builder
> ```
>
> That's it — turn any prompt into a reusable Copilot skill. 🚀
>
> This installs **Copilot Skill Builder** and **Dark Factory** together, so the
> build handoff works when you approve it.
>
> *Requires an active [Copilot subscription](https://github.com/features/copilot/plans).*
## What it does
You describe the helper you want with any prompt. Copilot Skill Builder asks at most
three simple questions, asks where your skills should live, shows a short plan,
then sends the approved plan to [Dark Factory](https://github.com/DUBSOpenHub/dark-factory).
Dark Factory builds the complete skill folder with:
- `SKILL.md`
- `catalog.yml`
- `README.md`
- `WHAT_WAS_BUILT.md`
## How it works
```mermaid
flowchart TD
A["Your prompt
I want a helper that does X"] --> B["Copilot Skill Builder"]
B --> C["At most 3 simple questions"]
C --> G["Plan Card
name, trigger, output"]
G --> H{"Create it?"}
H -- Edit --> C
H -- Cancel --> Z["No files created"]
H -- Create --> I["Build brief for Dark Factory
generated-skills/name/BUILD-BRIEF.md"]
I --> J{"Autopilot with Dark Factory?"}
J -- Approve --> K["Dark Factory runs all build steps
no stopping until final delivery"]
J -- Not now --> M["Save the build brief"]
K --> L{"Final delivery approved
Where should the finished skill live?"}
L -- Existing repo --> N["Add to skills/name/"]
L -- No repo --> O["Create private skills repo
AGENTS + SECURITY + Dependabot + validation"]
L -- Local only --> P["Save locally for now"]
O --> N
N --> Q["Try it locally
/skills add path/to/skills/name"]
P --> Q
```
Copilot Skill Builder is the front door. Dark Factory is the builder. When a
user says they want to build a skill, the approved plan goes through Dark
Factory's spec, architecture, hidden quality checks, validation, and hardening
flow.
At the end of the planning journey, Copilot Skill Builder asks:
```text
Ready to hand this to Dark Factory and build it on autopilot?
```
Choose **Autopilot with Dark Factory** to run the full factory line without
stopping between build steps. You still approve final delivery and where the
finished skill is saved.
## Skills catalog repo
Copilot Skill Builder assumes users should keep their finished skills together
in one repo. After Dark Factory finishes building, it asks where to save the
skill. If the user does not already have a skills repo, it offers to create a
**private** skills catalog repo by default.
The standard catalog repo includes:
- `README.md`
- `AGENTS.md`
- `SECURITY.md`
- `LICENSE`
- `.github/dependabot.yml`
- `.github/workflows/validate.yml`
- `skills//` for every generated skill
When Copilot Skill Builder creates the repo, it activates every available
GitHub security setting automatically: vulnerability alerts, Dependabot security
updates, private vulnerability reporting, secret scanning, non-provider secret
pattern scanning, secret scanning validity checks, and push protection. The user
should not need to find security settings manually.
## Anonymous telemetry
Copilot Skill Builder only counts how many skills are being built. It sends one
anonymous ping after the user approves the Dark Factory build handoff. It does not send prompts, skill names, repo names, Slack details, file contents, or any other metadata.
Set `COPILOT_SKILL_TELEMETRY=off` to disable it.
## Install
### One-command install
```bash
curl -fsSL https://raw.githubusercontent.com/DUBSOpenHub/copilot-skill-builder/main/quickstart.sh | bash
```
This installs Copilot Skill Builder plus Dark Factory, the build engine used
after you approve the Plan Card.
### Manual install
In GitHub Copilot CLI:
```text
/skills add DUBSOpenHub/copilot-skill-builder
/skills add DUBSOpenHub/dark-factory
```
Then start it with:
```text
copilot skill builder
```
or:
```text
skill builder
```
## Example
```text
skill builder
```
When asked what to build:
```text
Create a helper that summarizes the GitHub issues assigned to me each morning.
```
Copilot Skill Builder shows a short plan:
```text
Your new helper: Morning Issue Digest
Trigger: "morning digest"
What it does: Summarizes GitHub issues assigned to you.
What it uses: GitHub CLI
Where the brief will be saved: generated-skills/morning-issue-digest/BUILD-BRIEF.md
How it gets built: Dark Factory
Where the finished skill goes: your skills repo after the build
```
After approval, Copilot Skill Builder hands the plan to Dark Factory, and Dark
Factory creates the skill files for you.
## Why this exists
Most people do not start by thinking, "I need a skill with this exact YAML and
prompt structure." They start with, "I wish Copilot could help me with this
workflow."
Copilot Skill Builder bridges that gap.
## Built by Dark Factory
Copilot Skill Builder was built with [Dark Factory](https://github.com/DUBSOpenHub/dark-factory), the sealed-envelope Copilot CLI build system.
It also uses the same pattern for users: Copilot Skill Builder shapes the prompt,
then Dark Factory builds the skill through its full line:
```text
Prompt → Plan Card → Dark Factory → Spec → Architecture → Hidden quality checks → Build → Validate → Harden → Skill
```
That means this repo is both a skill builder and a proof point: Dark Factory can
build real Copilot skills end-to-end.
## What it does not do
This MVP does not create dashboards, package managers, hosted services, plugin
systems, or background daemons. It creates prompt-only Copilot CLI skills that
are easy to inspect, install, customize, and delete.
## Validation
Run:
```bash
bash tests/check-skill-builder.sh
```
The validation checks YAML syntax, catalog references, required files, prompt
frontmatter, and line counts.
## License
Released under the [MIT License](LICENSE).
---
## Built with Love
🐙 Created with 💜 by @DUBSOpenHub with the GitHub Copilot CLI.
Let's build! 🚀✨