Skip to content

Harmix/open-stanley / open-stanley/skills/stanley

stanley

Verified

Your head of content. Use this whenever the user wants help with LinkedIn or X (Twitter) — writing or scheduling a post, finding things to comment on, turning a meeting, voice note, or Slack thread into a post, reviewing why a post did or didn't work, planning the week's content, or asking "what should I post". Also use it for anything that mentions Stanley, ghostwriting, personal brand, founder-led content, building in public, or growing followers, even if the user doesn't say "post". Start here; it routes to the other open-stanley skills and holds the operating rules they all share.

FileKindSize
SKILL.mdskill md14.2 KB
references/capabilities.mdmarkdown3.3 KB
references/platform-access.mdmarkdown4.0 KB
references/recommended-mcps.mdmarkdown5.5 KB
references/recommended.mcp.jsonconfig2.0 KB
references/research-linkedin-2026.mdmarkdown6.7 KB
references/scheduling.mdmarkdown8.6 KB
references/vault-backends.mdmarkdown6.8 KB
references/verify-live.mdmarkdown2.2 KB
references/why-these-rules.mdmarkdown2.1 KB
scripts/stanley-auditexecutablescript24.6 KB
scripts/stanley-briefexecutablescript6.4 KB
scripts/stanley-chartexecutablescript14.5 KB
scripts/stanley-previewexecutablescript5.8 KB
scripts/stanley-statsexecutablescript14.9 KB
scripts/stanley-traceother6.3 KB
scripts/stanley-vaultexecutablescript35.1 KB

references/scheduling.md

View on GitHub
# Scheduling the rituals

Two modes. Pick one at onboarding and write it into `my-human.md` as `mode: laptop|cloud`.

## Laptop mode (default)

Every job runs **on the user's own computer** with the vault as a plain folder (ideally inside a desktop-synced Drive/iCloud/Dropbox folder), the user's MCPs, and their browser (Claude in Chrome), so each run does its own LinkedIn/X reading; there is no queue and no drain. Which scheduler you get depends on the surface, and the two behave differently when the laptop is closed:

**Cowork → cloud routine bound to the computer** (option B below). Cowork's Scheduled tab has no local scheduler; this is the path for Cowork users and what this plugin was built on.

**Claude Code Desktop → local routine** (option A). **Code** tab → Routines → New routine → **Local**, working folder = the vault, permission mode set to auto-approve after the first "Run now" (click "always allow" on each prompt). Needs Desktop 1.1.5368 or newer. Prompt = `templates/scheduled-tasks/<job>.md` with `_preamble-local.md`. This runs on the machine itself, so the plugin is visible at `${CLAUDE_PLUGIN_ROOT}` and the vault is the working folder: no `.stanley-scripts/` install, no mount paths. Documented behaviour (code.claude.com/docs/en/desktop-scheduled-tasks): a run that comes due while the computer sleeps is *skipped*, not switched off; "when the app starts or your computer wakes, Desktop checks whether each task missed any runs in the last seven days. If it did, Desktop starts exactly one catch-up run for the most recently missed time"; skipped runs show in the task's history with the reason; and Settings → Desktop app → General → **Keep computer awake** prevents idle-sleep (a closed lid still sleeps). The plugin's own `missed` step still runs inside each job for jobs that Desktop's one-catch-up rule leaves behind. No watchdog needed. Not available from Cowork.

**B. Cloud routine bound to the computer** (Cowork → Scheduled → "Require this computer" + "Work in a folder"). The Cowork path. The run reaches the vault only through a mount (`$HOME/mnt/<folder>`), cannot see the plugin (hence `.stanley-scripts/`), and — the important part — a task that comes due while the computer is offline is **switched off** (`suspension_reason: device_absent`) and never switched back on; a fire from the cloud runs it without the computer. Run it with the watchdog and the self-repair step below; together they cover the switch-off, though not a same-morning catch-up. Prompt = `_preamble-laptop.md`.

Cost either way: runs happen only while the computer is awake. Fine for people whose laptop is open during the day; wrong for people who need runs with the laptop closed for days — that is cloud mode.

Concurrency: tasks that overlap append to the same jsonl files; appends are line-atomic, nothing to merge. Desktop local routines are additionally serialised (a run is skipped if another scheduled task is still running), so keep the 22:00 scout and recap a few minutes apart.

## Cloud mode

Tasks run in Anthropic's cloud without "Require this computer". They have the user's MCPs but no browser and no local folders, so:

