OR Key
drop another .md file to compare - side-by-side diff against snappy-https

snappy-https

Lets your assistant open links, images, and files you share into chat.
personal 2 files

What it does for you

Lets your assistant open links, images, and files you share into chat.

What it produces

A recent result, so you can see the kind of work it returns.

loading…

How to get it

These run inside the Snappy workspace. Want this working in your business? I set skills like this up with you, in one focused week.

Work with me
For developers how this skill is built, graded, and how it runs

at a glance- the short version

actorThing that
auditorThing that judges (must be different - see CONSTITUTION
eval modeauto-shape
categoryUtility
stages4

what's inside - the parts that make up a skill 3/4 present

A skill is just a few plain-text files. Only the main one is required. The rest are optional, added as the work needs them. This is what the skill is made of; how it runs is just below.

The skill
state/skills/snappy-https/SKILL.md present
the skill itself, in plain text
The main file. It says what the skill is and lays out the steps in plain English.
Code
state/skills/snappy-https/api.ts present
code the skill can run
Reusable code this skill can call when it needs to.
Scripts
state/bin/snappy-https/ not present
helper scripts
Optional. Added when a skill has a few commands to run.
Loader
state/skills/snappy-https/AGENTS.md present
what the AI loads on the fly
Loaded automatically the moment this skill is needed. Kept short on purpose.

how it runs - the shared frame every skill uses 5/5 present

Every skill runs the same way. One part does the work, a separate part checks it, and a short loader hands the AI exactly what it needs for the job. Anything this skill doesn't use shows a one-line note saying why, on purpose, not by accident.

makes the work The worker
present
Thing that the worker
Does the actual work. Whatever it produces is what gets checked next.
checks the work The reviewer
present
Thing that judges (must be different - see CONSTITUTION the checker
A separate checker grades the work, so the part that made it can't approve its own work.
frame
learns Self-correction
present
fixes itself learns from gaps
When a run hits a gap, the skill gets edited on the spot [FIXED] or queued for a bigger rewrite [LOGGED], so it keeps getting better.
tidies up Background fixes
present
queued for rewrite runs in the background
Bigger fixes that can't be made on the spot get queued and rewritten in the background later.
remembers Run history
present
state/log/evals.ndjson auto-shape runs
Every run is written down here, so the next time this skill is used it already knows how the last runs went.
Critical rules the things this skill must not get wrong
No must-not-break rules called out for this skill. Anything important lives in the writeup below.

what it has learned - fixes written back in over time sample

When a run hits something this skill didn't handle, the fix gets written back into the skill so it doesn't happen again. FIXED means it was corrected on the spot. LOGGED means it's queued for a bigger rewrite. Either way, the skill gets a little better and never makes the same mistake twice.

  1. Loading feedback rows…

how the work flows- who makes it, who checks it

actor Thing that
1 control
Scope — no side effects
What to read, what to compute, what to return. This step MUST be runnable
what this step does
What to read, what to compute, what to return. This step MUST be runnable with no apply: true flag and no credentials beyond read-only.
2 generator
Act (only if the gate passes)
The real work. Dispatch, write, post, or compose. Keep this step thin —
what this step does
The real work. Dispatch, write, post, or compose. Keep this step thin — heavy logic belongs in state/lib/snappy-https.ts (or state/bin/snappy-https/), not inline here.
auditor Thing that judges (must be different - see CONSTITUTION
3 data
Log + eval
```typescript

SKILL.md- the skill, written out in plain English

snappy-https

Handles URLs shared in chat that point to external resources - DigitalOcean Spaces objects, images, zips, or any HTTPS link. Prevents the failure mode where the user pastes a URL expecting the agent to fetch or inspect it, and the agent ignores the link entirely.

Observed user requests

These are the prompts that triggered this skill being scaffolded:

  • "https://robert-storage.tor1.digitaloceanspaces.com/shared/2026-04-28-1777395923733-crayon-sdk.zip -- Okay, so I just now"
  • "https://robert-storage.tor1.digitaloceanspaces.com/shared/2026-04-28-1777409614425-snappy-region-1777409610914.png -- sc"
  • "https://robert-storage.tor1.digitaloceanspaces.com/shared/2026-04-29-1777436955168-snappy-region-1777436950892.png -- th"

Steps

  • Detect the URL's content type via a HEAD request (curl -sI <url>) - check Content-Type response header.
  • For image types (image/*): download to /tmp/snappy-fetch-<timestamp>.<ext> and display via state/lib/agent-browser.ts screenshot or pass to state/lib/image.ts for analysis.
  • For archive types (application/zip, application/x-tar, etc.): download to /tmp/, extract with unzip -l or tar -tzf to preview contents without full extraction.
  • For text/JSON types: curl -sL <url> and surface the first 200 lines.
  • For DigitalOcean Spaces URLs (*.digitaloceanspaces.com): no auth required for public objects; private objects need DO Spaces credentials via env("DO_SPACES_KEY").
  • Log the fetch result (url, content-type, byte-size, disposition) as an eval row via score("snappy-https", run_id, { score: 1.0 }).
  • Never store fetched content in git or .env.cache - temp files under /tmp/ only.

Steps (scope-only / apply:false)

1. Scope - no side effects

What to read, what to compute, what to return. This step MUST be runnable with no apply: true flag and no credentials beyond read-only.

2. Gate

Hard-fail any missing required field. Never soft-skip. The gate is the protection against "I thought we checked that."

3. Act (only if the gate passes)

The real work. Dispatch, write, post, or compose. Keep this step thin - heavy logic belongs in state/lib/snappy-https.ts (or state/bin/snappy-https/), not inline here.

4. Log + eval

import { score } from "../../lib/eval";
score("snappy-https", run_id, {
  score: <pass = 1.0 | partial = 0.5 | fail = 0.0>,
  primary_issue: <null | one-line reason>,
});

Eval

Actor: the thing that produces the output (a dispatch model, a CLI, or the state/lib/snappy-https.ts library if one exists). Auditor: the thing that judges (must be different - see CONSTITUTION invariant #3). Name both explicitly.

Score convention:

OutcomeScore
Pass on first try1.0
Failed first, auto-fix applied, re-check passed0.5
Still failing or unrecoverable0.0

If you cannot name a deterministic auditor, switch the frontmatter to eval: manual and log to state/log/pending-eval.ndjson - but fight to avoid manual. Manual is the escape hatch that leaks the thesis.

Gotchas

  • List concrete failure modes you hit while building. Examples: "API

returns 200 with empty body"; "round-tripped text has a , artifact where em-dashes used to be"; "cache file is stale after 12h."

  • If a gotcha matches an entry in user memory (see ~/.claude/CLAUDE.md),

cite the memory name so future agents can follow the trail.

AGENTS.md- what the AI loads when this skill comes up

snappy-https - loader

Per-turn rules for snappy-https. Full reference: state/skills/snappy-https/SKILL.md.

Critical Rules

  1. Default scope-only (apply:false). Preview the download; require explicit confirmation before any write.
  2. HEAD probe first. curl -sI <url> extracts Content-Type header. Route by type.
  3. DO Spaces public (no auth by default). Private objects need env("DO_SPACES_KEY").
  4. Never persist to git. Temp files /tmp/snappy-fetch-<timestamp>.<ext> only.
  5. Eval row mandatory. After run: score("snappy-https", run_id, { score: 1.0 }).

Commands

| ui dashboard | state/skills/snappy-https/resources/ui.openui |

operationcommand
HEAD probe`curl -sI <url> \grep Content-Type`
download to /tmpcurl -sL <url> -o /tmp/snappy-fetch-$(date +%s).<ext>
image analysispass to state/lib/image.ts or display via agent-browser
archive previewunzip -l <file.zip> or tar -tzf <file.tar.gz>
text first 200`curl -sL <url> \head -200`
eval logstate/log/evals.ndjson
writebackstate/log/loader-feedback.log

Self-Test

An agent reading this should correctly:

  1. [ ] Detect content-type via HEAD before downloading?
  2. [ ] Route image/zip/text by type?
  3. [ ] Use DO Spaces public access without explicit auth?
  4. [ ] Write eval row with score=1.0 on success?
  5. [ ] Never commit temp files to git?
  6. [ ] Pass DO Spaces URLs (*.digitaloceanspaces.com) as no-auth by default?

Self-correcting loader (PID feedback)

If this loader didn't cover your case - missing content type, no DO Spaces fallback, wrong temp path - you MUST attempt an Edit to this AGENTS.md before you log.

Log before exit:

echo "[$(date -u +%FT%TZ)] snappy-https: <what was missing or fixed> [FIXED|LOGGED] action_kind=skill-ran" >> state/log/loader-feedback.log
  • FIXED = you edited this file inline.
  • LOGGED = the fix was too large; it's queued for regen.

OpenUI Resource

  • Skill-owned OpenUI Lang resource: state/skills/snappy-https/resources/ui.openui. Read it before rendering or editing this skill's generated component surface.
  • Treat this resource as a first-class artifact of the skill, not a generic chat response. Improve it when the skill's user-facing output needs to become richer.
  • System resources compose OpenUI primitives and inherit SnappyChat tokens. Use ui_contract: branded in SKILL.md only for deliberate platform or client visuals.

api.ts- the code it can call

#!/usr/bin/env npx tsx
/**
 * state/skills/snappy-https/api.ts — sidecar stub for the snappy-https skill.
 *
 * This file is created by the scaffolder so a fresh skill folder is
 * structurally valid. Replace the placeholder with the real implementation
 * the moment the skill needs executable logic, OR move the implementation
 * to `state/lib/snappy-https.ts` (preferred — the lib path is what
 * `eval: shape` validates against).
 *
 * If this skill has no backing code (prose-only slash command), delete this
 * file and rely on `eval: auto-shape` in SKILL.md.
 */
export const SKILL_NAME = "snappy-https" as const;

export function describe(): string {
  return "The https skill — purpose TBD.";
}

if ((() => { try { return import.meta.url === `file://${process.argv[1]}`; } catch { return false; } })()) {
  console.log(JSON.stringify({ skill: SKILL_NAME, describe: describe() }, null, 2));
}

scripts- helper scripts it can run

prose-only skill - 1 inline code block live in SKILL.md above (no state/bin/ sidecar yet).

how we check it- the checks, plus the last 10 runs

rubric auto-shape no rubric declared
recent no runs actor/auditor: unverifiable
deps none declared

no recent runs logged - the eval contract is declared but nothing has been graded yet