Index of every page on this site: llms.txt
All skills
scode avatar

/skillette

@03a9f7f
Run it yourself

Use when the user invokes `skillette`, `$skillette`, or any `skillette-<name>` trigger.

  • 25 files
  • 237.6 KB
  • Updated last month
  • GitHub
Use this Skill: https://skilld.dev/gh/scode/dotfiles/skillette

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SPEC.md

≈8.6k tokens on demand. Your agent reads this file only when SKILL.md points to it.

skillette specification

This file defines the user-facing behavior of the skillette skill and the contract every skillette inside it must follow. Agents changing this skill or any skillette must conform to it. If the files and this spec disagree, that is a bug, or the spec must be updated in the same change.

NOTE: This is not the skill itself and nothing on the trigger path reads it. Its only readers are the change skillette, on its local-edit path, and the cold agent that picks up a change issue. If some other skillette or flow finds itself needing this file, that is a sign the design has drifted.

What a skillette is

A skillette is a small skill-like behavior that is too minor to justify a full skill of its own. The whole point is that adding one costs almost nothing: a directory with one markdown file, plus one row in a table. There is no registration step in the installer, because the entire skillette directory is installed as a single symlink per harness.

Why the top-level file is tiny

SKILL.md is designed to be resident in context for a whole session. A user either invokes skillette explicitly or keeps a line in their personal agent instructions saying to load it at the start of every session. Every line in SKILL.md is therefore paid for on every turn of every session, so it carries nothing but the frontmatter, one short paragraph on how to resolve a trigger to a file, and the table. Everything else lives behind the table in the per-skillette directories.

Layout

skillette/
  SKILL.md              frontmatter, the resolution paragraph, and the trigger table; nothing else
  SPEC.md               this file
  <name>/
    SKILLETTE.md        the skillette's instructions, read only on a trigger match
    ...                 optional supporting files (further .md for progressive disclosure, scripts, references)

Skillette names are kebab-case. The directory name is the skillette name.

The table

The table has exactly two columns.

The first column, "Triggers", is a space-separated list of explicit trigger words. Every one of them is kebab-case and starts with skillette-, so that no explicit trigger can collide with ordinary prose or with another skill's vocabulary. The first trigger in the list is always skillette-<name>, and that is how an agent maps a row to its directory: strip the skillette- prefix from the first trigger and read <name>/SKILLETTE.md. Further triggers in the same cell are optional aliases.

The second column, "Natural-language triggers", is either empty or a short phrase describing the situations in which the skillette applies without an explicit trigger: something the user says, or something the agent is about to do, such as committing. Empty means the skillette fires only on its explicit triggers. When present, the phrase is a trigger description, not a summary of what the skillette does; keep it to the words that make the activation decision, because the whole column is paid for on every turn.

Triggers

Every skillette has at least the explicit trigger skillette-<name>. A user who types it bare or with a leading $ gets the skillette. Whether a leading / works depends on the harness, which owns that namespace and may swallow an unknown slash command before the agent sees it, so this spec makes no promise about it.

The whole message containing a trigger is the request; the trigger only marks which skillette acts on it, since users drop triggers mid-sentence as often as at the start. A trigger with no request around it makes the skillette ask what the user wants.

An explicit trigger wins outright over another row's phrase match, so a change request that mentions some other skillette by topic does not cost a round trip. If two rows still plausibly match, by phrase against phrase or by two explicit triggers, the agent asks the user which one they meant rather than guessing. A skillette- word that matches no row is reported as such, not mapped to the nearest one. Bare skillette or $skillette with no trigger loads the skill and confirms that in a line; nothing else happens until a trigger arrives.