- the vault must be reachable through an MCP: a folder in the Google Drive the Drive MCP sees (`drive` backend, mirror procedure in `vault-backends.md`; one MCP call per file, so pull only the job's files and issue the calls in one turn), or Notion;
- browser-only work (LinkedIn reads, comments, analytics, X replies) is parked in `ledger/local-queue.jsonl` with an expiry and worked by the `drain` task, which does require the computer.

Git is not a cloud-mode option in Cowork today: scheduled tasks have no repository field, and the cloud git proxy only injects a credential for repos listed as a session's source, so a private repo cannot be cloned from a scheduled run. Git remains fine for Claude Code users who run the jobs from their own machine or CI (`vault-backends.md`).

## Setting up

**Claude Code Desktop, local routine (A):** Code tab → Routines → New routine → Local; name, instructions from the template with `_preamble-local.md`, model, schedule preset (ask Claude in a Desktop session for the 1st-of-month or 22:00 variants), working folder = the vault, permission mode auto-approve, then Run now once and always-allow the prompts.

**Cowork, cloud routine bound to the computer (B):** Sidebar → Scheduled → New: name, prompt (from `templates/scheduled-tasks/<job>.md` with the mode's preamble), model, frequency, **Permissions: Automatically approve** (otherwise each file write asks), and for laptop mode the computer toggle plus the vault folder. A task created from a chat session inherits that session's model; set it explicitly (see below). Each run is its own session with the user's connectors and installed plugins.

**Claude Code → Routines** (`/schedule`): same prompts; laptop mode is the natural fit there too.

Every template starts with the mode's preamble: find the vault, probe capabilities, `run-start`, `stanley-audit selftest`, do the job, `run-end` with `--shown/--queued/--browser`, deliver the result in the session output (or via the user's `notify` capability). The delivered message says what it looked at and what it found even when the answer is "nothing".

Times are the user's local time; Cowork takes local times, and `create_trigger` takes a cron that is UTC unless it starts with `CRON_TZ=<zone> ` (for example `CRON_TZ=America/Toronto 0 10 * * *`). Always write the zone: a bare UTC cron set in summer fires an hour early all winter, and `stanley-vault missed` then reports runs that did happen. A run can also start with no folders attached even though the task lists them (`get_device_info` shows `connectedFolders: []`); ask for the vault once with `device_request_folder_access`, which waits on the computer for about two hours, say so in the report and the notification, and do the parts that need no vault. Cowork adds a fixed stagger of a few minutes to every task (a 22:00 job fires at 22:04–22:07 every day), so a run that is "late" by under ten minutes is on time. Defaults (from `strategy.md`): soapbox 08:00, scout 10:00 and 22:00, recap 22:00, mine Saturday 18:00, weekly drafts Sunday 10:00, orbit + strategy check-in on the 1st, and the cloud watchdog at 07:30 and 12:30 (the only task without "Require this computer").

## The cadence ladder

Each rung reads a signal that actually accumulates at that frequency. Putting a question on the wrong rung is how a content loop stops improving: ask "is this shape working" weekly and you are reading noise, ask "what did the user cut from my draft" monthly and you have thrown away three weeks of the clearest feedback there is.

| Rung | Job | Reads | Produces |
|---|---|---|---|
| Continuously | every run | the user's corrections, in the moment they are made | a diff and a standing instruction the next draft reads |
| Daily | soapbox, scout, recap | today's feed, today's numbers, open threads on both sides | material, comments, a reaction |
| Weekly | mine (Sat) → tune + drafts (Sun) | the week's meetings; then repeated corrections and the experiment's arms | stories, then promoted rules, then three posts |
| Monthly | orbit + strategy check-in | 30 days of metrics, who kept showing up, one creator studied from outside | one strategy change, a verdict, one new format to test |

The learning is not concentrated in one job: corrections apply immediately, the weekly run promotes what recurred, and the monthly is where a change to the strategy itself gets proposed. Nothing waits a month to be noticed.

## Which model runs each job

The skills carry the judgment; the runs mostly execute them.

| Job | Model | Why |
|---|---|---|
| soapbox, scout (both), recap, mine, monthly, drain, watchdog | Sonnet | reading, linting, one short message; no writing in the user's voice |
| weekly drafts, longform | Opus | writes in the user's voice and runs the critic and fact-checker |

Change it per task in Scheduled → task → model. Model ids accepted in September 2026: `claude-sonnet-5`, `claude-opus-5`.


## Light schedule (8 GB laptops, or a machine that froze during a run)

A run drives the same Chrome the user works in, and on an 8 GB laptop a scan during working hours can freeze both. Onboarding reads the machine's RAM and, at 8 GB or less, sets `schedule: light` in `strategy.md`; the same tasks then run as: one scout a day at a time the user is away (lunch or evening) with the recap folded into it, mine and weekly drafts on the weekend, the monthly check-in as is, and no browser runs in the user's working hours. If a user says a run made the computer slow, move that task out of their working hours first, then drop the second daily scout.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall