| name | wick-automate |
| description | Detect when a task is being repeated often enough to be worth automating, then propose the right automation — a PROGRAM (deterministic script) or a SKILL (reusable judgment procedure). Analyzes the current session, the memory/ record, or an observation log; classifies program-vs-skill; estimates payoff; drafts the automation. Proposes, never auto-builds. Use when you catch yourself or the user repeating a multi-step task, or to mine an observation log periodically. |
| license | MIT |
Wick — Automate (spot the repetition, propose the automation)
The efficiency reflex: notice when work is being repeated and turn the repetition into an
automation — so the third time you do a thing is the last time you do it by hand.
Complements /evolve (which graduates logged instincts into skills). This works one level
earlier and broader: it detects task repetition in the work stream and proposes a
program (for mechanical repetition) or a skill (for repeated judgment). The
program-vs-skill call is the whole point.
When to invoke
- You (or the user) just did the same multi-step task a 3rd time.
- Periodically, to mine
memory/.observations.jsonl (if the observer hook is installed) for
frequent command/tool sequences.
- The user says "automate this" / "I keep doing X."
Step 1 — Detect the repetition
Three kinds (structural is the most valuable):
- Literal — the same command/sequence run N times (N≥3). Often just wants an alias.
- Structural — the same shape of task with different inputs: "ship a version" done for
1.1 / 1.2 / 1.3; "onboard a client" done 4×. The variable parts (version, name) become
parameters. This is the high-value target.
- Frictional — a task that's slow, error-prone, or many-step each time: high per-instance
cost even at low frequency.
Sources, in order: the current session's tool-call history → memory/ (decisions,
learning-journal, sessions) → memory/.observations.jsonl (if present) → the user pointing at it.
Step 2 — Decide IF it's worth automating (don't automate reflexively)
Automate only when payoff > cost AND the task is stable.
- Payoff ≈ (frequency × per-instance friction) over a realistic horizon.
- Cost = building it + maintaining it + the risk of ossifying a workflow that's still changing.
- Stability gate (load-bearing): if the task is still being figured out — steps changing
run to run — wait. Premature automation freezes a moving target; that's its own waste.
Automate the settled, not the exploratory.
- Skip the rare, the already-a-one-liner, and the moving target.
Step 3 — Program or Skill? (the classifier)
| The repeated task… | → Program (script/tool) | → Skill (SKILL.md) |
|---|
| Same steps every time, no judgment | ✓ | |
| Needs per-instance reasoning / adaptation | | ✓ |
| Deterministic I/O — files, git, data, builds | ✓ | |
| Reads/writes prose, weighs options, decides | | ✓ |
| High frequency, speed & cost matter | ✓ (no LLM = free + fast + reliable) | |
| Infrequent but complex, benefits from the gates | | ✓ |
- Program = deterministic, cheap to run, reliable — but brittle to change, can't adapt.
- Skill = adapts per instance, carries the gates — but costs tokens each run.
- Both (the mechanical-with-judgment case, often the right answer): a thin skill decides
whether / when / how, and calls a program for the mechanical heavy-lifting. E.g. a
/ship skill that runs a deterministic ship.mjs; or wick-migrate (skill) calling
wick-path-audit (program).
Step 4 — Propose (never auto-build)
Return:
- The pattern — what's repeated, how often, the evidence (cite the instances).
- Verdict — automate now / wait (not stable) / skip (low payoff), with the payoff estimate.
- Program, skill, or both — with the classifier reasoning; name the parameters (the
variable parts abstracted out of the structural repetition).
- A draft — a skeleton
.claude/skills/wick-<name>/SKILL.md or a script stub, ready to
build on approval.
- Gate — build only on explicit approval, then verify the automation on a real instance
(verify behavior, not form) before trusting it.
Cross-session mode (the observation log)
For detection that spans sessions, install the observer (Claude Code): tools/wick-observer.mjs
appends a compact {ts, tool, target} record to memory/.observations.jsonl on each Edit /
Write / Bash via a PostToolUse hook. This skill then mines the log for frequent n-gram
sequences. The log is runtime — keep it gitignored.
{ "hooks": { "PostToolUse": [ { "matcher": "Edit|Write|Bash",
"hooks": [ { "type": "command", "command": "node tools/wick-observer.mjs --post-tool-use" } ] } ] } }
What this will never do
- Auto-build an automation (propose + gate, always).
- Automate a moving target (stability gate) or a low-payoff rarity.
- Recommend a skill where a $0 deterministic program would do — or a brittle script where the
task genuinely needs judgment. Matching the automation to the task is the discipline.
