Bennyoooo/skillmaxxing

# create-skill

Crystallize a workflow into a durable, tested skill. The CLI is model-agnostic: **you** synthesize the content (name, body, scripts, real eval tasks); the CLI stages, smoke-tests, and commits it atomically.

## Two entry points

1. **Explicit** — the user says "turn X into a skill."
2. **Reflection** — after completing a non-trivial task, consider whether it is reusable. Fire this **sparingly** (review fatigue is real): only when the work was non-trivial (several steps, a fixed bug, a discovered workflow) AND plausibly recurs. When in doubt, don't interrupt.

## Step 0 — Prefer update over create

Before creating, search for an existing skill that already covers this:

```bash

# discover-skill

Discover skills from public sources and install the right one. This skill orchestrates the model-agnostic `skill-maxing` CLI — the CLI does the deterministic ranking and installing; you handle the conversation and the choice.

## When to use

- The user explicitly asks to find/search/discover a skill.
- You are about to do a task that a reusable skill would likely cover — search first before reinventing (retrieval-augmented execution).

## Steps

1. **Clarify intent.** Turn the user's need into a short query (e.g., "code review", "release notes", "postgres migrations").

2. **Search.** Run discovery and read the ranked results:

# optimize-skill

Make a skill measurably better without uncontrolled drift. This is an **agent-in-the-loop** loop, not a hands-off run: the CLI owns the deterministic machinery (scoring, edit budget, rejected-edit buffer, the gate, atomic promote/revert); **you** own the reasoning (running the skill, judging prose outputs, proposing edits). Expect several turns per optimization.

## Preconditions

- The skill has an eval manifest (`eval.yaml`) with real tasks. If it has none, stop and offer to create one (`create-skill`) — optimization cannot run without an eval set.
- Optimization edits a **managed copy**, never the installed symlink target.

## The loop (repeat until the gate stops improving)

1. **Rollout.** For each eval task `input`, run the current skill yourself and collect its output. Write `rollouts.json`: `[{ "taskId": "...", "output": "..." }]`.

2. **Score.**

# workspace-skill

Operate the team workspace registry. The registry is **just a git repo** the team pushes/pulls — no server. The CLI handles publish/sync/pool/promote; you handle the conversation and the review.

## Publish

```bash
scripts/workspace.sh publish --registry <dir> --skill-dir <dir> --channel dev --by "<name>"
```

New work goes to `dev` first. After publishing, remind the user to **commit and push** the registry repo so teammates can sync.

## Sync