Index of every page on this site: llms.txt
Avatar for Peter Schuller

Peter Schuller

@scodeperson
24 skills 2 Los Angeles

scode/dotfiles

My rc/config files

24 skills 2
npx skilld add scode/dotfiles --all
  • Use only when the user explicitly invokes `$agent-resumeable PATH` or `/agent-resumeable PATH`. Puts the session under a resume-log protocol anchored at PATH; if the log exists, read it and resume the work, otherwise create it. Either way, keep logging for the rest of the session so a fresh session can pick up after an abrupt break.

  • Use only when the user invokes `interactive-artifact`, `$interactive-artifact`, or `/interactive-artifact`, or asks for an interactive artifact in those words. Serves a styled, commentable HTML page from a short-lived local web server and collects the user's picks, comments, suggested edits, and notes back to the agent. Nothing is published; the page lives on 127.0.0.1 until the server stops.

  • Use Jujutsu for a solo-developer stacked GitHub workflow where each reviewable change is its own commit, bookmark, and pull request; create and update the stack with jj, and use gh only for PR creation (always as a draft), publishing, and PR base updates (via gh api, never gh pr edit).

  • Run concurrent persistent reviewers over functional groups with compact delivery audits and immediate findings logs. Use for explicit persistent-review invocation or a request for persistent adversarial review. Discussing, assessing, or editing the skill does not launch a reviewer; ordinary review requests do not activate this protocol.

  • Run a concurrent multi-angle review only when the user explicitly invokes `pre-pr-review-swarm` by name. Spawn parallel reviewers for documentation/comment correctness and README drift, simplification opportunities, language idiomaticity, correctness risks including systems behavior and resource bounds, security vulnerabilities, test quality gaps, AI slop detection, and SPEC.md compliance (when a SPEC.md exists at the project root).

  • Run a repository-wide review swarm, ask the user how to handle each finding, then create a linear stacked PR series with one PR per accepted fix. Use when the user asks for "repo-swarm", for a whole-repo swarm, or for constrained scopes such as "repo-swarm all the code under foo/".

  • Use when the user indicates they want to work with Sapling; after that initial signal, prefer Sapling by default for the rest of the conversation.

  • How to work with a delegate once a caller has decided to use one: the self-contained task spec, the artifact-file rule, the no-VCS rule, the run id and run directory, the two-stop checkpoint protocol for delegates that write code, crash and resume handling, and the gate that judges the result and returns one of a fixed set of verdicts. Loaded by orchestration skills at the moment they delegate; inert on its own, never active for a session, and not meant to be invoked by the user directly.

  • Build a repository-grounded implementation blueprint for a separate workhorse session, or execute an existing blueprint that explicitly requires this skill. The planner designs; the executor implements with bounded workers and state-of-the-art consultations and reviews. Discussing or editing the skill does not start either phase.

  • Use only when the user explicitly invokes `$scode-build-goal` or `/scode-build-goal`. Takes a natural-language goal, optionally prefixed with an `in <dir>` clause (also `into`, `under`); picks mnemonic paths for the goal file and its working log (by default beside the checkout, out of the repo; proposes a temporary location when no good place exists), interrogates the user up front to resolve the decisions unattended work will need, then writes a self-resumeable goal file meant to be passed to /goal. No-workhorse mode is the default: the executing session works at its own model, with same-model sub-agents allowed for speed. `galaxy-brain` mode uses scode-galaxy-brain to delegate suitable work to cheaper models; `powerhorse` mode uses scode-powerhorse to supervise large parallel chunks on strong delegates; `shepherd` mode writes it for scode-shepherd, a strong supervisor over a cheap worker; `overseer` mode has the /goal session launch a cheap Claude Code executor through farhelm and oversee it by reading its transcript and sending nudges. `scode-build-goal help` prints a usage TLDR instead.

  • Run periodic repository maintenance chores and prepare one stacked PR per approved chore. Use when the user explicitly invokes /scode-chores or $scode-chores to check dependency-lock updates, dprint plugin updates, or GitHub Actions version updates.

  • Use only when the user explicitly invokes scode-commit-msg-reviewer by name, asks for commit messages to be checked by a fresh-context reader, or their standing instructions say to always use this skill. Do not trigger merely because a commit or PR is being created. Puts commit messages, PR titles/descriptions, and equivalent VCS prose in front of a cold reader who has not seen the change, and rewrites until that reader understands them; after the first signal, applies to all commit-message-like content for the rest of the conversation. Also use when the user says "scode-commit-msg-reviewer feedback: ..." to record feedback about how this skill performed.

  • Set up or standardize a Rust repository with cargo-dist release automation, Linux-focused CI with macOS release-plan tag gates, git-cliff changelog generation, Conventional Commit PR title enforcement, and release archives shaped for scode/homebrew-dist-tap to pull; the repository never pushes a Homebrew formula. Use when creating a new Rust release pipeline or migrating an existing repo to this exact distribution model.

  • Accomplish a goal by delegating suitable parts of the work to cost-effective models while the current session stays in charge of planning, quality gating, and all commit/PR management. Use when the user explicitly invokes scode-galaxy-brain, e.g. "Use scode-galaxy-brain for a goal", optionally with a prefer-gpt, prefer-claude, prefer-muse, or prefer-glm keyword and/or a request to work with concurrency. Also use when the user says "galaxy brain feedback: ..." to record feedback about how this skill performed. Once invoked, the skill stays active for the rest of the session — including across context compaction and resume — until the user expressly stops it, unless the invocation itself limited the scope up front.

  • Use when asked to start, spawn, run, or delegate work to a named-model agent (e.g. "astra agent", "opus agent", "neon agent", "sol high agent", "sonnet subagent"), use another provider or harness, or use an agent/model the current harness cannot launch natively. The user need not name this skill. Prefer supported native delegation when the launch mechanism is open; honor an external mechanism selected by the user or caller. Also loaded by other skills for foreign-harness launches, including to pick which CLI runs a model. Supplies the CLI choice and verified launch, monitoring, resume, and kill mechanics for `codex exec`, `claude -p`, `muse exec`, `agy -p` (Antigravity), `opencode run`, and `omp -p`; loading alone activates no session-wide behavior.

  • Answers which model, reasoning effort, and launch mechanism a unit of delegated work should run on, given a work profile and the orchestrating session's situation: the inventory, the work-profile table, the native-path bias, provider preference, and the model routing config file that declares what exists locally. Loaded by orchestration skills that own delegation (they decide whether and how to delegate; this skill only answers the routing question); inert on its own and never active for a session. A user may also ask it directly, e.g. "which model would you use for X".

  • Scan a repository for known deprecated or outdated patterns and propose or apply the modern equivalent. Use when the user explicitly invokes /scode-modernize or $scode-modernize to audit and modernize project conventions incrementally.

  • Supervise a goal by splitting it into large, independent chunks and running them in parallel on strong delegates (by default the session's own model), while the current session plans the chunks and the interfaces between them, gates every result, integrates, and owns all commit/PR management. The objective is finishing sooner at equal quality, not saving cost. Use only when the user explicitly invokes scode-powerhorse, or when a goal file the user had written requires it. Replaces scode-galaxy-brain for the session; the two are never active together. Once invoked, the skill stays active for the rest of the session, including across context compaction and resume, until the user expressly stops it, unless the invocation itself limited the scope up front.

  • Make Ubuntu 26.04 LTS hosts, Fly.io sprites, Tensorlake sandboxes, and boat sandboxes available as remote workers. Use when the user invokes scode-ssh-delegate or $scode-ssh-delegate followed by one or more hostnames, including terse forms such as "$scode-ssh-delegate foo" or "$scode-ssh-delegate foo, bar, baz"; when it is followed by named sprites or sandboxes, such as "$scode-ssh-delegate sprites foo1 foo2", "$scode-ssh-delegate sbx foo1 foo2", or "use the sprites foo1 foo2"; or when it grants a sprite, sandbox, or boat budget, such as "$scode-ssh-delegate sprites:3", "$scode-ssh-delegate sbx:3", "$scode-ssh-delegate boat 10", "$scode-ssh-delegate boat:10", or "it's okay to use up to 3 sprites". Immediately identify each named host's, sprite's, or sandbox's OS, CPU count, and memory, then retain the supported workers (or the budgets) for possible use by another workflow. This invocation does not request delegation. If retained context after compaction or resume says workers or a budget were registered, re-read this skill and its companion files before touching them.

  • Use only when the user explicitly invokes `/scode-todo` or `$scode-todo`.

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

  • Use only when the user explicitly invokes `slstack` and wants a stacked-diff workflow with Sapling in `.git` mode and clean non-overlapping GitHub PRs via upstream `ghstack`. After explicit invocation, treat later commit and PR work in the same conversation as using this workflow by default. Do not use for native Sapling `.sl` repos or for Sapling's overlapping `sl pr submit --stack` workflow.

  • Use only when the user explicitly invokes `/stax` or `$stax`.

  • Use only when the user explicitly invokes `swarm-triage` by name. Drives the human triage of a pre-pr-review-swarm run — bringing chosen findings into a working document the user names, iterating on them there, and recording the user's verdict on every finding (accepted, rejected, skipped) with their own words on why — so the swarm's output can later be judged against what a person actually did with it.

Curated skills from @scode. Checked GitHub just now