DEV Community: Pesimmoq

I built an AI coworker that works while I sleep, using nothing but Claude Code

Pesimmoq — Fri, 16 Oct 2026 03:06:05 +0000

Claude Code has a feature called routines: a cloud session that starts on a cron schedule, clones a GitHub repository, uses the MCP connectors you've attached on claude.ai (Slack, Gmail), and exits. No server, no extra tooling.

I used it to build a watcher that, every morning at 09:00 JST, reads 12 pages of Anthropic's official docs, diffs them against yesterday, posts a Japanese summary to Slack, and, when a change affects my books, pushes a draft article to GitHub. The motivation was embarrassing: I write guides about the Claude API, and I missed the Haiku 5.5 launch for five days. A local script had been posting "changed" notices to Slack every day. Nobody was reading them.

Everything below is as of October 16, 2026. Routines are moving fast; check the official docs for the current shape.

What a routine is

A 5-field cron expression (UTC) or a one-time timestamp starts a cloud session. Minimum interval is one hour.
The session starts with your GitHub repository cloned. It cannot see your local files, local environment variables, or local services.
It can use MCP connectors attached on claude.ai (Slack, Gmail, ...). MCP servers configured only in Claude Code are not available.
Model, allowed tools, and the prompt go in one JSON object. The prompt is read from scratch every run, so it has to be self-contained.
Create, update, run-now, and run logs are available through an API (from inside Claude Code, the RemoteTrigger tool). Deleting is web-only.

What I built

volvox-ltd/claude-docs-watch (private)
├── pages.json        # 12 official pages (the .md versions on platform.claude.com)
├── watch.py          # fetch -> compare with state/ -> diffs/<date>/ + result.json (stdlib only)
├── state/            # yesterday's text
├── diffs/            # unified diffs per day
├── drafts/           # article drafts the routine writes when a change matters
├── log/              # daily summaries
└── ROUTINE_PROMPT.md # the instructions the routine receives

The design decision that matters: Python finds the diff; the model only judges and writes. Asking a model to "read these 12 pages and tell me what changed" means reading ~300k characters every morning and missing things. watch.py produces the diff files; the model reads only those.

The routine definition

{
  "name": "claude-docs-watch 09:00 JST",
  "cron_expression": "0 0 * * *",
  "enabled": true,
  "job_config": {"ccr": {
    "environment_id": "env_…",
    "session_context": {
      "model": "claude-sonnet-5-5",
      "sources": [{"git_repository": {"url": "https://github.com/volvox-ltd/claude-docs-watch"}}],
      "allowed_tools": ["Bash", "Read", "Write", "Edit", "Glob", "Grep",
                        "mcp__Slack__slack_send_message", "mcp__Slack__slack_search_channels"]},
    "events": [{"data": {"uuid": "…", "session_id": "", "type": "user", "parent_tool_use_id": null,
                "message": {"role": "user", "content": "<the prompt below>"}}}]}},
  "mcp_connections": [{"connector_uuid": "…", "name": "Slack", "url": "https://mcp.slack.com/mcp"}]
}

Sonnet 5.5 is plenty: the daily job is "read a diff and summarize it".

The prompt

The repository https://github.com/volvox-ltd/claude-docs-watch is already cloned in your
working directory (branch main). Configure git with user.name 'docs-watch-bot' and
user.email 'contact@volvox-ltd.com' before committing.

You are the daily docs watcher for persimmoq, an author of Claude API guides. You run
inside a fresh clone of this repository every morning. Work in Japanese for all
human-facing text.

Do these steps in order.

1. Run `git pull --rebase origin main` first (the checkout can be stale). Then run
   `python3 watch.py` from the repository root and read `result.json`.

2. If `changed` is empty and `errors` is empty: append one line `<date> no changes` to
   `log/<YYYY-MM>.md`, commit it, push to `main`, and send ONE short Slack message to the
   private channel #mail (channel_id C0BEY8JUCDR). Then stop.

3. If there are changes: read every file listed under `changed[].diff`. Ignore pure
   formatting changes. For the substantive changes, write a summary with, per page: the
   page key, 1–3 sentences on what changed, and a judgement on whether it affects the
   author's published material (the books on Claude 5 migration and on Managed Agents,
   and the articles on those topics). Mark each page as affected / not affected / check.

4. Write that summary to `log/<YYYY-MM>.md` under a heading `## <date>` and post the same
   summary to the Slack channel. Keep it under 2,000 characters; link each page URL.

5. If at least one page is affected and the change is a new model, a new price, a new
   breaking change, a deprecation/retirement, or a new Managed Agents feature: write ONE
   draft article in `drafts/<date>-<short-slug>.md` (front matter with published: false),
   quoting the exact new text from the diff where it matters, linking the official page,
   and ending with a section "What I verified" containing only a placeholder for the author
   to fill in after testing against the live API. Do not invent behavior that the
   documentation does not state. Do not claim anything was tested.