Natural-language triggers are optional and are a decision made when the skillette is added. The agent adding a skillette must ask the user whether natural-language triggers are wanted, but only when the user has not already made that clear. A user who says "explicit trigger only" or who hands over the trigger phrase has answered; do not ask again. When the agent does ask, it proposes the obvious phrase rather than posing a bare yes/no, and it points out when explicit-only cannot work (a skillette meant to fire on the agent's own actions, such as before a commit, has no moment for the user to type a trigger). The reason this is a deliberate decision rather than a default is that agents left to their own devices pile up trigger words and descriptions until the table stops being cheap.

Locating the skillette file

SKILL.md is resident for the whole session, and a trigger routinely fires long after the harness's original load message has been compacted away. Two things cooperate to recover from that, and both are load-bearing.

The frontmatter description is what re-summons the skill when SKILL.md itself has fallen out of context. It survives compaction because it lives in the harness's skills listing, not in the conversation, so it must keep naming skillette-<name> triggers; an agent that sees $skillette-change after compaction has nothing else to tell it which skill owns that word. Trimming the description to just skillette would silently break recovery on every harness.

NOTE: Only explicit triggers survive that way on their own. A natural-language phrase or an agent-action condition lives in the table, and the table is gone once SKILL.md has been compacted out; nothing in the skills listing mentions commits or whatever else the phrase names. The mitigation is a standing instruction in the user's always-loaded agent instructions that says to load skillette at session start and to load it again after every compaction. The instructions file is part of the system prompt and so is still present after compaction, unlike the conversation; the shipped agent-instructions/AGENTS.md carries such a line. This only works to the extent the agent notices compaction and honors the instruction, so a skillette that relies on its second column may still go quiet mid-session. The alternative, carrying the whole table in every session's description, was rejected on cost. Users choosing a phrase should know they are choosing it.

The resolution paragraph in SKILL.md covers the case where the table is still in context but the base directory is not. It compresses the same per-harness rule the repo's layered skills use for their dependencies (see tests/skill_deps.rs for the canonical wording and the reasoning behind the Codex path): the base directory is the directory containing the loaded SKILL.md; if it is not in context, reload skillette through the harness's skill mechanism, which on Claude Code, OpenCode, and Muse Code reports the base directory, and on Codex, which has no such mechanism, is the fixed path ${CODEX_HOME:-$HOME/.codex}/skills/skillette. If the loader fails or <name>/SKILLETTE.md cannot be read under that directory, the agent stops and names the path or tool. It does not continue from memory, from a search for the file elsewhere, or from a similar skill. The compression drops two parts of the canonical stanza: the name confirmation step, which matters for dependencies with look-alike names and not for a skill reloading itself, and the guard for harnesses other than the four named, which this skill does not claim to support. When the Codex root in tests/skill_deps.rs changes, the path here and in SKILL.md must change with it; no test couples them.

Harness neutrality

The skillette skill is not specific to any harness, and neither is a skillette unless the user intentionally overrides that for the one they are adding. Do not reference harness-specific tools, file locations, or slash-command syntax in a skillette unless the user asked for that skillette to be harness-specific. The one exception in skillette itself is the resolution paragraph in SKILL.md, which has to name each harness's skill loader because that is the only way to find the file. The change skillette carries the neutrality default into every hand-off it writes.

Adding, removing, or changing a skillette

Adding: create <name>/SKILLETTE.md, add one row to the table. Removing: delete the directory, delete the row. Changing: edit the files. None of these touch src/main.rs, because the installer symlinks the whole skillette directory.

Changes to SKILL.md itself, the table format, or this spec are changes to the skillette skill and go through the same change skillette as everything else.

The codex-wake-on-exit skillette

This skillette is intentionally Codex-specific, overriding the normal harness-neutral default for this one entry. Its explicit trigger is skillette-codex-wake-on-exit; its natural-language triggers cover requests to wake up later, check periodically, or wait for a condition in a Codex session, including "use Codex wake-on-exit". The user need not name the harness or mechanism: "wake up once per 30 minutes and fix it if it's broken" must discover this skillette. Discussion and edits do not arm watchers. The shared table does not provide deterministic harness filtering.

It teaches idle monitoring through a detached, owned condition watcher whose exit queues a message to the existing Codex thread, then has the agent end its turn. The watcher may poll its data source; the model must not poll the watcher's status or wake periodically to collect it. A requested timed wake uses a delay watcher. Explicitly requested periodic checks use a fresh delay watcher after each callback and check while the request remains active; waiting for a condition does not authorize inventing periodic model wakes. Active plan work continues until the flow next becomes idle. The existing flow's watcher arguments, baseline, role, lifetime, and terminal exit rules are preserved.

The bundled Deno helper captures the actual current thread, confirms local queue support, and acknowledges detached startup before returning. Linux and macOS ordinary Codex sessions are supported; unloaded native spawned subagents cannot receive direct queued input and are not completion-wake targets. Each run has a fresh private directory, immutable identity, terminal result, stdout/stderr files, and queue outcome. Nonzero exits still trigger a callback. Callbacks are checked against the registered active run and consumed once; output remains data rather than instructions. Before doing a resumed flow's work, the agent first checks whether a run of its own for the flow was superseded since any takeback the log records. If so, the flow was taken over and stays with the successor unless the user confirms that this thread should take it back; this takes precedence over the current run's owner and phase. Only then does it check the run its log records as current. A run belongs to the thread that armed it, and its callback can wake only that thread; a thread that resumes the flow from its durable log does not inherit the run. status reports the owner for any thread's run. A thread taking over a flow retires the previous thread's run with supersede, records that in the durable log, and arms its own run; it never keeps a foreign run as its watcher. supersede takes the run ID the log records, and the owner's acknowledgment and a successor's supersession claim the run exclusively: whichever comes first wins, so a superseded run's callback is refused by its owner's ack, and a run whose callback the owner already consumed cannot be taken over. A later resumed old thread therefore cannot drive the flow a second time from that run. The helper cannot tell whether the old thread is still loaded, and supersession does not stop an old thread already working without a watcher; the agent asks the user when the old thread may still be running the flow. Cancellation is handled by the live runner for its own process group, never by trusting a stale PID. Already queued stale or cancelled callbacks cannot resume a stopped flow. Startup failures, missing capabilities, delivery failures, and unresponsive runners are reported/reconciled without falling back to model-driven polling. There is no automatic enqueue retry or promise of restart recovery.

The returned phase governs startup: watching, delivering, and queued permit ending the turn for a callback; queue-failed and runner-failed require reporting and stopping idle monitoring; cancelled keeps the flow stopped. CLI exit code 0 alone is not evidence of an armed watcher.

Supporting scripts are installed through the existing directory symlink, so no installer registration changes are needed. The optional maintenance evals exercise both discovery and real watcher use; ordinary use does not read the eval instructions or automatically launch evaluators.

The lore skillette

lore stores frozen historical entries under the repository's lore/ directory. Its setup procedure owns the canonical instruction texts, entry naming, and Markdown-tool exclusions; setup does not enable automatic recording or routine history reads.

A repository may explicitly opt into a daily work log through a separate repository-level policy. The canonical lore instructions permit only that policy's specified startup/compaction reads and current-day YYYY-MM-DD-log.md creation and appends during ordinary work. Past-day logs remain frozen, corrections go in today's log, and other historical entries retain the default restrictions. Normalization preserves the approved work-log policy outside the canonical Lore section and never rewrites log contents. Markdown-tool exclusions still cover the entire directory.

The brain skillette

brain manages explicitly requested Markdown artifacts in the private scode/brain GitHub repository. It does not load brain contents at session start or capture things automatically. Natural-language requests to read, list, add, edit, or remove brain artifacts select it; discussion of changing the skillette selects change instead. Retrieved notes are reference material, not authority to execute their contents.

An unqualified brain means personal; named brains use <name>/ with no brain- prefix. Each folder contains a BRAIN.md heading and a concise two-column table of relative artifact links and descriptions, plus the referenced Markdown artifacts. Artifact names are mnemonic kebab-case with .md, without a dating system. There is no additional required metadata or structure, and BRAIN.md is the only brain-wide index. An individual artifact may still be a directory with its own entry file and internal index; its BRAIN.md row links to that entry file. Reads use the index to select relevant artifacts. Writes keep the index consistent with artifact additions, edits, renames, and removals in the same commit. Reads do not create missing brains or publish index repairs.

Local storage is automatic: a shared bare cache under ${XDG_CACHE_HOME:-$HOME/.cache}/brain/, and isolated operation worktrees under ${XDG_STATE_HOME:-$HOME/.local/state}/brain/operations/. Unpublished work belongs in state, not the disposable cache. Cache setup and worktree metadata operations are serialized; each operation owns its fetch ref and detached worktree. Read-only operations may read directly from their session snapshot without a worktree; they must never borrow another operation's worktree or trust a pre-existing tracking ref. No operation reuses the current project checkout or requires the user to pick a path.

The first explicit brain request establishes a session snapshot of the repository, recording the default branch, commit SHA, and successful-fetch time under a private session ref. Subsequent requests, including requests for another named brain, reuse it without GitHub calls until it is more than six hours old, the user requests a refresh or update of the brain, or concrete evidence such as a stale push or merge conflict calls for a refresh. Age is checked locally on requests, not in the background; reads do not reset it, and exactly six hours still permits reuse. Session metadata survives compaction, operation cleanup retains the session ref, and one session never adopts another's mutable ref. Lost snapshot metadata requires initialization on the next request. Failed refreshes preserve the previous timestamp and are reported, with retained content identified as stale.

Writes may start from that snapshot without a pre-write fetch. Publication and its verification still contact GitHub, and successful fetches advance the session snapshot to verified remote state, never to unpublished local work. A request to edit an artifact is not by itself a refresh request. An already-satisfied request is answered from the snapshot without a reconfirmation fetch or empty commit, and is not presented as a new check of current GitHub state.

A write succeeds only after a normal push publishes the artifact and index commit to the default branch and a fetch verifies remote acceptance. A rejected stale push requires fetching, rebasing, and semantic reconciliation, including preserving independent index additions and handling filename collisions. Force pushes are forbidden. Incompatible edits requiring user judgment, persistent contention, and network or permission failures retain pending work and are reported as not stored. An empty repository is initialized on main; a competing initialization is reconciled against the winning history. Cleanup is limited to the completed operation. Later requests surface relevant pending operations without automatically publishing them.

Artifact commits in scode/brain are mechanical storage operations, exempt from development gates such as commit wording criteria, cold-reader reviews, review swarms, PR/stack workflows, and project tests or CI. They use short mechanical messages with empty bodies and direct Git publication. Content and index checks, concurrency protection, and remote-publication verification still apply. This exception is also recorded in shared agent instructions so the general commit-review requirement does not reintroduce those gates. Development of the skillette itself is not exempt.

Code review queues, defined in brain/code-review-queue.md, are a convention on top of artifacts: one queue per project at code-review/<host>/<owner>/<repo>/ in the personal brain, where <host> is gh for GitHub and a bare repository name means the scode owner. A queue is only the set of open findings, with no record of review runs, coverage, or drained items. Its INDEX.md sorts one line per finding into the cr-triage P1/P2/P3 buckets, and each finding is a mnemonic file holding a condensed TLDR and details plus the verbatim text of every source merged into it. Ingesting keeps every reported finding without assessing validity, buckets by the claimed consequence, and merges a new finding into an existing one only when defect, location, cause, and consequence are clearly the same, scoped to that project's queue. Draining deletes the finding, and the last one takes the queue directory and its BRAIN.md row with it.

brain/EVALS.md records manual use flows, edge cases, and expected outcomes. Maintainers keep it current when behavior changes, guided by brain/AGENTS.md and its CLAUDE.md symlink. Evals run only when requested, defaulting to a cheap, fast available model without a hardcoded model name. These maintenance files are not part of normal brain use.

The ntfy skillette

ntfy sends one notification to an explicitly supplied topic on https://ntfy.sh. Its short forms are ntfy <topic> <message> and $ntfy <topic> <message> at the beginning of a send request; quoted examples and discussion do not send anything. Embedded instructions such as "do the work, then ntfy <topic> that you're done" also trigger it. Its explicit trigger is skillette-ntfy, with the same arguments. The short forms live in the table's natural-language column so the explicit-trigger naming convention stays intact.

The topic must be explicitly supplied and match [-_A-Za-z0-9]{1,64} in full. In command-style requests it is the first argument, and the remaining message is literal text, including newlines and shell metacharacters. In natural-language requests the agent composes the requested meaning, preserving exact wording when supplied, and honors send conditions. Completion messages wait for successful completion; a blocked task does not authorize a false success or an unrequested failure notification. Missing topics or unclear message intent require clarification; invalid topics are rejected. There is no default topic or reuse from previous requests, but a pending conditional send retains its explicitly named topic. No real user topic appears in the shipped instructions or examples.

Publishing uses curl, assumed installed; if unavailable, abort without installing it or switching clients. Publishing defaults to high priority. Overrides require a separate explicit instruction, not option-like text inside the message. Reject messages over 4,096 UTF-8 bytes before publishing to prevent automatic attachment conversion. One invocation makes one publish attempt, without automatic retries, splitting, or truncation. Success means confirmed server acceptance, not confirmed phone delivery. Authentication errors are reported without searching for credentials. The skillette neither manages subscriptions nor enables ongoing notifications.

The cr-triage skillette

cr-triage walks the user through a set of code review findings and records one outcome per finding: spec (change SPEC.md or SPEC_impl.md, typically because the reviewer lacked a constraint), fix (queue a code fix), spec+fix, discard (not worth discussing, with no implied verdict on correctness), or other in the user's words. Besides catching bugs, the aim is a project whose stated constraints stop agent reviewers from raising the same invalid findings repeatedly. Its explicit trigger is skillette-cr-triage; the bare word cr-triage sits in the natural-language column for the same reason ntfy's short forms do, and like every phrase it stops working once the table has been compacted out.

It is triage only. No code or spec is edited during the flow unless the user asks outright, and then only after the outcome is recorded. The skillette names no particular review tool or skill; findings from any source are handled the same way.

The findings are whatever the user points at, or by default those produced earlier in the session; when that is unclear the agent asks. A bare trigger is therefore a complete request, an exception to the general rule that a trigger with no request around it makes the skillette ask. Questions are settled before assessment. When the user has not said where the queue goes, the agent asks, offering a secret GitHub gist as the default and taking whatever else the user names. Findings that exist only in the session are, with the user's agreement, saved next to the queue before assessment, so the queue's references to them survive the session. Secret values are never copied into either file.

The queue keeps every finding; the only reduction is merging exact duplicates. Each entry records the agent's correctness assessment, made with a high bar for calling a finding invalid. Entries are sorted into P1 (security, data loss, critical correctness), P2 (serious UX or behavior bugs), and P3 (minor, rare, style) by what the finding claims, not by the assessment or by rarity, so an invalid or rare security or data-loss finding stays where it gets attention.

The queue is Markdown by default, holds enough of every finding to be triaged without the original review output, and gives each entry a T<n> identifier that is never renumbered or reused. Each decision is written as soon as it is made; a failed read or write of the queue or findings copy stops the flow until the user decides how to proceed. Invoking the skillette again with the same findings and queue resumes at the first pending entry.

The hackmd skillette

hackmd gives an agent the mechanics for reading and writing HackMD notes through hackmd-cli and, where the CLI falls short, the REST API. It fires when the user mentions HackMD. It prescribes no workflow or sync design; a repeatable sync is designed with the user. Notes are created owner-only with owner comments unless the user asks otherwise, and the agent reports the permissions it set.

A note can carry SVG, PNG, JPEG, GIF, and WebP figures uploaded to HackMD itself, so that neither external hosting nor inline data: URIs (which run into HackMD's 100 KiB body cap) are needed. The skillette ships upload-image.sh for this, because the CLI has no upload command. Uploads belong to one note and inherit its read permission, so a note with images is created private, gets its images uploaded and linked, and is shared only afterwards; its comment permission is still chosen for the shared state at creation, because HackMD cannot change it later. Uploads are not idempotent and cannot be listed or deleted through the API, so the agent does not re-upload unchanged images, and it reports a partial or uncertain upload rather than retrying silently. The agent does not shrink an oversized image without asking.

The snippets skillette

snippets is a pointer to the user's private scode/snippets repository, whose root AGENTS.md is the authority on how snippets are created, changed, and published. The skillette carries none of that process itself: it tells the agent to read the current AGENTS.md from the default branch on every use and follow it, and to stop if the file cannot be read. Keeping the process in one place means the snippets repository can change it without a matching edit here.

The natural-language trigger is the word scode-snippets. A plain "snippet" was the first choice, but it collides with ordinary talk about code snippets in almost every coding session, and a distinctive word avoids having the agent decide each time whether the user meant the repository. The skillette assumes the agent can reach the private repository and does not ask.

The trigger also covers "a scode snippet" and "the preview flow", because the user asks for the preview flow in those words rather than by the repository's name. A bare "preview flow" is the user's own requested phrase. It is more generic than scode-snippets, and the cost is that an unrelated "preview flow" may load this skillette; that was accepted so the phrase works in a session where snippets have not come up yet.

The preview flow is the one piece of process the skillette carries itself. On request, the agent builds the snippet in a scratch clone exactly as AGENTS.md says (same stylepack, same content rules) but commits and pushes nothing. Instead it serves the clone's snippets/ directory with snippets/preview-server, a Deno script next to SKILLETTE.md, and hands the user a loopback URL. Serving the clone rather than a copy of the snippet is what keeps the relative stylepack link working. The server binds 127.0.0.1 only, on the first free port in 14100-14120, and the agent must not widen that: the whole point of the preview is that nothing leaves the machine. For the same reason it refuses any request whose real path, after following symlinks, lands outside the served directory. It also serves an index.md entry point at /<slug>/, as text/plain, since AGENTS.md allows Markdown snippets and the user is only ever given that URL.

The server runs under the harness's ordinary background mechanism and is never detached (nohup, setsid, and the like are forbidden), so it dies with the session that started it. A review found that in some harnesses this can kill it before the user has looked; that was accepted over the alternative, a detached server left running as an orphan once the session is gone. If premature death turns out to be a real problem, the user intends to revisit it; an idle timeout on a detached server was the option discussed.

The flow lives here rather than in AGENTS.md because it is about not using the repository's publication process, and everything about the snippet's content still comes from AGENTS.md. Publishing a previewed snippet later is the normal flow, privacy check included.

The scripts skillette

scripts records the user's strong preference for Deno with TypeScript over shell, Python, Perl, or anything else whenever the agent is about to write a script or non-trivial inline code. It fires on the agent's own action, so its natural-language phrase is what makes it work; the explicit trigger exists only because every skillette has one. Deviating needs a very strong reason, stated in a line. A missing Deno is not by itself one: the agent asks the user, and when unattended it may brew install deno if brew and its permissions allow. Only when neither gets Deno installed does it fall back to whatever scripting language is available, saying so in a line. The preference is strong but never a blocker.

The skillette is deliberately small. It carries only the preferences an agent cannot infer (single-file scripts, exact version pins, dax for subprocesses, tests in the script itself) and the gotchas observed when agents first wrote Deno scripts this way, chiefly that deno test is sandboxed regardless of the shebang and needs -A. Further rules are added when real use shows they are needed, not in advance.

The change skillette

change exists so that "oh, by the way, skillette should also do X" can be said mid-session, in any project, without derailing what the session was doing. Its trigger is skillette-change and it covers adding, removing, and changing skillettes as well as changing the skillette skill itself.

The flow, in order:

  1. Decide where the change is made. The probe is a file check: does the current directory or any ancestor contain agent-skills/skillette/SKILL.md? It is deliberately not a VCS query, because the user's dotfiles checkouts include jj-only workspaces where git commands fail. If the probe finds the file, the session is in a dotfiles checkout and the agent asks whether to edit locally or file a GitHub issue, unless the conversation already answers that (the session is already editing this skill, or the user said which they want). For an addition, the name and trigger proposal rides in that same question. If the probe finds nothing, or the agent cannot tell where it is, file an issue without investigating further; the issue flow is always correct. A request about some other skill is out of scope and is declined in a line.
  2. Local path: read this spec from the checkout the probe found, make the edits under agent-skills/skillette/ there, and stop. An edit that changes user-facing behavior updates this spec in the same edit. Whether a commit or PR follows is up to the user and the surrounding session.
  3. Issue path: write a hand-off for a cold agent and open a GitHub issue on scode/dotfiles labeled skillette-change. The hand-off carries everything a later agent needs to produce roughly the change the current agent would have made right then, minus anything private. Create the issue immediately unless a question is open, and there is at most one question, asked once: it batches the name and natural-language trigger decision for an addition or a trigger change (when the user has not already settled it) together with every privacy item worth asking about. Whatever the answer leaves unaddressed defaults to omit.
  4. Report the issue URL in one line, with a count of identifiers generalized or omitted, and go back to whatever the session was doing. The agent does not check for an existing issue on the same subject; duplicates are cheap and deduplicating costs a round trip on every use. If gh fails for any reason, the agent requests its harness's one-time approval if there is one, and otherwise asks the user to choose between fixing gh and receiving the issue text to file by hand; it never investigates or routes around the failure. If the label cannot be created, the issue is filed without it and the report says so.

The repo is public. The hand-off must not contain personal or privacy-sensitive information. Concrete identifiers from the session (paths under the home directory, hostnames, employer, client, project, or people names, email addresses and handles, URLs and ticket IDs, credentials or anything shaped like one, and pasted tool output, error text, or code from the session) are generalized or omitted by default. That list is not exhaustive. The current repository is treated as private unless the agent already knows it is public. The check covers the title as well as the body. The agent asks only about identifiers whose generalization or omission would lose substance the cold agent needs; everything else is generalized silently. It asks once, listing every such item in that one question with the choices include, generalize, or omit for each. One question, however many items. Approval is per item and per issue: a general remark that some class of identifier is fine, or that the agent asks too much, is itself a change request to this skillette and is recorded as one rather than applied to the current filing. An approved identifier still goes in only when leaving it out would lose substance.

The hand-off template is in change/SKILLETTE.md. It is deliberately high level. Agents are expected, not merely allowed, to add whatever context does not fit the template; the failure mode this skillette is optimized against is lost context, not an untidy issue. The privacy rule constrains identifiers, not substance: the situation, the reasoning, and the intended behavior can and should be described in full in generic terms.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No third-party reports yet.

Signed by skilld at 03a9f7f. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated last month

README badge

README badge for scode/dotfiles/skillette