Skip to content

Junhanliu-dev/espalier-engineering / skills/espalier-init

espalier-init

Verified

Analyze any existing codebase, discover its patterns and best practices, and generate an Espalier structure (rules, skills, wiki, pipeline) so AI coders produce code matching that project's language and conventions. Greenfield repos take the two-pass Decide-Then-Bind path (/espalier-map charts the conventions, init binds them); boilerplate repos run init normally, then map the product. Wires into Claude Code, Codex, and/or GitHub Copilot (.claude/, .agents/skills/ + .codex/, .github/).

FileKindSize
SKILL.mdskill md43.5 KB
hook-templates/check-layer-boundaries-go.shscript665 B
hook-templates/check-layer-boundaries-python.shscript821 B
hook-templates/check-layer-boundaries-typescript.shscript1.6 KB
hook-templates/copilot-hook-adapter.shscript2.4 KB
hook-templates/drift-detect.shscript5.7 KB
hook-templates/drift-helpers.shscript56.4 KB
hook-templates/espalier-outside.shexecutablescript28.8 KB
hook-templates/espalier-pr.shexecutablescript43.2 KB
hook-templates/espalier-stats.shexecutablescript27.3 KB
hook-templates/lookup-helpers.shscript9.5 KB
hook-templates/map-guard.shexecutablescript3.9 KB
hook-templates/maprun-dispatch.shexecutablescript21.0 KB
hook-templates/maprun-integration.shexecutablescript3.4 KB
hook-templates/maprun-merge.shexecutablescript2.9 KB
hook-templates/maprun-pr.shexecutablescript12.8 KB
hook-templates/maprun-verify.shexecutablescript5.0 KB
hook-templates/maprun.pyscript65.6 KB
hook-templates/parse-drift-blocks.pyscript1.1 KB
hook-templates/post-edit-wrapper.shscript2.0 KB
hook-templates/post-merge-backlink.shscript2.2 KB
hook-templates/pre-push-gate-wrapper.shscript3.0 KB
hook-templates/pre-push-gate.shscript18.1 KB
hook-templates/rebuild-commit-index.shscript2.6 KB
references/discovery-checklist.mdmarkdown18.5 KB
references/validation.mdmarkdown16.7 KB
references/wiki-templates.mdmarkdown710 B
references/wiring.mdmarkdown13.5 KB
templates/agent.mdmarkdown3.7 KB
templates/agents/harness-coder.mdmarkdown33.9 KB
templates/agents/harness-reviewer.mdmarkdown25.1 KB
templates/agents/harness-security.mdmarkdown14.0 KB
templates/agents/modes/fix-round.mdmarkdown3.0 KB
templates/agents/modes/re-review.mdmarkdown5.3 KB
templates/agents/modes/repo-audit.mdmarkdown2.8 KB
templates/agents/modes/simplification.mdmarkdown7.0 KB
templates/agents/modes/stage6-abuse-coverage.mdmarkdown1.3 KB
templates/agents/modes/wiki-sweep.mdmarkdown5.6 KB
templates/pipeline.mdmarkdown18.9 KB
templates/rules/coding-standards.mdmarkdown3.2 KB
templates/rules/development-process.mdmarkdown3.2 KB
templates/rules/engineering-structure.mdmarkdown1008 B
templates/rules/production-standards.mdmarkdown5.8 KB
templates/rules/security-standards.mdmarkdown5.6 KB
templates/scout-prompts.mdmarkdown9.0 KB
templates/skills/espalier-ask.mdmarkdown6.4 KB
templates/skills/espalier-audit.mdmarkdown10.0 KB
templates/skills/espalier-coding-references/platform-native.mdmarkdown9.4 KB
templates/skills/espalier-coding-spec.mdmarkdown496 B
templates/skills/espalier-coding.mdmarkdown4.0 KB
templates/skills/espalier-doctor.mdmarkdown8.0 KB
templates/skills/espalier-fix.mdmarkdown77.5 KB
templates/skills/espalier-grill.mdmarkdown21.5 KB
templates/skills/espalier-map.mdmarkdown20.0 KB
templates/skills/espalier-maprun.mdmarkdown31.1 KB
templates/skills/espalier-prune.mdmarkdown13.0 KB
templates/skills/espalier-repot.mdmarkdown7.6 KB
templates/skills/espalier-requirements.mdmarkdown4.7 KB
templates/skills/espalier-review.mdmarkdown4.5 KB
templates/skills/espalier-security.mdmarkdown5.6 KB
templates/skills/espalier-simplify.mdmarkdown25.0 KB
templates/skills/espalier-stages/1-2-requirements.mdmarkdown7.6 KB
templates/skills/espalier-stages/3-coding.mdmarkdown15.0 KB
templates/skills/espalier-stages/4-panel.mdmarkdown14.3 KB
templates/skills/espalier-stages/5-6-contract.mdmarkdown10.3 KB
templates/skills/espalier-stages/7-10-delivery.mdmarkdown16.8 KB
templates/skills/espalier-stages/simple.mdmarkdown14.0 KB
templates/skills/espalier-testing.mdmarkdown2.9 KB
templates/skills/espalier.mdmarkdown27.7 KB