6. `git add -A`, commit, push to `main`. If the push fails, retry once after `git pull --rebase`.

7. If any `errors` are present, mention them at the end of the Slack message.

Never publish anything outside this repository. Never edit files under `state/` by hand.

Step 5 is the point. The coworker drafts; it never publishes. The draft ends with an empty "What I verified" section that a human fills in after running the real API. The prompt says "do not claim anything was tested" for the same reason.

What happened on the first two runs (October 16)

Run 1 (23 seconds, 8 turns). Sandbox allocated, repo cloned, watch.py found no changes, log appended, push succeeded, Slack post failed with channel_not_found. The agent searched for the channel, found nothing, and fell back to a mobile push notification. Cause: the Slack connector on claude.ai was attached to a different workspace. I reconnected it and put the channel ID in the prompt.

Run 2 (51 seconds, 9 turns). Slack post succeeded. Then the push was rejected: the sandbox's checkout predated run 1's commit. The agent ran git pull --rebase, saw its own commit was a duplicate line, discarded it, and exited cleanly. Reasonable, but I added git pull --rebase as step 1 so it doesn't happen every morning.

The run log is available from the API with timestamps for every tool call, error, and the final message. You can read everything the coworker did while you were asleep.

Three things that broke

The GitHub App must be installed on the organization. Connecting GitHub on claude.ai was not enough for a private repo under an org; creating the routine failed with repo_access_denied until I installed github.com/apps/claude on the org and granted the repo.
A connector points at one workspace. With several Slack workspaces, it was attached to the wrong one. Use channel IDs, not names.
The checkout is not always fresh. A routine that pushes should pull first.

Cost and limits

Runs use the allowance of my Claude subscription plan; I have seen no separate API charges. A no-change run is a few thousand tokens. Check the pricing page for your plan.
Minimum interval one hour. Not a tool for "poll every five minutes".
No access to your local machine. Anything the job needs must be in the repo or reachable from the cloud.
Deletion is web-only.

Three ways to build the same thing

	Claude Code routine	Managed Agents	cron + API on your machine
Runs on	Anthropic's cloud	Anthropic's cloud	your machine
Setup	one JSON	Agent + Deployment	plist/crontab + script
Billing	plan allowance	tokens + session time ($0.08/h)	API tokens
Best for	periodic jobs that fit in a repo + connectors	long-running agents that need a hosted toolbox	jobs that need local files or local credentials
Notify via	connectors (Slack/Gmail), push	webhooks	your own

I use all three. This watcher is a routine; my production agent platform is Managed Agents; the weekly Search Console report, which needs local OAuth tokens, stays on launchd.

Takeaways

A Claude Code routine gives you a cron'd cloud agent with a repo and Slack, with no infrastructure.
Split the roles: Python detects, the model judges and writes, a human publishes.
What breaks is permissions and connections, not the prompt.

The 400-errors-when-migrating guide this watcher protects is here: Claude 5 Migration Guide (PDF, $19).

Claude Opus 5.5 / Sonnet 5.5: 5 settings that return 400 when you only change the model name

Pesimmoq — Thu, 15 Oct 2026 01:47:16 +0000

Claude Opus 5.5 shipped on September 22, 2026 and Claude Sonnet 5.5 on September 28. If you take code that runs on Opus 5 or Sonnet 5 and change only the model string, one of these five settings will return an HTTP 400. All five are in Anthropic's official migration guides; I reproduced the first one against the live API on October 6 and pasted the exact responses below.

A static scanner that finds these in your code (file:line) is open source: claude5-migration-kit.

python scan.py path/to/your/app --target opus-5-5
python scan.py path/to/your/app --target sonnet-5-5

1. `thinking: {"type": "disabled"}` returns 400

Opus 5.5 cannot turn thinking off. On Opus 5 you could send disabled at high effort or below. On Opus 5.5, both disabled and enabled + budget_tokens are rejected at every effort level:

"thinking.type.disabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

Omit thinking (same as adaptive) and lower output_config.effort where you used to disable thinking.

Sonnet 5.5 replaces disabled with between_tools. It is the lowest thinking setting: no up-front thinking, only the short notes between tool calls.

To turn thinking off on this model, send "thinking": {"type": "between_tools"} instead of {"type": "disabled"}. The model does not think before responding. The short updates it writes between tool calls come back as thinking blocks.

# Sonnet 5
client.messages.create(model="claude-sonnet-5", max_tokens=16000,
                       thinking={"type": "disabled"}, output_config={"effort": "xhigh"}, messages=[...])

# Sonnet 5.5
client.messages.create(model="claude-sonnet-5-5", max_tokens=16000,
                       thinking={"type": "between_tools"}, output_config={"effort": "high"}, messages=[...])

between_tools works only at high effort or below (400 with xhigh / max), takes no other field (display, budget_tokens and block_binding are 400), and cannot be combined with per-message effort changes. In a request without tools it answers without thinking at all, so move multi-step reasoning tasks back to adaptive.

Both responses above are verbatim from the API (max_tokens: 64, no charge for a 400).

2. Forced `tool_choice` returns 400

{"type": "any"} and {"type": "tool", "name": ...} are rejected on both models, including on the token-counting endpoint:

tool_choice: type "tool" and "any" are not supported for this model.

Use tool_choice: {"type": "auto"}, mark the tool strict: true so the input matches the schema, and say in the prompt when to call it. Strict tools are capped at 20 per request and need additionalProperties: false on every object. If you only wanted JSON, use structured outputs (output_config.format) instead of a tool. On Amazon Bedrock, Opus 5.5 and Sonnet 5.5 have no structured outputs (strict included): send auto, name the tool in the prompt, and validate the input yourself.

3. `computer_20251124` returns 400 on the Claude API and Google Cloud

Declare computer use as the computer_toolset_20260801 toolset (no beta header). Sonnet 5.5 also rejects computer_20250124 on every platform. Amazon Bedrock keeps computer_20251124. The fine-grained-tool-streaming-2025-05-14 header is a 400 next to a toolset entry; set eager_input_streaming: true on the tools that need it.

4. Editing conversation history returns 400 (or drops the thinking)

The preserved-thinking check that Fable 5.1 introduced now applies to both models: thinking blocks are bound to the model and to the conversation prefix. Editing system, tools or earlier turns and then sending the thinking blocks back is a 400 on accounts created on or after August 31, 2026 (enforced by default), or a dropped block otherwise.

Keep history append-only. Change instructions with a mid-conversation {"role": "system", ...} message.
Change tools with tool_addition / tool_removal; with the inline-tools-2026-09-15 beta you can include full definitions.
To shrink history, use on-demand compaction (compact-2026-09-04): you receive a signed summary block and send it first on the next request.
Sonnet 5.5 thinking blocks are also account-bound: sent from another organization they are silently dropped.

5. Sonnet 5.5 rejects Opus 4.x / Sonnet 5 as advisors

With a Sonnet 5.5 executor, the advisor must be Opus 5, Opus 5.5, Sonnet 5.5, Fable 5 / 5.1 or Mythos 5 / 5.1. Opus 4.8 / 4.7 / 4.6, Sonnet 5, Sonnet 4.6 and Haiku 5.5 return 400. Advice comes back encrypted as advisor_redacted_result.

Changes that don't fail, but matter

Opus 5.5 defaults to effort: medium (Opus 5: high). Carry over a request without effort and it runs one level lower. Anthropic reports that 5.5 at medium matches or beats Opus 5 at high; start there and sweep.
Sonnet 5.5 effort levels are recalibrated. Start coding agents at medium, general work at high, max_tokens 128K with streaming.
Text between tool calls now arrives in thinking blocks, empty at the default display. A UI that streams progress notes goes quiet with no error. Use display: "updates" (beta header thinking-display-updates-2026-08-18).
More refusal categories. Opus 5.5 adds bio; Sonnet 5.5 has cyber, bio, frontier_llm, reasoning_extraction, general_harms. Server-side fallback only retries cyber and frontier_llm on Sonnet 5. Since September 24, refusals before any output in bio / frontier_llm / reasoning_extraction are billed.
Prompt cache minimum is 512 tokens (Sonnet 5: 1,024). Sonnet 5.5 cache reads dropped to $0.10/MTok on October 7 (0.05x).
Priority Tier is not supported on Opus 5.5.
Sonnet 4.5 retires on November 30, 2026. Replacement: Sonnet 5.5.

Summary

#	Symptom	Fix
1	`disabled` → 400	Opus 5.5: omit + lower effort. Sonnet 5.5: `between_tools` (≤ `high`)
2	`tool_choice: any` → 400	`auto` + `strict` + name the tool in the prompt
3	`computer_20251124` → 400	`computer_toolset_20260801`
4	edited history → 400	append-only; system messages, tool_addition, compaction
5	advisor → 400	Opus 5 / 5.5, Sonnet 5.5, Fable

The seven things that already broke when moving from 4.x to Opus 5 / Sonnet 5 (temperature, budget_tokens, prefill, max_tokens eaten by thinking, content[0] on refusals, empty thinking text, the ~30% tokenizer increase) still apply.

The full guide, with per-model checklists, the prompt re-tuning table across 4.7 → 4.8 → Opus 5 → Fable 5.1 → 5.5, prompt caching and history design, and verification scripts, is a 70-page PDF: Claude 5 Migration Guide ($19). Written with AI assistance; every API behavior was checked against the live API or the official docs before publication.

Official sources: Opus 5.5 migration guide · Sonnet 5.5 migration guide