donnfelker
- 49 skills
- 0 followers
- last month last updated
- ▌
- ▌ Dev Team · donnfelker bundleDrive a single unit of work — one spec, ticket, finding, or change request — from spec to a committed, reviewed result with a dev team of coordinating agents: Dev → QA → Reviewer/code-review in a bounded cycle. Runs as an agent team when the harness supports one, else coordinated subagents, so it works across agents and models. Use whenever the operator wants a change implemented with rigor instead of a quick edit: 'use a dev team to build and verify this', 'fire off the dev team on this', 'spin up the dev/QA/review agents', 'implement this with a dev/QA/review loop', 'drive this change through dev then QA then code review', 'QA and review this before committing'. This is also the per-subtask engine behind implement-full-spec — that skill calls this dev team once per subtask, then handles stacking, PRs, and review-response on its own. Use this skill for ONE unit of work; for a parent ticket with many subtasks shipped as stacked PRs, use implement-full-spec (which delegates here).
- ▌ Pr Autopilot · donnfelkerAutonomously watch a single pull request and drive its review feedback, failing CI checks, AND merge conflicts to completion without supervision: each round fetch every unaddressed review and comment (Claude, CodeRabbit, Copilot, other bots, humans), the PR's check runs (tests, lint, type, build, security), and its mergeability; address the actionable ones (resolving conflicts by merging the base branch into the head), commit, push, reply/resolve threads, and re-request review from bots whose change requests were addressed, then loop until a quiet round or a safety cap. Use whenever the user wants to 'watch a PR', 'babysit a PR', 'keep addressing PR comments until done', 'fix the failing checks', 'get CI green', 'resolve the merge conflict on PR #N', 'auto-respond to reviews', or run a hands-off review-response loop on ONE PR, even if they don't name this skill. Pass --single-pass (or --max-rounds 1) for one autonomous round, no loop. For MANY stacked PRs from a parent ticket, see /implement-full-spec.
- ▌ Plan To Tickets · donnfelker bundleImport a structured planning document (implementation plan, project plan, design doc with tasks) into a task-tracking system as a ticket hierarchy with dependencies wired. Use whenever the operator says 'break this plan into tickets', 'import this into ClickUp/Linear/Jira/Asana', 'create tickets for this plan', 'turn this doc into tasks', 'set up the project in [tracker]', or any variation of converting a written plan into trackable work items. Also use when the operator references a planning doc and a target tracker URL or list in the same request. Covers hierarchy negotiation, ID mapping, dependency wiring, and the platform-specific gotchas that bite on the first attempt. Includes a readiness check up front that will stop and ask the operator to spec the plan out further if it's not yet structured enough to ticket — refusing to import a half-baked plan is part of the contract, not a failure mode.
- ▌ Implement Full Spec · donnfelker bundleUse when the operator points at a parent ticket, audit, RFC, design doc, or multi-finding report with N actionable subtasks and wants every subtask shipped as its own stacked pull request, then driven to merge-ready by addressing every bot/human review comment and re-requesting review per round. Triggers on: 'fix all subtasks of [ticket]', 'work through P1/P2/P3 items', 'open a PR per finding and stack them', 'ship the audit remediations', 'knock out this report end to end', 'use agent teams to fix [parent]', 'address all comments on these stacked PRs', 'drive the stack to merge-ready', 'do a review-response sweep', 'comment @bot re-review when done'. Depends on the dev-team and pr-autopilot plugins. For a single unit of work, see dev-team; for one PR's review-response, see pr-autopilot.
- ▌ Multi LLM Convergence · donnfelker bundleDrive any artifact to convergence by alternating two genuinely different LLM reviewers — a Codex reviewer and an independent Claude review subagent — applying each round's findings and looping until BOTH independently agree it clears the bar (default: no critical/high findings). Artifact-agnostic: works on a plan, PRD, design doc, spec, or implementation diff. Use whenever the user says 'have two LLMs converge on this', 'loop Claude and Codex until they agree', 'review and revise until consensus', 'iterate this plan/PRD/spec until there are no blockers', or wants cross-model agreement rather than one reviewer's opinion. Prefer this over a single review pass whenever the user wants different models to actually agree on an end result. NOT pr-autopilot (one GitHub PR's comment threads) — this is the artifact-agnostic, alternating-different-models, iterate-to-consensus loop.
- ▌ Triangulated Code Review · donnfelker bundleTriangulated multi-reviewer code-review orchestrator that runs comprehensive, security, Codex, and Codex adversarial reviews in parallel, then a QA analyst subagent substantiates each finding (verifying any third-party library claims via the context7 MCP) and demotes unsubstantiated ones into an 'Invalidated Findings' section of the timestamped report. Use whenever the user asks for 'a thorough code review,' 'triangulated review,' 'review my changes,' 'multi-reviewer review,' 'run all the reviews,' 'code review with security,' 'pre-PR review,' wants more than a single perspective on pending changes, or invokes the triangulated-code-review orchestrator. Prefer this over a single reviewer whenever the user wants real coverage before opening a PR.
- ▌ Multi LLM Convergence Beta · donnfelker bundle(beta/experimental) Host-agnostic, N-model variant of multi-llm-convergence: drive any artifact (plan, PRD, design doc, spec, or implementation diff) to cross-model consensus from Claude, Codex, Gemini, or another capable host by rotating multiple built-in reviewer families through one uniform read-only reviewer protocol, hard preflight, local-only source grounding, per-round commits, and a full clean-cycle convergence rule. Use for 'beta convergence', 'N-model convergence', 'run convergence from Codex/Gemini/Claude', or 'converge with multiple models'. For the stable Claude Code loop, use multi-llm-convergence instead.
- ▌ Scrivener Edit · donnfelker bundleWhen the user wants to edit a document's text or restructure the binder of a Scrivener project — adding, renaming, moving, reordering, re-parenting, or deleting documents and folders, appending to a document, or setting its synopsis or notes. Use when the user says "add a chapter," "add a scene," "move this section," "reorder chapters," "rename this document," "delete this," "append to this doc," "set the synopsis," "set the notes," "split this scene," or "merge these." For labels, status, keywords, and section types, see scrivener-metadata. For versioning before a rewrite, see scrivener-snapshots.
- ▌ Scrivener Sync · donnfelker bundleWhen the user wants to edit a Scrivener Draft as plain text in an external folder and re-sync the changes back — the agent-native round-trip that avoids RTF surgery. Use when the user says "sync to a folder," "edit as plain text and sync back," "export the draft so I can edit it elsewhere," "external folder sync," "set up a Dropbox sync folder," or "is this project in a sync conflict." For converting content out without the round-trip, see scrivener-extract. For bringing edited text back into a document today, see scrivener-edit. For detecting and resolving sync conflicts, see scrivener-integrity.
- ▌ Scrivener Stats · donnfelker bundleWhen the user wants word counts, length estimates, or writing-progress metrics for a Scrivener project. Use when the user says "word count", "how long is my manuscript", "reading time", "how many pages", "what words do I overuse", "writing history", or "am I hitting my target". For reading a document's text and outline, see scrivener-inspect. For assembling the Draft into a finished file, see scrivener-compile.
- ▌ Scrivener Format · donnfelker bundleWhen the user wants to understand how a Scrivener 3 project is stored on disk — the .scriv package, the .scrivx binder, where text/synopses/notes/snapshots/comments live, or how section types, labels, and metadata serialize. Use when the user says "how does Scrivener store…", ".scrivx format", "what's in a .scriv", "scrivener file format", "where are synopses stored", or "what files make up a Scrivener project". This is the foundational reference hub the other scrivener skills cite. For reading/exploring an actual project, see scrivener-inspect. For validating or repairing a package, see scrivener-integrity.
- ▌ Scrivener Import · donnfelker bundleWhen the user wants to bring external material into an existing Scrivener project. Use when the user says "import this file/manuscript into Scrivener", "bring this markdown in", "split this long doc into chapters on import", "import research", or "merge another Scrivener project". For adding or splitting items already in the project, see scrivener-edit. For scaffolding a brand-new project, see scrivener-create-project. For matching imported text to the project's look, see scrivener-format.
- ▌ Scrivener Search · donnfelker bundleWhen the user wants to find text across a Scrivener project, see which documents mention something, or (planned) rename a term everywhere. Use when the user says "find where I mention X," "search the project for X," "which docs talk about X," "rename X to Y everywhere," or "find duplicates." For reading a single document, see scrivener-inspect. For editing one document's text, see scrivener-edit. For searching by label or status, see scrivener-metadata.
- ▌ Scrivener Styles · donnfelker bundleWhen the user wants to work with named Styles and Stylesheets in a Scrivener 3 project — apply a style to text, create or redefine a style, remove styling, or import styles from another project. Use when the user says "apply the Block Quote style", "create a style", "redefine Heading 1", "remove styles from this text", "make this a named style", or "import styles from another project". This is named STYLES (a project stylesheet), distinct from direct FORMATTING (fonts/color/alignment applied inline) — for that, see scrivener-formatting. For how styles turn into headings/markup on output, see scrivener-compile. For where styles serialize on disk, see scrivener-format.
- ▌ Scrivener Compile · donnfelker bundleWhen the user wants to compile or export the Draft as a finished manuscript — assemble the chapters into one Markdown or plain-text file with titles turned into headings, or produce a docx/epub/pdf/Fountain document. Use when the user says "compile," "compile to Markdown," "export as Markdown/docx/epub/pdf," "produce the manuscript," "build the book," "assemble the draft," or "compile to Fountain." For section types that drive compile layouts, see scrivener-metadata. For raw per-document text without binder structure, see scrivener-extract. For the named styles that markup compile, see scrivener-styles.
- ▌ Scrivener Extract · donnfelker bundleWhen the user wants to get the raw text out of a Scrivener project — convert a document to Markdown or plain text, export a chapter or the whole draft, or pull synopses and metadata into files. Use when the user says "get the text of this document," "convert this to Markdown," "export this chapter as text," "pull all the synopses," "dump the manuscript to markdown," or "export the outline to OPML/CSV." For an assembled, structured manuscript with proper headings, see scrivener-compile. For reading a single document in place, see scrivener-inspect. For comments and footnotes, see scrivener-annotations.
- ▌ Scrivener Inspect · donnfelker bundleWhen the user wants to open and explore a Scrivener project read-only — see its structure, read a chapter or scene, or locate a document. Use when the user says "show the outline", "what's in this project", "read this chapter/scene", "what's the synopsis of", "find the document about", or "list the binder". For converting/exporting content out, see scrivener-extract; for full-text/field search, see scrivener-search; for word counts and reading-time, see scrivener-stats.
- ▌ Scrivener Metadata · donnfelker bundleWhen the user wants to set or inspect a Scrivener project's labels, statuses, section types, keywords, or custom metadata — "set the status to Done", "label these red", "make these section type Part", "what labels/statuses exist", "tag with keyword" (planned), or "add custom metadata" (planned). Use when the user says "set the status to", "label these", "what labels are there", "change the label", "set section type", or "what section types exist". For editing text/structure (add/move/split), see scrivener-edit; for direct fonts/color/highlight, see scrivener-formatting; for how section types map to compile layouts, see scrivener-compile.
- ▌ Scrivener Integrity · donnfelker bundleWhen the user wants to validate, repair, or back up a Scrivener project, or worries it might be damaged or sync-conflicted. Use when the user says "is this project OK", "validate my project", "check this .scriv", "back up first", "rebuild the search index", "fix checksums", "the checksums are mismatched", or "did a sync conflict happen". For versioning a single document, see scrivener-snapshots; for the writes these checks protect, see scrivener-edit; for the external-folder sync round-trip, see scrivener-sync.
- ▌ Scrivener Snapshots · donnfelker bundleWhen the user wants to version a Scrivener document — capture a revertible copy before rewriting, list earlier versions, or roll a document back. Use when the user says "snapshot this", "save a version", "show previous versions", "roll back this document", "compare versions", or "I want to be able to undo this rewrite later". For editing a document's text/structure (which auto-snapshots first), see scrivener-edit. For validating/backing up the whole package, see scrivener-integrity.
- ▌ Scrivener Formatting · donnfelker bundleWhen the user wants to apply direct formatting to a Scrivener 3 project's editing text — fonts, size, bold/italic/underline/strikethrough, text or highlight color, alignment, line/paragraph spacing, indents, tab stops, lists, tables, or hyperlinks (Manual Ch.15 / the Format menu). Use when the user says "change the font for the whole project", "make this 12pt", "bold this", "italicize", "highlight this", "align center", or "convert to default formatting". This is the editing-font layer, NOT the compile output font. For named, reusable styles, see scrivener-styles. For the font of the exported/compiled manuscript, see scrivener-compile. For script-mode documents, see scrivener-scriptwriting.
- ▌ Scrivener Annotations · donnfelker bundleWhen the user wants to work with Scrivener comments and footnotes — both linked (margin) notes and inline notes. Use when the user says "add a comment", "insert a footnote", "show comments/footnotes", "list the comments on this chapter", "convert inline footnotes to linked", or "who wrote this comment". Detecting that a document has comments/footnotes is available now; adding, editing, deleting, and converting them is planned. For pulling note bodies out into Markdown/text, see scrivener-extract. For editing the surrounding body text, see scrivener-edit. For direct text formatting, see scrivener-formatting.
- ▌ Scrivener Scriptwriting · donnfelker bundleWhen the user wants to write a screenplay or script in Scrivener, work with script mode, or move scripts in and out as Fountain. Use when the user says "screenplay", "script mode", "write a screenplay in Scrivener", "compile to Fountain", or "import a Fountain file". For assembling/exporting the Draft (Fountain out), see scrivener-compile. For bringing a Fountain file in, see scrivener-import. For why a blind font/format change can break script docs, see scrivener-formatting.
- ▌ Scrivener Create Project · donnfelker bundleWhen the user wants to scaffold a brand-new Scrivener project or make a throwaway working copy to experiment on. Use when the user says "create a new Scrivener project", "start a new .scriv", "scaffold a Scrivener project", or "make a copy to experiment on". For the package format itself, see scrivener-format; to bring text into a project, see scrivener-import; to add and restructure binder items, see scrivener-edit.
- ▌ App · donnfelker bundleOperate and inspect already-running Kamal apps without redeploying. Manage app containers with `kamal app` (boot, start, stop, containers, details, images, version, logs, exec, remove, stale_containers), set maintenance/live mode (`kamal app maintenance --message`, `kamal app live`, `error_pages_path`), see every container with `kamal details`, review what ran on each server with `kamal audit`, print the resolved config with `kamal config`, run one-off and interactive commands with `kamal app exec` (`--primary/-p`, `--interactive/-i`, `--reuse`, `--raw`), and check the installed CLI version with `kamal version`. Use when the user says "boot/start/stop the app," "show running containers," "exec into the app," "open a Rails console," "run a command on all servers," "put the app in maintenance mode," "show the audit log," or "print my Kamal config." For shipping releases, see deploy. For reverting a release, see rollback. For log-driver and OTel/file config, see logging. For kamal-proxy, see proxy.
- ▌ Env · donnfelker bundleConfigure environment variables in your Kamal deploy.yml — the `env` block with `clear` values, `secret` references loaded from `.kamal/secrets`, `tags` for per-host overrides, and per-role `env`. Use when the user says things like "add an env var to Kamal," "set DATABASE_URL in deploy.yml," "pass a secret to my container," "how do I keep my API key out of git," "different env vars per server or role," "clear vs secret env," "aliased secrets," or asks about `env.clear`, `env.secret`, `env.tags`, or `kamal secrets fetch`/`extract`. Covers how clear values are passed to `docker run` while secret values are written to an env file on the host. For managing the secret values themselves and password-manager helpers, see secrets. For tagging hosts and defining roles, see servers. For the overall deploy.yml structure, see config.
- ▌ Ssh · donnfelker bundleConfigure how Kamal connects to servers over SSH and tune SSHKit connection handling. Use when the user sets the SSH `user` or `port`, authenticate with specific `keys`/`key_data`, force `keys_only`, control agent forwarding (`forward_agent`), load an OpenSSH `config` file, connect through a jump/bastion host with `proxy` or `proxy_command`, debug connection problems with `log_level: debug`, or tune concurrency and pooling (`max_concurrent_starts`, `pool_idle_timeout`, `dns_retries`) when deploying to many hosts. Also use when they say "kamal can't connect to my server," "permission denied (publickey)," "deploy as a non-root user," "kamal through a bastion/jump host," "SSH timeouts deploying to lots of servers," or "change the SSH port for kamal." These map to the `ssh:` and `sshkit:` blocks in `config/deploy.yml`. For first-time project setup, see setup. For defining the hosts and roles you connect to, see servers.
- ▌ Cron · donnfelker bundleRun recurring, scheduled, or cron jobs on a Kamal deployment. Use when the user says "run a cron job," "schedule a recurring task," "nightly job," "hourly job," "periodic task," "set up cron with Kamal," "scheduled jobs," "run cron in a container," or asks how to keep a crontab running on their servers. Covers defining a dedicated `cron` role under the `servers:` key with a `cmd` that loads a `config/crontab` file and runs `cron -f`, and propagating environment variables into the crontab (cron does not pass them through on its own). For configuring web and worker job roles or targeting hosts/roles, see servers. For running databases, Redis, or other supporting services, see accessories. For setting `env:` values and secrets the jobs need, see env.
- ▌ Hooks · donnfelker bundleWrite and wire up Kamal deploy hooks — scripts in `.kamal/hooks` (docker-setup, pre-connect, pre-build, pre-deploy, post-deploy, pre-app-boot, post-app-boot, pre-proxy-reboot, post-proxy-reboot) that run at fixed points in a deploy, plus the `KAMAL_*` env vars (`KAMAL_VERSION`, `KAMAL_PERFORMER`, `KAMAL_HOSTS`, `KAMAL_RECORDED_AT`) passed to them for audit reporting, deploy notifications, CI gates, and load-balancer draining. Use when the user says "add a deploy hook," "run a script before/after deploy," "post-deploy notification," "fail the deploy if CI hasn't passed," "block deploys unless I'm on the VPN," "run a script when kamal-proxy reboots," "where do hooks live," "hooks_path," "hooks_output," "skip hooks," or "what are the KAMAL_ env vars." Covers the `.kamal/hooks` folder from `kamal init`, naming rules, non-zero exit aborting the command, `hooks_path`/`hooks_output`, and `--skip-hooks`. For the deploy sequence these fire within, see deploy. For builds, see build.
- ▌ Proxy · donnfelker bundleConfigure and operate kamal-proxy, the reverse proxy that gives Kamal zero-downtime deploys on ports 80 and 443. Use when the user wants to route a domain (host/hosts), enable automatic HTTPS via Let's Encrypt (ssl), point the proxy at their app's port (app_port), tune the deploy healthcheck (/up), or adjust response_timeout and buffering — and when they say things like "configure the kamal proxy," "set up SSL for my domain," "add my custom domain," "the proxy isn't routing," "reboot the proxy," "upgrade kamal-proxy," or run kamal proxy boot/reboot/start/stop/details/logs. Covers the proxy config block and the kamal proxy command. For full deploys, see deploy. For enabling the proxy per role, see servers. For starting and stopping the app container, see app. For migrating from Kamal 1.x to kamal-proxy, see upgrade.
- ▌ Prune · donnfelker bundlePrune old Kamal containers and images and control how many Kamal keeps around. Kamal retains the last 5 deployed containers and the images they use; everything older is removed. Use when the user says "prune old images," "clean up old containers," "my servers are running out of disk," "free up space on my servers," "remove unused Docker images," "kamal prune," "how many old releases does Kamal keep," or "change how many containers I keep." Covers `kamal prune all`, `kamal prune containers`, `kamal prune images`, and tuning retention with the `retain_containers` config key (default 5). For running a full deploy, which prunes automatically at the end, see deploy. For inspecting and managing already-running app containers, see app.
- ▌ Setup · donnfelker bundleInstall Kamal and ship your first deploy on a new project. Use when the user is starting with Kamal for the first time and says "install Kamal," "set up Kamal on this project," "kamal init," "get started with Kamal," "deploy my app for the first time," "bootstrap my servers," or "run kamal setup." Covers `gem install kamal`, the dockerized install alias, `kamal init` (config/deploy.yml, .kamal/secrets, .kamal/hooks), writing the first config (service, image, servers, registry, builder, env), filling in .kamal/secrets, bootstrapping Docker with `kamal server bootstrap`, and the first `kamal setup`. For the full set of configuration keys, see config. For routine releases after setup, see deploy. For secrets files and vault adapters, see secrets. For registry providers, see registry.
- ▌ Config · donnfelker bundleUnderstand and write your Kamal configuration in config/deploy.yml. Use when the user says "set up config/deploy.yml," "what goes in my deploy.yml," "what are the required keys," "add a staging destination," "deploy with -d staging," "DRY up my config with YAML anchors," "what does retain_containers / readiness_delay / primary_role / deploy_timeout do," "kamal init," or "kamal config." Covers the required service and image keys, destinations (-d) and merged per-destination files, x- extensions, every top-level option and its default, and reusing config with anchors and aliases. For configuring servers and roles, see servers. For env and secrets, see env. For command shortcuts, see aliases. For a first deployment, see setup.
- ▌ Deploy · donnfelker bundleRun Kamal deploys end to end — a full `kamal deploy` (build, push, pull, boot, health-check on GET /up, zero-downtime cutover via kamal-proxy, then prune) and a faster `kamal redeploy` that skips bootstrapping, kamal-proxy startup, pruning, and registry login. Covers targeting with `--hosts`, `--roles`, `--version`, and `--primary`, plus `--skip-push` and `--skip-hooks`, and managing the deploy lock with `kamal lock acquire/release/status` and `--lock-wait`/`--lock-wait-timeout`/`--lock-wait-interval`. Use when the user says "deploy my app," "kamal deploy," "ship a release," "push to production," "redeploy," "deploy only to web/workers," "deploy a specific version," "skip the build," "skip hooks," "the deploy lock is stuck," or "lock deploys for a maintenance window." For building and pushing images, see build. For pre/post-deploy scripts, see hooks. For reverting a bad release, see rollback. For managing already-running containers, see app.
- ▌ Remove · donnfelker bundleTear down a Kamal deployment with `kamal remove` — it removes the kamal-proxy, app, and accessory containers from your servers and logs out of the Docker registry, prompting for confirmation unless you pass `-y`. Covers full teardown plus removing components piece by piece with `kamal app remove`, `kamal accessory remove [NAME]`, `kamal proxy remove`, and `kamal registry logout`, and scoping a teardown to one environment with `-d/--destination`. Use when the user says "remove my deployment," "tear down the app," "kamal remove," "decommission this server," "uninstall Kamal from these hosts," "delete the proxy and accessory containers," "clean up the staging deploy," "nuke my Kamal setup," or "log out of the registry on my servers." For deploying or redeploying, see deploy. For managing running app containers, see app. For accessory lifecycle and data, see accessories. For the kamal-proxy container, see proxy.
- ▌ Aliases · donnfelker bundleDefine custom command aliases under the top-level `aliases` key in `config/deploy.yml` so a long, repeated `kamal` invocation becomes a single `kamal <name>`. Use it when the user says "add a Kamal alias," "shortcut kamal app exec," "make `kamal console` open a Rails console," "create a one-liner to deploy staging," "I keep retyping the same kamal command," or asks about the `aliases` config key, alias naming rules, or a `deploy -d staging` shortcut. Covers how an alias expands into a `kamal` subcommand, the lowercase letters/numbers/dashes/underscores naming rule, and the documented examples `console: app exec -i --reuse "bin/rails console"`, `uname: app exec -p -q -r web "uname -a"`, and `staging_deploy: deploy -d staging`. For the rest of `config/deploy.yml` and DRYing it up with YAML anchors, see config. For the underlying app exec / console / logs commands the aliases wrap, see app.
- ▌ Logging · donnfelker bundleConfigure how logs flow in a Kamal deployment — the Docker logging driver and options for your app containers (the `logging:` key, where `driver` is passed to Docker as `--log-driver` and `options` as `--log-opt`, e.g. `json-file` with `max-size`), and Kamal's own output loggers that ship deploy/command logs to an OpenTelemetry endpoint or write them to a file on disk (the `output:` key, with `otel.endpoint` and `file.path`). Use when the user says things like "configure Docker logging," "set a log driver," "rotate or cap container logs with max-size," "docker logs are filling the disk," "set logging per role," "ship deploy logs to OpenTelemetry/OTel/OTLP," "send Kamal logs to a collector," or "write deploy logs to a file." For viewing running app and accessory logs with `kamal app logs` / `kamal accessory logs`, see app. For where these keys sit in config/deploy.yml alongside other top-level options, see config.
- ▌ Rollout · donnfelker bundleControl how Kamal boots new containers across many servers during a deploy — rolling the release out in batches instead of restarting every host at once. Use when the user mentions "boot limit," "boot strategy," "rolling deploy," "deploy in batches," "restart a few hosts at a time," "stagger the deploy," "boot 25% at a time," "wait between servers," "thundering herd on deploy," or the `boot`, `boot.limit`, `boot.wait`, or `boot.parallel_roles` config keys in config/deploy.yml. For running the deploy itself, see deploy. For how servers map to roles (which matters for parallel_roles), see servers.
- ▌ Secrets · donnfelker bundleManage secrets for a Kamal deployment — the `.kamal/secrets` file, dotenv variable and command substitution, and the `kamal secrets` vault helpers (1Password, Bitwarden, LastPass, Bitwarden Secrets Manager, AWS Secrets Manager, Doppler, GCP Secret Manager, Passbolt). Use when the user says "kamal secrets," "where do I put my registry password," "manage secrets," "pull secrets from 1Password/Bitwarden/LastPass/Doppler," "kamal secrets fetch/extract/print," "secrets-common," "secrets.<destination>," "secrets_path," "secret vs clear env keys," "RAILS_MASTER_KEY," or "migrate from .env / kamal envify," "migrate local or file-based secrets into 1Password / a vault," or "move plaintext secret files into a password manager." Covers wiring secrets into `env.secret`/`env.clear` in deploy.yml, per-destination secrets files, and aliased secrets. For setting plain non-secret env values, see env. For registry login and KAMAL_REGISTRY_PASSWORD, see registry. For build-time secrets and args, see build.
- ▌ Servers · donnfelker bundleDefine and structure the servers Kamal deploys to — a simple list of hosts, multiple custom roles (such as web and workers/job hosts), the primary role, tagged hosts, and per-role options. Use when the user says things like "add a workers role," "run background jobs on separate servers," "split web and job servers," "configure multiple servers," "set the primary role," "only some servers should run the proxy," or is editing the `servers:` block in `config/deploy.yml`. Covers the implicit `web` role, role-specific `hosts`, `cmd`, `options`, `logging`, `proxy`, `labels`, `env`, and `asset_path`, plus the root keys `primary_role` and `allow_empty_roles`. For the overall config file, see config. For tuning kamal-proxy, see proxy. For tags and secret/clear env, see env. For rollout order across hosts, see rollout.
- ▌ Upgrade · donnfelker bundleWalk through upgrading an existing Kamal 1.x project to Kamal 2.0 with `kamal upgrade` — the move from Traefik to kamal-proxy, the new custom `kamal` Docker network, backward-incompatible configuration changes (the `traefik` block becoming `proxy`, the `app_port` default changing from 3000 to 80, the removed `healthcheck` section, and required `builder` `arch`), and migrating secrets from `.env`/`.env.rb` to `.kamal/secrets`. Use when the user says "upgrade Kamal to 2.0," "migrate from Kamal 1 to 2," "kamal upgrade," "kamal downgrade," "my traefik config stopped working," "how do I do a rolling upgrade," "convert my deploy.yml for Kamal 2," or "keep using Traefik on Kamal 2." Covers validating config with `kamal config`, the `kamal upgrade --rolling` sequence, downgrading back to Kamal 1.9, and running Traefik as an accessory in front of kamal-proxy. For configuring kamal-proxy itself, see proxy. For the `.kamal/secrets` format, see secrets. For the full Kamal 2 config reference, see config.
- ▌ Registry · donnfelker bundleConfigure the Docker registry Kamal pushes your app image to and pulls it from — Docker Hub (the default), AWS ECR, GCP Artifact Registry, a local registry, or any custom/self-hosted registry such as GHCR — and log in or out with `kamal registry login` / `logout`. Use when the user says "set up my Docker registry," "kamal registry login," "configure ECR/GCR/GHCR for Kamal," "where does Kamal push my image," "docker login failed on deploy," "use a private Docker Hub repo," or needs the `registry` block (`server`, `username`, `password`) in `config/deploy.yml` wired to a `KAMAL_REGISTRY_PASSWORD` secret. For building and pushing the image itself, see build. For storing the registry password safely, see secrets. For first-time project setup, see setup.
- ▌ Rollback · donnfelker bundleRoll back a Kamal deployment to a previous image when a release goes bad, and identify or check which versions are deployed. Use when the user says "roll back," "rollback," "revert to the previous version," "go back to the last working deploy," "the deploy is broken, undo it," "which version is running," or "what versions can I roll back to." Covers `kamal rollback [VERSION]`, finding rollback targets with `kamal app containers -q`, and checking versions with `kamal app version` and `kamal version`. For building and shipping new releases, see deploy. For inspecting, stopping, starting, and managing running app containers, see app.
- ▌ Accessories · donnfelker bundleRun and manage accessory services — databases, Redis, search, and other long-lived dependencies your app needs — through Kamal's `accessories:` configuration and the `kamal accessory` command. Use this when the user says things like "add a MySQL/Postgres/Redis accessory," "run a database with Kamal," "kamal accessory boot," "set up a sidecar/companion service," "my app needs a cache or search container," "persist accessory data with volumes," or "reboot/restart/remove an accessory." Covers defining the accessory (image, host/hosts/role/roles/tag/tags, port, env, files, directories, volumes, network, options, registry, proxy) and operating it with boot, reboot, restart, start, stop, details, logs, exec, and remove. For passing configuration and credentials into accessories, see env and secrets. For scheduled jobs, see cron.
- ▌ Server Hardening · donnfelker bundleInspect a Linux server Kamal deploys to and harden it — automated security updates, firewall/port lockdown, auto-blocking of repeated SSH auth failures, and safe SSH configuration — while keeping the ports Kamal needs open. Use when the user says "harden my server," "lock down my VPS," "secure my Kamal server," "audit server security," "close open ports," "set up automatic updates," "is my server exposed to the internet," or before putting a new box into production. Interviews the user before changing anything, explains how to undo every change, and verifies the result afterward. For provisioning Docker itself, see setup. For the servers/roles Kamal targets, see servers. For the SSH settings Kamal itself uses to connect, see ssh. For accessory port exposure, see accessories.
- ▌ Codebase Analyzer · donnfelker bundleWhen the user wants a comprehensive technical analysis of a codebase or project. Also use when the user mentions 'analyze this codebase,' 'technical overview,' 'document this architecture,' 'what does this codebase do,' 'summarize this repo,' 'code audit,' 'architecture review,' 'codebase walkthrough,' or 'analyze this project.' Performs a multi-phase analysis covering architecture, code quality, testing, and infrastructure, producing a detailed markdown report targeting engineers. For quick code searches or single-file reviews, see standard editor tools.
- ▌ Find Past Conversation · donnfelkerSearches past Claude Code session transcripts under ~/.claude/projects/ to recover a previous conversation by recalled phrase, error string, or topic. Use when the user says 'search your history for', 'find the conversation about', 'look through your past sessions', 'did I ever finish that work on', 'what did we decide about X last week', 'remind me what came out of that session', or otherwise asks you to recall a prior session. Returns session ID, project, date, and a 2-4 sentence summary; on request, also reports the outcome (commit, branch, PR opened or merged). Not for searching the current codebase, current PR comments, or external systems like Slack/Jira — for those, see codebase-analyzer and address-pr-comments.
- ▌ Generate Release Notes · donnfelker bundleThis skill should be used when the user asks to "generate release notes", "generate changelog", "create release notes", "write changelog", "what changed since last release", "prepare release notes", "update changelog", or "summarize changes from git history". Parses conventional commit messages to produce categorized, well-formatted release notes or changelog entries.