templates/skills/espalier-grill.md

View on GitHub
---
name: espalier-grill
description: Internal pipeline stage — invoked by /espalier and /espalier-fix Stage 1 (and by /espalier-map for decision tickets) with a mode and reqs_path; not for direct user invocation. Stress-test a requirement (spec), a bug diagnosis, or an open decision before coding — adaptive sequential interrogation that surfaces ambiguity, false premises, missing edge cases, and collisions with the project's own rules/wiki conventions
---

# Espalier Grill

## Purpose

Interrogate the Stage 1 input before any code is written. A vague requirement or an
unconfirmed diagnosis that passes Stage 1 is trusted by every later stage — and no
later gate audits it. Grill is that audit: it converts an under-specified input into
one a coding agent can execute without guessing.

Grill also closes the one blind spot a bare reading cannot: a requirement that violates
a convention in `espalier/rules/` or re-implements what `espalier/wiki/` documents —
known to the repo, unknown to the requester. Step 1.5 cross-references the input against
the project map and turns that collision into a question before any code is written.

Grill is invoked BY Stage 1 of `/espalier` and `/espalier-fix`, and by
`/espalier-map` when resolving a grilling ticket. It is not a slash command and
is never called directly by the user.

## Inputs (passed by the invoking stage)

| Input | Values |
|-------|--------|
| `mode` | `spec` (from `/espalier`) — interrogates the requirement |
| | `diagnosis` (from `/espalier-fix`) — interrogates the bug's root cause |
| | `decision` (from `/espalier-map`) — settles an open decision ticket |
| | `score` (from `/espalier-map` handoff) — Step 1 signal count only; no interrogation, no writes |
| `input_text` | the requirement, bug description, or ticket question (+ map context) |
| `reqs_path` | path to the change's `requirements.md` (spec/diagnosis) or the ticket file (decision) |
| `familiarity` | optional — `low` when the requester SAID this area is new to them ("I don't know the auth module", "never touched this"); otherwise unset. Never inferred. |

### Decision-mode deltas (`mode=decision`)

A decision ticket inverts grill's usual input: the QUESTION arrives sharp (the
map already stated it precisely — that is what made it a ticket), and the
ambiguity lives in the answer space. Everything below applies with these deltas:

- **Step 1 (tiering):** skip the signal count — a decision ticket is never
  `skip`-crisp (an already-settled question would not be a ticket). Default
  tier `light` (≤ 3 questions); the user's read of the stakes bumps to `full`.
- **Step 1.5:** runs unchanged, against the CANDIDATE ANSWERS: before locking
  a decision, cross-check the leading candidates against `espalier/rules/` and
  `espalier/wiki/` — a candidate that collides with an encoded convention is
  surfaced as a citation-carrying question before it can win. Empty rules/wiki
  (greenfield Pass 1) → skip silently, per the existing contract.
- **Step 2:** the divergent-interpretations technique becomes divergent
  CANDIDATES: privately list 3–5 concrete, divergent answers to the ticket,
  ask the question that eliminates the most. Sequential, HITL — never answer
  the ticket yourself.
- **Step 3:** resolved decisions land in the ticket file's `## Resolution` —
  the answer, its rationale, citations from Step 1.5 — plus a one-line gist
  the caller appends to the map's Decisions-so-far. A non-answer records the
  conservative default in `## Resolution` marked `(default — revisit)`.
