Skip to content
Skills Library
AI & agents · Tool integration

setup

/setup

Use when the user wants corgi set up end to end: \"set up corgi for me\", \"I just installed corgi, what now\", \"get corgi agent running\", \"connect my phone, Telegram, menu bar\", \"connect Jira, Linear, GitHub to corgi\", \"onboard me to corgi\". Runs every step a program can; lists the manual clicks. NOT for authoring compose or running the stack.

Repository
corgi ↗
Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
5
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when the user wants corgi set up end to end: \"set up corgi for me\", \"I just installed corgi, what now\", \"get corgi agent running\", \"connect my phone, Telegram, menu bar\", \"connect Jira, Linear, GitHub to corgi\", \"onboard me to corgi\". Runs every step a program can; lists the manual clicks. NOT for authoring compose or running the stack.

Triggers from the description

set up corgi for me\I just installed corgi, what now\get corgi agent running\connect my phone, Telegram, menu bar\connect Jira, Linear, GitHub to corgi\onboard me to corgi\
Original author description

Use when the user wants corgi set up end to end: \"set up corgi for me\", \"I just installed corgi, what now\", \"get corgi agent running\", \"connect my phone, Telegram, menu bar\", \"connect Jira, Linear, GitHub to corgi\", \"onboard me to corgi\". Runs every step a program can; lists the manual clicks. NOT for authoring compose or running the stack.

How it works

  1. Guardrails
  2. Steps
  3. The manual checklist (print only what is still open)
  4. Done when
  5. Writing to the tracker
  6. Choosing what runs unattended
  7. Reaching the dashboard
  8. Noise
  9. If they are not in Claude Code
Original SKILL.md headings · 490 lines, 4,124 words
SKILL.md preview
---
name: setup
description: "Use when the user wants corgi set up end to end: \"set up corgi for me\", \"I just installed corgi, what now\", \"get corgi agent running\", \"connect my phone, Telegram, menu bar\", \"connect Jira, Linear, GitHub to corgi\", \"onboard me to corgi\". Runs every step a program can; lists the manual clicks. NOT for authoring compose or running the stack."
---

# Set corgi up, end to end

One pass, from nothing to a phone that can start a session on this laptop.
Every step is idempotent: run the whole thing again and it only fixes what
is missing. Do the automatic steps yourself; collect the manual ones and
print them at the end as a checklist, with the exact command or click.

## Guardrails

- Never paste a token into chat or a commit. Tokens go straight into a
  command flag or the environment. Ask for them once, by name.
- `brew`, `code`, `open`, `gh` are the tools. If one is missing, say so and
  give the install line; do not invent a workaround.
- macOS only for corgi-bar and the Stream Deck plugin; the rest works on
  Linux too. Check `uname -s` before those steps.
- Do not start a Claude session on the user's behalf. The last step is the
  link; the user starts sessions.

## Steps

### 1. The CLI

```bash
command -v corgi || brew install andriiklymiuk/homebrew-tools/corgi
brew trust andriiklymiuk/tools 2>/dev/null || true   # Homebrew 5 asks once; harmless otherwise
corgi update                                          # or corgi upd
corgi doctor                                          # required tools, Docker, ports
```

`corgi doctor --fix --yes` starts Docker and frees ports without asking;
installing a missing tool asks unless `--yes`.

### 2. The workspace

In the project directory:

- No `corgi-compose.yml`? Offer `/corgi-new` (writes one with Claude) or
  `corgi create` (a starter), or `corgi run -l` for an example. Do not go on
  to agent mode without a directory the user actually works in; agent mode
  works in any git repo, compose or not.
- `corgi agent init` registers the directory and enables supervision
  (autostart). `corgi agent init --config-dir ~/.claude-work` for a repo on
  another Claude account. `corgi agent scan ~/dev` registers every stack
  under a folder without enabling them.
- Everything corgi generates lives in **`.corgi/corgi_services/`** beside
  `.corgi/agent.yml`. A checkout with a top-level `corgi_services/` is moved
  there by any corgi command; `corgi migrate` does it out loud (`--dry-run`
  to look first). Nothing moves while services are up - `corgi stop` first.
  Git worktrees under it are repaired, so the source repo still points at
  them. The move also touches `.gitignore` - before committing that, run
  `git check-ignore -v .corgi/corgi_services` - a broader rule already in
  the file (a repo that ignores all of `.corgi/`) covers the new path, and
  the commit would be pure noise.

### 3. The daemon, the endpoint, the tunnel, the QR

```bash
corgi agent up --at-login
```

One command: daemon at login (launchd / systemd), MCP endpoint, a
Cloudflare quick tunnel, a single-use pairing QR, the launcher URL. Print
the QR block and the `or open:` link to the user; that is the link they
asked for. `corgi agent up` again reprints a fresh pairing window; `corgi
agent status --json` has `dashboardUrl`.

**Stable URL** (the quick tunnel changes on every restart and un-pairs the
phone). Pick one, once:

| choice | commands | manual part |
|---|---|---|
| same Wi-Fi, no tunnel | `corgi agent up --http 0.0.0.0:8765 --at-login` | none; phone opens `http://<lan-ip>:8765/app` |
| Cloudflare named tunnel | `brew install cloudflared` · `cloudflared tunnel login` · `corgi agent tunnel setup corgi.yourdomain.com` | a domain on Cloudflare; the login opens a browser |
| ngrok static domain | `brew install ngrok` · `ngrok config add-authtoken <token>` · `corgi agent tunnel setup <name>.ngrok-free.dev --provider ngrok` | free account, copy the dev domain from dashboard.ngrok.com/domains |

After `tunnel setup`, `corgi agent restart` keeps the same URL.

### 4. Session tracking (the board)

```bash
corgi agent track enable          # hooks into ~/.claude and every profile's config dir
corgi agent hooks enable --all    # "needs you" notifications for every registered workspace
corgi agent board --slots 6       # 6 for a Stream Deck Mini, 15 for an MK.2
```

Sessions started before this report on their next event; `corgi agent
rescan` picks up running ones. Run `track enable` again after every `corgi
upd`: a new version can add hooks, and `corgi agent doctor` flags the old
set as "from an older corgi".

### 5. Notifications on the phone

Telegram (free on iOS, unlike ntfy):

1. Ask the user to message **@BotFather**, send `/newbot`, follow it, and
   hand you the token (into the command, not the chat).
2. `corgi agent notify telegram --token <TOKEN>` - checks the token, waits up
   to three minutes for the user to message the bot, reads the chat id,
   writes `notifyUrl`, sends a test. Tell the user to open the bot and send
   it any message when the command says so.
3. The bot then answers commands too: reply to a "needs you" message to type
   into that session, `/sessions`, `/usage`, `/allow`, `/deny`, `/focus`.

Slack, Discord, ntfy: `corgi agent notify set <webhook-url>`; `corgi agent
notify test` sends one. A daily digest: `digestAt: "18:00"` in the user
config, `corgi agent digest --send` to try it.

### 6. The desktop surfaces (macOS)

```bash
code --install-extension Corgi.corgi --force          # VS Code: Agent sessions view, status bar, focus by tab
open "macappstore://apps.apple.com/app/corgi-agents"    # Corgi Agents for Mac: the menu bar + window (not on brew - the app is on the store)
```

Then the person: reload each VS Code window once (`Developer: Reload
Window`), grant corgi-bar **Accessibility** (Talk and typed prompts press
keys) and **Notifications** when macOS asks. corgi-bar turns Launch at login
on by itself the first time it runs from /Applications (its Settings › App
toggle turns it off); `corgi agent up --at-login` opens it once for that.

Two macOS traps `corgi agent doctor` checks: the daemon must run from its own
copy of the binary (`corgi agent install` does this; an older install that
ran Homebrew's path makes macOS ask "corgi wants access to Documents" after
every update), and the menu bar must be running for its login item to exist.

Stream Deck: `gh release download -R Andriiklymiuk/corgi-agent-deck -p
'*.streamDeckPlugin' -D /tmp && open /tmp/*.streamDeckPlugin` installs the
plugin; the person drags **Session** keys, a **Talk** key, a **Prompt** and a
**Budget** key onto the deck.

Voice: in Claude Code run `/voice tap` once; bind `voice:pushToTalk` to
`ctrl+y` in `~/.claude/keybindings.json` (and in each profile's config dir).
The Claude Code panel uses its own `cmd+d`.

### 7. The tracker and code-host watch (optional)

Ask whether they want the daemon to notice things while they are away, and
**offer the list rather than asking an open question** - people answer
"which of these do you use?" far better than "what do you want watched?".
Say it as a menu and take whatever they name:

> corgi can watch these, and you pick the ones you actually use:
>
> - **Linear** or **Jira** - new tickets assigned to you, new comments on them
> - **GitHub** or **GitLab** - reviews and comments on your pull requests, requests to review someone else's, red builds
> - **Slack** - someone naming you or writing to you directly; a channel you want every message of; a code-review channel where pull requests get posted
>
> Which do you use? I only need a token for the ones you name.

Then take only those, in one pass. Do not ask for a token for a service they
did not name, and do not run a second round of questions per service: the
table below has everything each one needs. Get the token into the command,
never into the chat:

| service | where the token comes from | command |
|---|---|---|
| Linear | linear.app → Settings → Security & access → Personal API keys → New key (read is enough) | `corgi agent watch auth linear --token lin_api_…` or `LINEAR_API_KEY` |
| Jira Cloud | id.atlassian.com → Security → API tokens → **Create API token**, the plain one. Not "create with scopes": corgi authenticates with Basic auth (email + token), which a scoped bearer token is not. Plus the site URL and the login email | `corgi agent watch auth jira --url https://you.atlassian.net --email me@x.io --token …` or `JIRA_URL`, `JIRA_EMAIL`, `JIRA_API_TOKEN` |
| GitHub | `gh auth login` is enough (the watch reads the notifications feed through it); or a fine-grained PAT with Notifications read | nothing, or `corgi agent watch auth github --token ghp_…` / `GITHUB_TOKEN` |
| Slack | api.slack.com/apps → your app → OAuth & Permissions → **User Token Scopes**: `search:read`, `channels:history`, `groups:history`, `im:history`, `mpim:history`, `channels:read`, `groups:read`, `im:read`, `mpim:read`, `users:read`, `chat:write`, `reactions:write` → Install to workspace → copy the **User OAuth Token** (`xoxp-`). A bot token (`xoxb-`, scopes `chat:write`, `reactions:write`, `chat:write.public`) is optional and only changes whose name a reply carries | `corgi agent watch auth slack --token xoxp-… [--bot xoxb-…]` or `SLACK_USER_TOKEN`, `SLACK_BOT_TOKEN` |
| GitLab | Preferences → Access tokens → **legacy** token, scope `read_api` only. A fine-grained token is scoped to groups and projects; corgi reads `/api/v4/todos`, which belongs to the user and sits outside that scoping. Self-hosted needs the URL | `corgi agent watch auth gitlab --token glpat-… --url https://gitlab.example.com` or `GITLAB_TOKEN`, `GITLAB_URL` |

Those are the machine-wide tokens: every watched workspace falls back to
them. **A workspace at another company gets its own** - a second Jira site,
a different Linear key, a self-hosted GitLab. Add `--local` inside it (or
`--workspace <id>` from anywhere) and that token beats both the machine-wide
one and the environment:

```bash
cd ~/dev/acme-api
corgi agent watch auth jira --url https://acme.atlassian.net --email me@acme.com --token … --local
corgi agent watch auth gitlab --token glpat-… --url https://gitlab.acme.com --local
corgi agent watch auth linear --clear --local     # drop this workspace's override again
```

Tokens never go into the repository. `--local` writes to the user-level
agent directory, mode 0600, beside the machine-wide ones. `corgi agent
watch` prints one row per workspace holding an override.

Then, in each workspace:

```bash
corgi agent watch enable --tracker jira --project ABC --repos acme/api,acme/web --labels bug,defect --prs
corgi agent watch enable --tracker linear --project ABC --prs --action fix   # also run the fix skill, draft PRs only
corgi agent watch run --dry-run                                      # prove the tokens work: no bookmark moved
corgi agent restart
corgi agent watch                                                    # tokens per workspace, watched workspaces, last polls
```

For Slack, ask two more things and nothing else:

- **"Where do people post pull requests for review?"** → `--review-channel '#code-review'`
- **"Who may set corgi working by mentioning you?"** → `--trust @teammate @reviewer`

The second is a security question wearing a friendly hat: everyone in a
channel can type a mention, so the answer is a list of named people and the
default is nobody. Never suggest a wildcard, and never fill it in from the
channel's membership.

```bash
corgi agent watch enable --mentions --trust @teammate
corgi agent watch enable --review-channel '#code-review' --action fix --auto-for reviews
```

**Always set `--project` and `--repos`.** They are what routes an event to a
workspace - an issue by its key prefix, a PR by its repo. With neither, an
event falls through to the first watched workspace that merely matches the
rules, so a review on one client's PR can start an agent in another's
checkout. `--tracker linear|jira` picks the tracker when both have tokens.

**Never guess either one - read them off the repos.** A key that is one
letter off routes nothing, silently, and looks exactly like a quiet week:

```bash
# the tracker key, from the ids the team already writes
for d in */; do git -C "$d" log --oneline -30; git -C "$d" branch -a; done 2>/dev/null \
  | grep -oE '\b[A-Z][A-Z0-9]{1,9}-[0-9]+\b' | sort | uniq -c | sort -rn | head
# the repo list, from the remotes
for d in */; do git -C "$d" remote get-url origin 2>/dev/null; done \
  | sed -E 's#.*[:/](.+)\.git#\1#' | sort -u | paste -sd, -
```

**What the first round actually does depends on the source.** GitHub sends
`If-Modified-Since` and starts from now. Linear and Jira start from
**24 hours ago** on an empty cursor, so the first poll reports a day of
tickets. Say so before enabling, or the first notification looks like a bug.

**Prove each token is the right person before going further.** A token that
works but belongs to another account sees nothing as "mine", and that looks
exactly like a quiet week:

```bash
corgi agent watch board            # columns · `you <email>` - the tracker's idea of who holds the token
gh auth status                     # the GitHub account the feed reads as
corgi agent watch run --dry-run    # every source polls once, nothing moves
```

If `you` is not the person whose tickets these are, redo `watch auth` with
that person's key (or `--local` for this workspace) before anything else.

**Filter new issues by state, or the backlog arrives every time.** Take the
names from `corgi agent watch board` - it reads the tracker's real columns
(Linear and Jira alike); a state you invented matches nothing. Name only the
**ready** column:

```bash
corgi agent watch enable --states "Ready for dev"
```

With no `--states` the watch takes every open ticket **except the ones in
flight** - In Progress, Code review, QA and the like, which someone already
has (2.30.4). Naming such a column in `--states` takes it anyway, so "In
Progress" belongs there only when the team parks ready work in it. A ticket
a live session is on - its ticket or its branch names it, on this laptop or a
peer - is never picked, whatever the column.

The state filter applies to **new issues only**. Comments on your issues and
reviews on your PRs come through whatever the state is - those are already
about you.

**When something fires that should not have, or does not fire at all**, ask
rather than theorise. It walks routing, rules, dedupe, caps and quiet hours
and prints the gate that stopped it. Nothing runs:

```bash
corgi agent watch test issue.new --ref <KEY>-123
```

**Unattended.** `corgi agent watch enable --auto` is `--action fix --prs
--comments`: it works on what arrives instead of only telling you. Say what
that means before turning it on - it opens draft pull requests on their real
repositories without being asked:

```bash
corgi agent watch enable --auto --quiet 18:00-09:00
```

Draft PRs only, never a merge. One run at a time per ticket, nothing done
twice (an event key is handled once across polls and webhooks), at most
3/hour and 10/day, and nothing above 95% of a usage window (`--limit-ceiling
100` lifts that for a workspace that may spend the account down). `--quiet
HH:MM-HH:MM` closes a window completely: no fix starts **and nothing
buzzes** - what arrived is recorded, shows in the inbox, and is delivered as
one summary when the window opens. A run the daemon was killed in the middle
of is closed on the next start and its event offered again, so a reboot
loses nothing and repeats nothing.

What it did outlives the notification: `corgi agent watch` lists the last
fixes with their pull requests, and so do the phone ("worked on for you")
and the VS Code status bar.

`--action fix` (and so `--auto`) runs unattended only after `corgi agent init
--dangerously-skip-permissions`; say that before enabling it. Suggest quiet
hours at the same time - an unattended agent with no window acts at 3am.

**Turning fix mode on, in order** - each line answers a question the user
will otherwise ask after the first run:

```bash
corgi agent watch board                                   # the columns, read once
corgi agent watch enable --action fix \
  --states "Ready" --pickup "In Progress" --review-status "Code review" \
  --isolate --hand-over --max-per-hour 2 --max-per-day 6 --quiet 17:00-09:00 --days-off sat,sun
corgi agent harden                                        # deny rules for secrets, force-push, reset --hard
corgi agent init --dangerously-skip-permissions           # only after saying what it means
corgi agent restart
corgi agent doctor                                        # no ✗ - `security · <ws>` names the workspace to harden
```

- `--isolate` keeps every run in worktrees of its own; without it a fix
  edits the checkout a person may be typing in.
- `--hand-over` types a review comment, a red build or a colleague's word in
  the review channel into the session already on that branch instead of
  starting a second one.
- `--pickup` / `--review-status` move the ticket as the run goes, so the
  board tells the team what the agent has.
- A post of **your own** in the review channel is never a review for you; a
  reply under it is feedback on your work. A merge waits for the forge's
  approval and green checks (`--auto-merge`), never for a "LGTM" in Slack.
- After every `corgi upd`: `corgi agent restart`, then `corgi agent track
  enable` once more - the hooks live in the Claude config and an upgrade
  can leave them behind.

**Codex as an agent** (`corgi agent init --agents claude,codex`, or `--kind
codex`): Codex has no plugin, so give it the skills - `corgi agent skills
install` copies them into `~/.codex/skills` with the `_shared` files they
read; `corgi agent doctor` reports when that copy is behind, and `install`
again after `corgi upd` brings it up. `corgi agent track enable` wires its
`notify` hook the same way as Claude's.

**Two clients on one laptop**: tokens `--local` per workspace, `--tracker`
and `--repos` set explicitly in each, and a look at `corgi agent watch` to
see one token row per workspace. `corgi agent doctor` and `corgi agent watch
prune --dry-run` are the check for leftovers; `git worktree list` in each
repo shows what prune does not track (a worktree a skill made in /tmp).

**Webhooks** (instant instead of every three minutes): run `corgi agent
watch hooks --install` inside each watched workspace - it creates or updates
the hook on every GitHub and GitLab repo in `--repos` (GitLab needs
Maintainer, GitHub repo admin) and prints what is left by hand. Polling
stays on beside the webhooks as the safety net; a comment from both runs
once. Sources mix freely: GitLab on webhooks while Jira polls is fine. A
named tunnel (step 3) keeps the URLs alive across restarts; with a quick
tunnel they change on every restart, so `--install` again after one. Verify
with a comment on a test MR/PR, then `corgi agent watch status` shows a
`webhook <time>` on that source. What is left by hand goes on the manual
checklist:

- Linear: Settings → API → Webhooks → New: URL `<base>/hooks/linear`, the
  secret, events Issues and Comments.
- GitHub / GitLab: only a repo `--install` reported `✗` for (no admin /
  Maintainer there) - the same settings by hand, as `watch hooks` prints them.
- Jira: Settings → System → WebHooks → Create: URL
  `<base>/hooks/jira?token=<secret>`, events Issue created, Comment created.

### 8. Verify, then hand over

```bash
corgi agent doctor      # every check green: claude binary, daemon, login, trust, tracking, board
corgi agent status      # workspaces online as devices
corgi agent sessions    # the board
corgi agent notify test # the phone buzzes
```

Print, in this order: the launcher link, the pairing QR (or the `or open:`
URL), and the manual checklist that is still open.

## The manual checklist (print only what is still open)

- Scan the QR on the phone (single use, ten minutes; `corgi agent up`
  prints a new one). Save `<url>/app` to the home screen.
- Open the Telegram bot and send it one message while `notify telegram`
  waits.
- Cloudflare: `cloudflared tunnel login` opens a browser. ngrok: copy the
  authtoken and the dev domain from the dashboard.
- macOS dialogs: Accessibility and Notifications for corgi-bar (and for the
  Stream Deck app if Talk should work from the deck); Docker if doctor
  started it for the first time.
- Reload each VS Code window once.
- Drag keys onto the Stream Deck.
- `/voice tap` and the `ctrl+y` binding inside Claude Code.
- Trust: run `claude` once in each workspace and accept the trust dialog,
  or `corgi agent doctor` keeps saying `trust · <id>`.
- Tokens for the watch: Linear API key, Jira API token, `gh auth login`,
  GitLab access token (table in step 7). Webhook entries in each service,
  from `corgi agent watch hooks`.

## Done when

- `corgi agent doctor` has no ✗.
- `corgi agent status` lists the workspace online.
- `corgi agent watch board` says `you <the right person>` in every watched
  workspace, and `watch run --dry-run` polled every source without an error.
- The user has the launcher link and, if they wanted it, got a test
  notification on the phone.
- The remaining manual steps are listed, each with its command or click.

## Writing to the tracker

`corgi agent watch board --refresh` first, always. It reads the workspace's real
columns once and caches them; a column name you guessed is refused, and Jira also
decides which moves are legal from where the ticket currently sits, so a refused
move names the ones that were.

- `--pickup "In Progress"` moves a ticket when someone picks it up - from the
  phone's **Work on it** and from an unattended run. Unset writes nothing, which
  is the default: no existing setup starts changing a board it was not asked to.
- `corgi agent watch undo [REF]` closes what a run opened and puts the ticket
  back. `--dry-run` says what it would do. The branch is left alone: it holds the
  work, and deleting it is the part that cannot be undone in turn.

## Choosing what runs unattended

`--action fix` alone means every kind the rules match, including a fresh ticket,
which is the one with no test for "done". Split it:

```bash
corgi agent watch enable --action fix --auto-for reviews,comments
corgi agent watch enable --action fix --auto-for ci
```

- **reviews / comments** - a known, already-scoped change. The safest to hand over.
- **ci** - needs `--ci` to arrive at all. A red build is the best unattended
  target there is: a precise signal and a pass condition nobody can argue with.
- **tickets** - a blank page. Leave it reporting until the rest has earned trust.
- **requests** - someone else's pull request. It needs `--reviews` to arrive at
  all, and corgi posts a review rather than pushing to their branch. Almost
  never belongs in `--auto-for`.

Two more flags belong with a ticket workflow:

- `--review-status "In Review"` moves the ticket again once a run opened a pull
  request, and posts the link on it. Without it a board full of "In Progress"
  is a board of finished work nobody has looked at.
- `--lease` claims the ticket on the tracker first, so a second machine
  watching the same board leaves it alone. Only worth it with two machines.

Before turning any of it on, and after:

```bash
corgi agent watch replay --since 168h      # the week it would have had
corgi agent watch replay --auto-for ci     # try a setting without saving it
corgi agent while-away                     # the morning card
corgi agent watch undo ABC-1 --dry-run     # close what it opened, ticket back
```

A kind that was not named is reported, not worked, and `corgi agent watch test`
answers `notify` for it, so the split is visible before an event arrives.

## Reaching the dashboard

The phone pairs by scanning the QR `corgi agent up` prints. A browser on the
machine running the daemon needs no code - anything that can run the command
can already read the daemon's files:

```bash
corgi agent dashboard          # opens it and authorises this browser
corgi agent dashboard --print  # the link, refused into a pipe or --json
```

It is a real device with a name: `corgi mcp devices list` shows it,
`corgi mcp devices revoke this-laptop` takes it away.

## Noise

- `--from max` narrows comments and reviews to the people you are actually
  waiting on, across every repo. The rules are otherwise shaped like a board.
- Tickets closed as duplicate, cancelled, won't do, not planned, rejected or
  obsolete are skipped with the reason said out loud - unless `--states` names
  that column, because asking for it means you meant it.
- Several comments on one pull request collapse to one per poll.
- `--quiet 17:00-09:00` holds notifications as well as fixes, and delivers one
  summary when the window opens. It applies to a reporting watch too.

## If they are not in Claude Code

Codex, Cursor, Cline, Droid, an in-house agent - do not tell them corgi has
no plugin for their tool. The skills are plain Markdown in the repository and
the `skills` CLI installs them anywhere:

```bash
npx skills add Andriiklymiuk/corgi
```

Then say which skills matter for what they actually do, rather than listing
all of them. The frontmatter must stay valid YAML for this to work: a
`description` containing a colon has to be quoted, or a strict parser skips
that skill silently while Claude Code goes on reading it fine.

Versions

RepositoryScoreLicence
This page · andriiklymiuk/corgi100MIT
HwangSlater/harness-fit100MIT
nesquikm/dev-process-toolkit100MIT
userKael/rastro100MIT
als-apg/osprey100BSD-3-Clause
dedujeong/gemba100Apache-2.0
eigenwise/eigenwise-toolshed100MIT
awrshift/agent-memory-kit100MIT
lifecycle-innovations-limited/claude-ops100MIT

Database snapshot: 13.11.2026 · package version 9173064ff93e (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95corgi
    Author and explain corgi-compose.yml files and the corgi CLI. Use when writing or editing a corgi-compose.yml, picking db drivers, healthchecks or tunnels, or explaining corgi concepts, commands, and flags. Corgi is a Go CLI that starts databases, services, and required tools…
  • 100ci
    Use when the user wants the corgi stack in CI or end-to-end tests across repos: \"set up CI for this workspace\", \"wire this up to GitHub Actions/GitLab CI\", \"run the stack in CI\", \"full-stack e2e on the PR\", \"each repo's CI passes but the combination breaks\". NOT for…
  • 86telegram-connect
    Set up Telegram as a notification center for your Egregore — creates the group, links the bot, and stores the chat ID. Use for /telegram-connect, ''connect telegram'', or ''set up telegram notifications''.
  • 95setup-telegram-bridge
    How the Telegram bridge is installed and configured on this machine, so it can be reproduced on Vinny's InstaBox Pi coding agent. Use when he says "set up telegram on the box", "connect telegram on instabox", "same telegram setup on the cloud pi", "make the box's pi talk to…
  • 90hive.telegram-notifications-setup
    Set up a Telegram notification channel (Sentinel) for a colony by driving the browser — create a bot via @BotFather in Telegram Web, store its token, detect the chat to notify, and turn Sentinel on so the colony can ping the user on Telegram and accept replies. Use when the user…
  • 100tool-connector
    Connect any tool you use at work to your agent — including internal company tools, custom-built systems, deployment portals, incident trackers, internal knowledge bases, HR systems, and commercial tools like Slack, Confluence, Jira, Linear, GitHub, Outlook, Datadog, and…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.