- **Verdict:** `GRILLED (light)` / `GRILLED (full)` or
  `SKIPPED: non-interactive` only.

### Score-only mode (`mode=score`)

The map lane's CLEARED → FILED handoff calls this to score each drafted slice
requirement BEFORE filing it. Run Step 1's signal count against `input_text`
(the drafted slice requirement) — nothing else: no Step 1.5, no questions, no
file writes. Return ONE line to the caller: `SCORE: {skip|light|full}
(signals={N})`. The handoff files `skip`/`light` slices and refuses
would-be-`full` ones (the map is not actually clear there). This mode records
no verdict in pipeline-state.md — no change exists yet.

## Process

Run Steps 0–3 in order (Step 1.5 sits between Step 1 and Step 2).

### Step 0 — Environment check

Decide whether a human can answer a grill question. Do NOT use a bare `[ -t 0 ]`
TTY test — inside Claude Code stdin has no TTY even when a user is right there,
so that test would skip the grill in normal interactive use (the bug this
closes). Use the explicit-signal helper instead:

```bash
. espalier/hooks/drift-helpers.sh
interactivity_mode        # -> "interactive" | "unattended"
```

Only an EXPLICIT unattended signal (`CI`, `ESPALIER_UNATTENDED`, `ESPALIER_LOOP`,
`ESPALIER_HEADLESS`) returns `unattended` — then do NOT grill (a question would
hang an unattended pipeline); return the verdict `SKIPPED: non-interactive`.
Otherwise you are interactive: grill normally. The real authority is the
orchestrator — if it can call `AskUserQuestion`, it is interactive regardless;
this check only governs the auto-skip for genuinely headless runs.

### Step 1 — Score ambiguity, choose depth

Do not judge ambiguity by feel. Count concrete ambiguity **signals** in `input_text`:

| Signal | Example |
|--------|---------|
| Undefined / overloaded term | "archive the order" — soft-delete? export? |
| Unstated actor or system | "send a notification" — to whom, over what channel? |
| Missing failure / error behaviour | nothing said about what happens when it fails |
| Hidden quantifier | "fast", "some", "large", "soon" — unmeasured |
| Unscoped edge case | the input describes only the happy path |
| Over-specified mechanism | the input names HOW where the WHAT is met by a documented capability, stdlib / a native feature, or nothing at all — "add a caching layer for X" when X is read once per process |
| (diagnosis) Unconfirmed cause | the cause is asserted, not evidenced |
| (diagnosis) Weak reproduction | "sometimes fails" — no exact, repeatable steps |
| Rule collision | the requirement's approach contradicts an `espalier/rules/` convention |
| Wiki duplication | the requirement re-implements a capability `espalier/wiki/` documents |
| Unstated ripple | the requirement touches a documented critical-path / data-model with unstated downstream |
| Requester unfamiliar | `familiarity: low` was passed — the requester said this area is new to them |

Rule collision, wiki duplication, and unstated ripple are not in `input_text` — they
surface only by cross-referencing the project's own map, which **Step 1.5** does. A
collision confirmed there counts as a signal and floors the tier at `light` (Step
1.5). Requester unfamiliar is the one signal the requester supplies about
themselves: it counts, floors the tier at `light`, and turns on **Step 1.6** — a
requester who does not know the area cannot name what they have not considered,
so the map is read to them before they are asked. Count the text signals now; let
Step 1.5 add any collision signals before you commit to a tier.

Map the count to a depth tier:

| Signals | Tier | Action |
|---------|------|--------|
| 0–1 | `skip` | Confirm understanding in one line. Return `SKIPPED: crisp`. Steps 2–3 do not run. |
| 2–4 | `light` | Ask ≤ 3 questions. |
| 5+ | `full` | Ask ≤ 7 questions. |

Tier anchors (calibrate against these):
- `skip` — "feat: bump the copyright year to 2026"
- `light` — "feat: add a CSV export button to the reports page"
- `full` — "make the dashboard faster and handle errors better"

State the chosen tier to the user in one line ("Well-specified — confirming, not
grilling") so a misjudgment is visible and they can correct it. If the user pushes
back on the tier ("this is more involved than that" / "don't bother grilling"), adopt
their tier and proceed — their read of the requirement's stakes overrides the signal
count. A `skip`→`light`/`full` bump runs Step 2; a bump down to `skip` returns
`SKIPPED: crisp`.

### Step 1.5 — Blind-spot pass (convention cross-check)

Runs in both modes, after Step 1, before Step 2. Its job is the collision the requester
could not have flagged — a rule they don't know exists, a capability the wiki already
documents — which no text-signal count in Step 1 can catch.

Read the project map — NOT source code:
- `espalier/rules/*.md` — the encoded conventions.
- `espalier/wiki/*.md` — architecture, data-models, critical-paths, external-services.

**If neither directory exists or both are empty, skip this step silently** — there is
nothing to cross-check (e.g. a repo not yet initialised by `/espalier-init`). No signal,
no tier change, no output.

Scan for three collision classes (the last three rows of Step 1's signal table):

| Class | You are looking for |
|-------|---------------------|
| Rule collision | the requirement's implied approach contradicts a `rules/` convention (e.g. `throw` where coding-standards mandates `Result<T>`) |
| Wiki duplication | the requirement re-implements a capability `wiki/` already documents (e.g. a new HTTP client where `external-services.md` documents one) |
| Unstated ripple | the requirement touches a `wiki/` critical-path or data-model whose documented downstream is not in the requirement (e.g. "add a field to Order" when `critical-paths.md` shows Order feeding three consumers) |

Reading `rules/`/`wiki/` is always allowed — they are the curated map, and consulting
them is the whole point. Scope wiki reads to the requirement's surface; skim rules.

**Verify before you raise it.** A doc can be stale. Before treating a collision as real,
confirm the cited convention still holds in the current code (read it — there is no
read count). If the doc contradicts the code, do not raise a false collision —
flag the doc as drifted instead, with the same helper `/espalier-ask` uses:

```bash
. espalier/hooks/drift-helpers.sh
mark_stale "espalier/<rules|wiki>/<file>.md" "$(git rev-parse HEAD)" "grill-verify: <one-line mismatch>"
```

Then move on — a stale doc is not a collision.

**What a confirmed collision does:**
- **Becomes a Step 2 question** — the sharpest kind, because it carries a concrete fork
  and a citation: *"Requirement implies X; `rules/coding-standards.md#error-handling`
  says this repo returns `Result<T>` — reconcile to `Result<T>`, or is `throw` intended
  here (and why)?"* Always cite the exact `rules/<file>#section` or `wiki/<file>#section`.
- **Floors the tier at `light`.** A `skip`-scored requirement (0–1 text signals) that
  nonetheless collides must not skip — the collision is exactly the hidden default grill
  exists to catch. `skip` + ≥ 1 confirmed collision → run Step 2 for the collisions alone.

**Scope guard.** Surface collisions with conventions that already exist in `rules/`/`wiki/`
only. Never propose new designs, generate alternatives, or brainstorm — that is not
grill's job, and it would fight the point of encoding conventions. Zero collisions → add
nothing and stay silent.

### Step 1.6 — Requester brief (the requester's unknown unknowns)

Runs after Step 1.5, before Step 2, when `familiarity: low` was passed OR the tier
is `full`. Step 1.5 catches what the repo knows and the requester does not; this
step tells the requester what they could not have asked about. It reads the same
map — `espalier/rules/`, `espalier/wiki/`, and the layer specs under
`espalier/skills/espalier-coding/specs/` for the layers the requirement touches —
and prints ONE short brief before the first question, at most seven lines, each
a fact with its citation:

- what this area already decides that the requirement does not mention (the
  documented data model the change joins, the critical path it sits on, the
  convention that fixes the shape — `wiki/<file>#section`, `rules/<file>#section`,
  `specs/<layer>.md § section`);
- what "good" looks like here — the reference pattern the layer spec names;
- the one thing a newcomer to this area most often gets wrong, when a rule or
  wiki page records it.

The brief explains; it never proposes. No design, no alternatives, no "you could
also" — the Step 1.5 scope guard applies word for word. A line without a
citation is not a line. Empty `rules/` and `wiki/` → skip silently, as Step 1.5.
The brief lands in `requirements-notes.md` under `## Requester brief` (Step 3);
the questions that follow assume it was read.

### Step 2 — Grill loop (tiers `light` and `full`)

Ask questions **sequentially** — one question, wait for the answer, let the answer
shape the next. Batching is allowed in exactly one case: tier `light`, AND the
remaining planned questions are pairwise INDEPENDENT — no possible answer to one
could eliminate, reorder, or rephrase another. Then ask them together in ONE
`AskUserQuestion` call (still ≤ 3 total), saving the user a round-trip per
question. When independence is in any doubt, sequential. `full`-tier grills stay
strictly sequential — at that ambiguity level the discriminating question almost
always depends on the last answer, and a batched checklist is exactly the
failure mode the tier exists to prevent. Decision mode (`/espalier-map`) stays
sequential too — candidate-elimination questions are inherently dependent.

**Before each question**, privately list 3–5 concrete, *divergent* ways the input
could still be built (`spec`) or explained (`diagnosis`). Ask the question whose
answer **eliminates the most of them**. This produces a sharp, non-obvious question
instead of a generic one.

> Example. "add export" → interpretations: {CSV of the current page, sync · CSV of
> the full dataset, async job · XLSX · JSON endpoint}. The discriminating question is
> "CSV of the current page, or the full dataset as an async job?" — not the generic
> "what format do you want?".

At tier `full`, and whenever Step 1.6 ran, the list is NOT private: show it with
the first question — one line per candidate build, then the question that
eliminates most. The requester reacts to shapes they would not have named; the
question still does the eliminating, and the cap is unchanged. At tier `light`
the list stays private (the input is near-crisp; showing it would add reading,
not information).

When the candidates differ in APPROACH — not detail — and the requester cannot
choose ("not sure", "either"), do not choose for them: record `approach: {the
candidates}` under `## Open Questions` in requirements.md with the conservative
candidate named as the default, and print ONE line — `approach undecided: a
/espalier-map prototype or research ticket settles what talking cannot`. The
requirement still proceeds to the approval gate, where the human sees the default
and decides; grill never brainstorms past this point.

Rules for the loop:
- **Answer from the codebase first.** If a question is answerable by reading the code
  (does helper X exist? what does the current cancel flow do?), read it — do not ask
  the user. Read as much of the code as answering the question needs — there is no
  count. Ask the user only for what the code cannot answer: product intent,
  priorities, an unratified decision. A verified premise handed to the coder in
  `requirements.md` and the pack's "Facts established" is worth more than a saved
  read. (Every read lands in the orchestrator's own context — Stage 1 runs in the
  main session; the approval gate's fresh-session offer is what releases them.)
- **Verify premises.** When the input assumes current behaviour ("extend the existing
  X", "the bug is in Y"), check the code and surface any contradiction immediately.
- **Over-specified mechanism.** When the input names a mechanism (a cache class, a
  new picker library, a config surface) and the map (Step 1.5), the layer specs, or
  the platform meets the same outcome, ask ONE question that offers the covering
  alternative with its citation. The requester's choice stands: a kept mechanism
  is an Acceptance Criteria line, never re-argued downstream — the coder's ladder
  trims only what the contract never asked for.
- **By mode** — `spec`: probe scope (in / out), false premises, edge cases, vague
  terms. `diagnosis`: probe the root cause (symptom vs. cause?), the reproduction,
  and whether the stated "expected behaviour" is actually correct.
- **Cover every counted signal.** Each ambiguity signal you counted in Step 1 must end
  either resolved by an answer or consciously ruled out of scope. Stop-early (below)
  applies only to questions *beyond* the counted signals — never leave a signal you
  counted unaddressed, because that is exactly the ambiguity grill exists to catch.
- **Handle a non-answer.** If the user replies "I don't know" / defers, do not silently
  drop the point: record it under `## Open Questions` in `requirements.md`, pick the
  safest default, and name that default. An invisible unresolved signal defeats the audit.
- **Stop early.** Stop the moment the next question's answer would not change the
  implementation — even before the tier cap (but after every counted signal is covered).

### Step 3 — Write the resolved input back

Write every resolved decision into `requirements.md` inline, as it is resolved — not
batched at the end. The contract file carries the DECISION, one clause in the
criterion or scope line it resolves; the full question and answer go to
`requirements-notes.md` beside it under `## Resolved by grill` (create the file
on first write; link it once from the Requirement Summary as
`Notes: requirements-notes.md`). Convention Notes stay in the contract.

| Mode | Where |
|------|-------|
| `spec` | concrete `## Acceptance Criteria` entries + explicit `## Scope Definition` in / out lines |
| `diagnosis` | populate `## Root Cause`; sharpen `## Reproduction` into exact, repeatable steps |

A **resolved collision** (Step 1.5) lands the same way, carrying its citation:

| Collision resolved to | Lands as |
|-----------------------|----------|
| follow the convention | a `## Acceptance Criteria` line naming it ("errors returned as `Result<T>` per `rules/coding-standards.md`") |
| reuse the existing capability | a `## Scope Definition` out-line ("reuse the documented `PaymentClient`; do not add a new HTTP client") |
| over-specified mechanism resolved | a `## Scope Definition` out-line naming what covers it ("no cache class; memoize `loadSettings()` — revisit when settings change at runtime"), or an `## Acceptance Criteria` line when the requester keeps the mechanism |
| intentional deviation | a `## Acceptance Criteria` line + one line of *why* the convention is overridden |
| unresolved (non-answer / unattended) | an `## Open Questions` entry with the cited path + a conservative default |

When Step 1.5 ran, add a short `## Convention Notes` block to `requirements.md` listing
each `rules/`/`wiki/` path consulted and the collision verdict (raised / cleared / doc
flagged stale) — so the audit trail shows the cross-check ran even when it found nothing.
When Step 1.6 ran, its brief goes to `requirements-notes.md` under `## Requester
brief`, verbatim — the contract file carries decisions, not explanations.

Every grilled decision must land as a verifiable line. Never leave a resolution only
in the conversation.

**Coverage guard (before returning `GRILLED`).** Re-read the Step 1 signal list. Every
signal you counted must now appear in `requirements.md` as a resolved criterion, a
scope-out line, or an `## Open Questions` entry. A counted signal with no written trace
is a coverage miss — ask it now (within the tier cap) or record it under
`## Open Questions` in requirements.md with a chosen conservative default and one
line of why (the same convention as the user-non-answer rule above) — the record
option is allowed ONLY when the tier's question cap is exhausted; never exceed
the cap. Then return.

## Verdict

Return ONE verdict to the invoking stage — it records this in `pipeline-state.md`:

| Verdict | When |
|---------|------|
| `GRILLED (light)` / `GRILLED (full)` | grill ran; the tier word is the tier that actually ran (after any Step 1.5 floor or user bump); `requirements.md` (or the decision ticket) updated |
| `SKIPPED: crisp` | spec/diagnosis only — tier was `skip`, input already well-specified, **and** Step 1.5 confirmed zero collisions. A crisp input that collides with a rule/wiki convention returns `GRILLED`, not this. Decision mode never returns it. |
| `SKIPPED: non-interactive` | unattended run (Step 0's interactivity_mode check) |
| `SKIPPED: --no-grill` | spec/diagnosis only — the invoking stage passed the opt-out flag |

## Anti-Patterns

- NEVER ask a question the codebase already answers.
- NEVER re-ask something already answered or inferable from a prior answer.
- NEVER ask a generic question ("what about edge cases?") — name the specific case.
- NEVER exceed the tier's question cap, or grill past the point where answers stop
  changing the implementation.
- NEVER leave a resolved decision only in the chat — it must be written to
  `requirements.md`.
- NEVER batch dependent questions — batching is legal only for pairwise-independent
  `light`-tier questions (Step 2); when unsure, sequential.
- NEVER raise a collision (Step 1.5) without first verifying the cited `rules/`/`wiki/`
  claim against the current code — a stale doc gets `mark_stale`, not a question.
- NEVER brainstorm new designs or generate alternatives in Step 1.5 — it surfaces
  collisions with conventions that already exist in `rules/`/`wiki/`, nothing more.
- NEVER turn the Step 1.6 brief into a proposal — it explains what the map already
  decides, every line cited; the candidate list shown at `full` tier is the
  requester's to react to, never a recommendation.
- NEVER pass `familiarity: low` on your own read of the requester — only their words.
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall