OCDevel Claude Code

OCDevel

Take Claude Code from its first useful change in your terminal to a repeatable software delivery workflow. For working developers who already ship applications and use Git, this course starts with setup, giving Claude a task, inspecting the diff and checking the result. Build on that session with project instructions, skills, hooks, MCP connections and context management. Later lessons connect parallel agents and Git worktrees to GitHub issues, pull requests and review-and-fix loops, then develop testing and deployment workflows with GitHub Actions and AWS. Permissions, sandboxing, cost controls and observability are taught alongside the automation they support, so you can judge what a run changed and investigate a failure. Concrete examples explain the commands, settings and checks behind each workflow; earlier techniques return as parts of larger systems. Claude Code news and practical shortcuts cover changes that affect coding work, setup or cost. The curriculum builds toward an issue-to-deployment pipeline, including rollout decisions and incident response. This show's audio is narrated by AI-generated synthetic voices.

Play

Open in

29 episodes
weekly
English

Episodes 29

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

Saturday · length unknown
5. A Check That Runs Without Being Asked
Moving the type check from something you remember to run into a PostToolUse hook that Claude Code runs after every edit, feeding errors back so the agent fixes them before finishing. Also covers this fortnight's Claude Code changes to hook failure handling, sandbox fixes and headless time limits. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website Turning the type check into a hook The routine still relied on memory for two steps: running the type check and running the tests. An example shows the gap. A request to add an optional note field to list items looks fine in the browser. Then the compiler fails on a shared-view component the agent never opened, because the note was marked required by mistake. CLAUDE.md is an instruction the model can skip. A hook is a command Claude Code itself runs at a defined moment, every time. The chapter wires the project's no-emit TypeScript check to the PostToolUse event with an Edit|Write matcher, as described in the hooks guide. It lives in the committed project settings file so everyone working in the repository gets it. Exit codes carry the meaning, per the hooks reference: Zero stays silent. Two hands the compiler's stderr back to Claude to fix. Any other code is a non-blocking warning. The build starts small: a hook that only logs "hook fired." It is confirmed with /hooks, and a file read is shown not to trigger it. The logger is then replaced with a committed script. The script reads the event JSON with jq, skips non-TypeScript files, and checks the whole project, because the note bug lived in an untouched file. It runs through CLAUDE_PROJECT_DIR with a 120-second timeout. The test suite stays out of the hook because it is too slow to run after every edit. The hook is proven by breaking types on purpose, then by making a correct edit that should produce no output. Where hooks go wrong Four risks are covered: Cost: every second the hook takes is added to every edit. Setup failures: a missing tool or uninstalled dependencies should exit one, not two, so the agent isn't sent to fix errors it didn't cause. Repair loops: start from a clean type check, and step in if the agent goes in circles. Trust: hooks run with your permissions without a prompt, so review them like code. disableAllHooks turns off custom hooks but not hooks from an organization's managed settings. The work ends with a commit and one line in CLAUDE.md explaining where the type errors come from. This fortnight's releases The Claude Code changelog covers versions 2.1.286 through 2.1.288: PreToolUse and PermissionRequest hooks now fail closed. Shell sandbox escapes through nested bash -c and symlinked writes are patched. Background time limits are strictly enforced in headless runs, CI and the Agent SDK. Up arrow on an empty prompt restores a request cleared with Control C. /code-review accepts a max-findings option.
September 26 · length unknown
4. A Change Too Big for One Session
How to carry a multi-step change across several Claude Code sessions by keeping its plan, decisions and progress in committed files. It covers continue and resume, reading /context, compaction and what it loses, and a deliberate fresh start, plus recent fixes to resuming and compaction. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website A change that outlasts one sitting The conversation with Claude Code is not memory you can rely on. The repository is. The worked example is a done checkbox for items in the shared-list app. It needs a schema migration, a way to set the flag through the database client, a checkbox and crossed-out style in the React interface, and tests. The check at the end is to tick an item, reload the page, and see it still ticked. Planning happens in plan mode. The plan goes into a committed file of numbered steps, each with a check that proves it is done. A second file records decisions and rejected options, such as choosing a boolean column over a status text field because the app has only two states and a boolean cannot hold a typo. Stopping halfway and coming back After two committed steps the session ends. claude --continue reopens the most recent session. claude --resume opens a picker with preview, rename and filter, all described in the guide to managing sessions. Resuming restores the conversation, tool results, model and recent checkpoints. It does not restore launch-time folders or elevated permission modes. It also brings back stale guesses and knows nothing of hand edits made since. When the context window fills /context breaks usage into messages, memory files, tool schemas and skills, and the messages row is the one that grows. Compaction replaces older turns with a summary. The root CLAUDE.md is reread and the active goal survives, but exact names and the reasons behind decisions tend to get lost. You can steer the summary with instructions after /compact or with a compact instructions section in CLAUDE.md. A summary is still written by the model. When it and the committed decisions file disagree, the file wins. A deliberate fresh start The handoff has four steps: Have the agent update the progress file. Check each tick against git log and the code. Commit the file. Run /clear. The new session reads the task files, git log and the diff, then reports the state of the work before editing anything. If its account is wrong, the gap is in the files. Keep plans to steps and checks. Rules for every task go in CLAUDE.md, and notes for one task go in the task files. Auto-memory stays on your machine and is not committed, so it cannot replace the task files. Recent fixes to resume and compaction The Claude Code changelog records several relevant changes: 2.1.274: Resuming a compacted session no longer drops its goal. Goal- or hook-driven sessions compact instead of crashing with "prompt too long" on the second overflow. Damaged transcripts are repaired, or resume stops with an error that suggests rewinding. 2.1.282: Resuming long sessions is faster. This does not make the session aware of edits made after it last looked. Context accounting: Tool-server instructions now get their own row in /context. 2.1.283: Compaction shows an elapsed timer and a live count of summary tokens. Claude Opus 5.5 defaults to a one-million-token window, so auto-compaction triggers later, which makes the handoff habit more important.
September 19 · length unknown
3. Fixing a Bug in Code You Have Never Read
A vague pasted-text bug report gets turned into a reproduction, then traced with an agent that is blocked from editing anything, then fixed one narrow diff at a time. Includes how plan mode actually enforces its limits, how to check an agent's account of your code, and the case where the tests pass but the browser is still broken. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website A vague report becomes a reproduction "It keeps saying the name is too long when it isn't. Only happens when I copy the name in from somewhere else." No file, no error text, no browser. The work starts by turning that sentence into four written things: exact steps, exact data, observed result, expected result. The data is the clue — a line copied from a notes app, nine visible characters, carrying a trailing space and a newline. Reproduced twice from a clean state, so there is a before to measure against. Trace first, edit later The code that enforces the length rule has never been opened. Instead of asking for a fix, the request is a trace that forbids edits — done in plan mode, where file editing and writing tools are mechanically blocked rather than merely discouraged. Ways in: the permission-mode flag at launch, Shift+Tab to cycle modes, the slash-plan command, or a default mode set in settings. The caveat: plan mode gates edits, not process execution. Read-only shell commands run unprompted from a built-in allowlist you cannot edit; anything else goes to a safety classifier unless you turn off auto mode during plan. Launching with dangerously-skip-permissions overrides the gate entirely. Tool-level alternatives: allowed-tools or disallowed-tools flags, or edit and write in the deny list. The trace may be delegated to the built-in read-only Explore subagent, which keeps file contents in its own context and returns a summary. Two consequences: intermediate work vanishes from the transcript, and the built-in Explore and Plan subagents skip the project instructions file to save tokens — so your constraints must be restated in the prompt. Ninety seconds of checking The account names a form component, a route handler, and a validation function comparing raw length before trimming. That is a claim until the files are opened. A confident specific you cannot find means stopping and re-asking, not waving it through — the details arrived as one story, not independently. Green tests, broken browser A failing test comes before the fix, read to confirm it fails for the right reason. Three lines change. The suite passes. The browser still fails, because the form component counts characters too. Why a wide diff was wrong the first time and justified the second. Then a branch, one commit, and a message naming the behavior. Three things that went wrong, each with a one-line detection method. Recent changes worth knowing A persistent side-by-side diff pane from slash-diff; grep and glob now returning explicit errors instead of silent "no matches" on large result sets; slash-ultrareview handling a clean tree; Control+Enter to interrupt tool work and submit at once; and AGENTS.md as a fallback when no CLAUDE.md is present.
September 12 · length unknown
2. Writing the Instructions Your Next Session Will Actually Read
This chapter explains how to write and test a CLAUDE.md file so a fresh Claude Code session knows a project's commands, layout, and definition of done without being told each time, and covers a recent change to which parts of a session actually read that file. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website The founding charter The core of this chapter is CLAUDE.md, the file Claude Code loads automatically at the start of every session before your first request arrives — no attaching, no pasting, just a file sitting at the project root or inside the .claude directory that gets read on its own. It walks through the four places instructions can live — the shared project file, a personal file in your home directory, an untracked local variant, and organization-wide settings — and explains that Claude Code doesn't let the narrowest file override the others; it concatenates all of them into context, broadest first, and leans on the model to treat the more specific instruction as the one that wins. From there the chapter builds an actual file for a shared-list app: starting from a /init draft, keeping only the commands that aren't obvious (the dev server, the type check, the one authoritative test command), naming the manual click-through journey that tests alone can't replace, writing down two or three real architectural constraints, and stating flatly what "finished" means. It explains why the file should stay short — it's re-injected on every turn, so bloat taxes every future question — and points to /context, /doctor, and /memory as ways to check what's loaded and trim what doesn't earn its place. It draws a hard line between guidance, which the model can still talk itself past, and real enforcement through a permissions deny list, and closes with a repeatable loop for testing whether an instruction actually changes agent behavior: fresh session, one-line request, watch what's skipped, edit one sentence, retest. What changed in how instructions get loaded A shorter section covers a real gap in that mental model: the built-in Explore and Plan subagents skip reading CLAUDE.md and skip checking Git status entirely, while custom subagents you define still inherit it. It also notes a new flag for passing subagent rules via a file instead of a command-line string, and a fix in recent releases removing an approval prompt that used to stall scripted runs using organization-delivered instructions — all catchable with the same /context check.
September 10 · length unknown
1. Your First Real Change, Made by an Agent and Checked by You
This chapter installs Claude Code, opens it inside a small shared-list web app, and walks through fixing one real bug — blank items being addable — end to end: describing the project, requesting a narrow change, reading the diff, running tests, manually verifying the behavior, adding a test, and committing. It closes with two recent changes to the tool, Auto permission mode and default model updates, and what to check about each. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website Getting the tool onto your machine The chapter walks through installing Claude Code as a standalone application rather than through npm, explaining why the native installer (fetched with curl or the PowerShell script) is the recommended path — it updates itself and needs no Node.js runtime — while noting Homebrew, WinGet, and Linux package repositories as valid alternatives, per the setup instructions. It covers system requirements, the sign-in flow through a browser, and the built-in diagnostic reached with slash doctor for fixing installation and network problems, drawn from the CLI reference. Opening a real project Once launched inside a small shared-list web app, the chapter shows the workspace trust prompt, the live session display showing model and context usage, and the two permission modes — Manual, which asks before every write or command, and Auto, now the default for Pro, Max and Team plans, which only interrupts for destructive operations. It draws on the permissions documentation and the interactive mode guide to explain what each mode actually shows you and why reading a diff before approving it matters. Making one change and proving it The core of the chapter is a single fix: stopping blank or whitespace-only list items from being added. It shows the tool describing the project first, proposing a small diff, running the test suite after a command-approval prompt, and then a manual click-through of the app to confirm the behavior actually changed — because a passing suite only proves what it already tested. A new test is added, deliberately watched failing and then passing, before a single readable commit closes the loop. What changed recently in Claude Code A short section flags two changes that affect a first session directly: Auto mode becoming the default permission mode on Pro, Max and Team plans, and Sonnet 5 becoming the default model with support for pinning a default model via environment variable, both listed in the Claude Code changelog and the what's new page.
September 5 · length unknown
Moving the Instruction Out of the Prompt
A working session on a Next.js and Postgres project is used to demonstrate moving repeated instructions — formatting, migration safety, route-handler conventions — out of prompts and into hooks, slash commands, skills, subagents, and MCP servers, followed by a rundown of recent Claude Code releases and model updates. Episode page & show notes Visit website Turning repeated instructions into repository rules The chapter walks through five places to put an instruction so it stops living in the same three sentences typed at the top of every session. A hook is a shell command wired to a fixed point in the loop — format the changed file and run the typecheck after every write, no memory required — and the Claude Code hooks documentation covers how they can also block an action outright, which is distinguished from a flat permissions deny rule by the fact that a hook can inspect state before refusing. A custom slash command turns a retyped personal habit, like a pre-commit diff review, into a named file the whole team shares. A skill goes further: a folder whose short description is always visible but whose full body — doctrine plus a real example file — only loads when the work actually matches, exactly as laid out in the Claude Code skills documentation. A one-off subagent handles the heavy-input, light-output question — search forty files, report three paragraphs — per the Claude Code subagents documentation. And an MCP server connects to a system outside the repo entirely — an issue tracker, a read-only database — as described in the guidance on connecting Model Context Protocol servers, best added only for a system you keep pasting from. The chapter closes on the risk of over-wiring — too many hooks, skills and servers making a failure's cause unreadable — and the fix of stripping back to a bare session and re-adding one layer at a time. This week's releases A short rundown of recent changes: a new diagnostic command flags which skills are eating context, new models default to a million-token window with a much cheaper cache-read price, and a supply-chain fix stops a cloned repo from silently redirecting a client's configuration.
August 29 · length unknown
Deciding What a Session Is Allowed to Do
This chapter builds a layered permissions system for coding sessions — allow, ask, and deny rules split across user, project, and local settings files — so routine actions stop requiring attention while irreversible ones still get a pause, then extends the idea into plan mode and a rundown of recent tool updates. Episode page & show notes Visit website The founding charter The core problem: every permission prompt spends a little of your attention, and by the thirtieth approval in a session you've stopped reading before you say yes. The fix isn't discipline — it's deciding, calmly and in advance, what a session may do freely, what it must ask about, and what it may never do, written into a file rather than negotiated in the moment. That file lives in three places, layered from general to specific: a user-level settings file that travels with you across every project, a committed project-level file that belongs to the whole team and shows up in code review, and an uncommitted local file for machine-specific quirks. More specific layers override broader ones, though a managed policy file (the kind an IT department deploys) sits above all of them and can't be overridden. Inside these files, permission rules sort into three lists. Allow lets a matched action through without a prompt — pure convenience, buying back attention for boring, repeatable calls like running tests or reading files. Deny blocks an action outright with no prompt and no override, reserved for anything irreversible: touching production data, reading credentials, force-pushing or rewriting git history. Ask sits in between and always interrupts. Deny beats everything; ask beats allow. Applied to a typical TypeScript/Next.js/Postgres project, this produces a short, deliberate file — narrow allow rules for test, typecheck and lint commands, ask rules for writes outside the repo and package installs, deny rules for env files, cloud credentials, and destructive git or database commands. The payoff is counterintuitive: locking things down doesn't feel restrictive, it makes the prompts that remain actually mean something, because the noise is gone. The same logic scales up through plan mode, which stops a session from editing anything while it reads, traces and proposes — useful for unfamiliar code or multi-file changes, skippable for one-line fixes. An approved plan is not a contract; work in progress can reveal files the plan never listed, so the habit is to compare the plan's file list against what actually changed. Built-in commands like permissions, config, context, and status let you inspect and edit the live configuration mid-session rather than restarting — which matters because configuration drift is real: a rule quietly added to a local file weeks ago can silently override what the team believes is running. Checking the resolved permissions at the start of a session catches this before it costs anything. The show's news beat, skewed hard A new restricted mode for the command-line tool strips out command execution, code running and web fetching, and confines edits to the working directory — and it ignores your settings files entirely, offering a hard ceiling for working with untrusted code. Authentication can now log in directly against console billing alongside SSO and email options. Smaller additions include a readline-style keybinding option, per-prompt frontmatter controls for effort level and cache duration, and a statusline metric exposing rolling five-hour and seven-day rate-limit usage. A native VS Code extension brings inline diffs and sidebar progress, and community projects bundling sub-agents, skills and hooks — including one collection called Everything Claude Code and a planning-focused framework called Superpowers — offer working examples of the extension layer ahead.
August 25 · length unknown
One Session, Driven by Hand
This chapter walks through running a single Claude Code session end to end on a real app — writing a strong first prompt, reading and correcting the model's plan, building a trustworthy project memory file, and cleanly resuming work the next day — then closes with a roundup of recent pricing, rate limit, and SDK changes. Episode page & show notes Visit website Learning your codebase, one session at a time The core of this chapter is a single hands-on walkthrough of running one Claude Code session properly, using an ordinary TypeScript/Next.js app with Postgres behind it as the running example. It opens with the problem of a session that keeps rediscovering the same facts about a repository — how to run the tests, where things live — because nothing was ever written down for it to read. From there it builds out a full first prompt: naming the goal in outcome terms, scoping what not to touch, pointing at the real files or an existing pattern to imitate, and stating a concrete done-condition such as a test that fails without the change. It covers how to read the plan that comes back — checking the file list, the silent assumptions, and whether the approach matches the project's actual conventions — and makes the case for interrupting the moment an assumption is wrong rather than after several files have been built on top of it. From there it turns to project memory: generating a starter file with the init command, then cutting it down to only what's true and verified — real commands, real layout, real conventions — while stripping out prose, philosophy, and anything nobody will maintain. It explains how these memory files stack rather than override each other, how nested files load lazily, and how imports work. It closes with finishing a unit of work cleanly and picking it back up, covering the continue and resume flags, the from-pr option, and the naming and forking commands that make sessions easier to find again. This week in Claude Code The main item is pricing: Sonnet 5's standard rates are now set at $2 per million input tokens and $10 per million output tokens, cancelling a planned increase, alongside removal of peak-hour throttling and doubled five-hour rate limits on paid plans. A recent changelog entry adds separately configurable prompt cache lifetimes for main sessions and subagents, finer usage telemetry, an organisation-configurable model picker, and a fix for remote tool servers dropping their connection in print mode. Recent releases also brought a design-drafting command preview, a Concise output style, persistent goal conditions across resumes, and an environment variable for setting a default model. On the SDK side, the Python Agent SDK picked up in-process Model Context Protocol server support and a structured error type, and the platform Python SDK reached version 1.0 on a new HTTP transport.
August 25 · length unknown
A Session That Already Knows Your Project
A hands-on walkthrough of driving Claude Code on a real codebase — writing and maintaining a project memory file, running a scoped bug fix from request to committed diff, and resuming sessions the next day — followed by a quick roundup of recent CLI, desktop, and SDK releases. Episode page & show notes Visit website The founding charter The core loop for driving Claude Code by hand: open a session in your project, ask for a change in plain English, review the diff, run tests, commit. The real subject is the gap between a session that starts cold and one that already knows your codebase, and how a request that names a file, a current behaviour, a wanted behaviour, and a constraint outperforms a vague ask, because the model fills any gap with its own taste rather than yours. That gap gets closed with a Markdown memory file, written by running the in-session init command, which surveys the package manifest, test setup, build, and git history before drafting instructions. The file should stay short: how to run the app, how to run the tests, and two or three conventions a new contributor always gets wrong — nothing derivable by reading the code. These files stack from broadest to most local at session start, and the automatically maintained per-project memory file is capped at roughly two hundred lines or twenty-five kilobytes, while everything else is not. A worked example — moving email validation from submit-time to on-blur — shows the loop end to end: Claude reads the form and schema, proposes a scoped fix, runs the test command from memory unprompted, surfaces a failing existing test, and waits for a human call on which behaviour is correct. The diff stays small because the request stayed narrow. Sessions persist as transcripts on disk automatically, restarted with a continue flag for the most recent one or a resume flag for a picker across past sessions, with branching and renaming available mid-session — though transcripts older than thirty days get cleaned up by default. The closing warning: an unmaintained memory file rots into a wiki of contradictory, stale instructions that Claude will obey confidently anyway, so it needs treating as short, living, and checked every quarter. The show's news beat, skewed hard The current CLI release adds a per-loop breakdown to the usage command and separate cache lifetime settings for main sessions versus subagents, plus a model-picker setting and managed pricing for enterprise contracts. Recent releases also fixed lost plan-mode state on restarted remote workers and added automatic resumption after a rate limit, with a matching auto-continue toggle on the desktop app's limit notification. A research-preview design command now opens an editable canvas for implementing frontend interfaces, and the Python SDK has hit version one with a CLI migration helper for teams still on the old client conventions.
August 23 · length unknown
Moving your unattended Claude Code runs onto a runner inside your own AWS account
This chapter walks through moving Claude Code's automated runs off GitHub's shared machines and onto a runner living inside a private AWS network, covering the setup, the trade-offs against self-managed runners, and the most common way such a setup silently stalls, then closes with a roundup of recent Claude Code releases and pricing changes. Episode page & show notes Visit website Getting a runner inside your own network The problem is simple to state: a workflow can label an issue, wake Claude Code, have it read your repo and instructions, write code, run tests, and open a pull request — all cleanly — and then stop dead the moment it needs something only your own network can give it. A database in a private subnet, an internal service, a preview deploy: none of it is reachable from a machine sitting on GitHub's own infrastructure, because that's exactly how private subnets are supposed to work. The fix is ownership of the machine itself. A GitHub Actions runner never gets connected to — it phones out, holds an outbound connection open, and waits for work. That means it can sit deep in a private subnet with no route to the internet and still pick up jobs, and everything the job then does reaches out from inside your network. Two ways to get there are laid out and compared directly: letting AWS CodeBuild's runner mode spin up a container per job and throw it away when done, or standing up and registering your own instances or Kubernetes pods. The recommendation is the managed option for almost everyone, with real per-minute and startup-time figures backing the trade-off, plus a full walkthrough — connecting the account to GitHub, creating the project, wiring subnets and a NAT path with interface endpoints, the exact runs-on label syntax the run identifier and attempt number require, authenticating through the project's own role versus an explicit federated handshake, and why ephemeral runners matter (a permanent, non-ephemeral runner can quietly hand one job's leftover cloud credentials to the next). It closes with the single most common failure — a job stuck silently "waiting for a runner" — and the two-minute check for it: the label, then the webhook delivery log. What shipped recently A short round of Claude Code updates, several of which land right on this setup. The self-hosted runner command gained a shutdown-delay flag and two ways to supply proxy authorization, relevant the moment runners sit behind an authenticating proxy in a locked-down subnet. The same release fixed prompt caching for gateways using a custom base address, and fixed a memory leak in long unattended sessions. The introductory Sonnet 5 pricing has been made permanent, cancelling the planned September increase. Two default behaviors changed — todo/task-tracking tools are now off by default, and forked subagents are now the default — each with an environment variable to reverse it. The bundled API skill was cut from over 200,000 tokens of context down to roughly 25,000. And the temporary boost to weekly usage limits has expired.
July 8 · length unknown
GitHub Actions Foundations for Unattended Claude Code Runs: Triggers, Permissions, OIDC, Timeouts, and Concurrency
Every GitHub Actions primitive is the automated substitute for a human's presence, so when nobody's at the keyboard you must declare a tight timeout-minutes (the default is a six-hour burn) and an explicit permissions block. We walk the full workflow anatomy, triggers, secrets, GITHUB_TOKEN scopes, and end-to-end AWS OIDC auth for a Claude Code run. Episode page & show notes Visit website Act III opens with the CI plumbing under every headless Claude Code run. The frame: each GitHub Actions primitive covers a failure mode a human would otherwise handle live. Claude Code GitHub Actions is built on the Claude Agent SDK and runs on GitHub's own runners. News Claude Code CLI v2.1.204 (Jul 8): single-change release fixing hook events not streaming during SessionStart hooks in headless sessions, which could idle-reap remote workers mid-hook. Safe to keep heavier SessionStart hooks again. (changelog, Releasebot) claude-code-action v1.0.166 (Jul 6): drop buffered inline comment when posted live (#1412), modern noreply co-author email (#1369), symlinked CLAUDE.md config snapshot (#1441), preserve repeated --add-dir (#1256), propagate curl install failures (#1241). (release notes) CLI v2.1.202 (Jul 6): Dynamic workflow size in /config; workflow.run_id / workflow.name OpenTelemetry attributes; /review back to single-pass, multi-agent moved to /code-review. CLI v2.1.200 (Jul 3): default permission mode now labeled "Manual" — set an explicit --permission-mode in CI. Tutorial: GitHub Actions foundations Workflow anatomy (on, permissions, jobs, runs-on, steps). Triggers: workflow_dispatch, schedule/cron (UTC, 5-min min, default-branch only, 60-day public auto-disable), repository_dispatch, issues/pull_request (synchronize), workflow_call. Jobs run in isolated VMs — matrix, needs, if, and outputs pass state. Secrets vs variables vs environment secrets. The Feb 2023 read-only GITHUB_TOKEN shift and the permissions: allowlist (unlisted scopes become none; id-token: write required for OIDC). Full AWS OIDC auth with the sub-claim security lever. Concurrency groups, timeout-minutes (360-min default), and caching. Pitfalls: GITHUB_TOKEN can't trigger downstream CI, silent 403s, pull_request_target injection, the 6-hour burn, fork PRs lack secrets, OIDC sub mismatch, and silently disabled crons. Pin actions to full SHAs.
July 3 · length unknown
Fleet observability for parallel Claude Code: built-in OpenTelemetry, Grafana cost dashboards, and per-agent spend attribution
Wire every parallel Claude Code session, subagent, and headless run into one OpenTelemetry feed and watch per-agent token burn and dollar cost on a Grafana dashboard, with stall detection that catches a looping agent before it drains the budget. The one trap: the same opt-in log flags that give you attribution can ship raw prompts and pasted credentials to your observability backend, and one shared API key collapses every worktree's cost into a single lying bucket. Episode page & show notes Visit website This week's Claude Code releases, then a full tutorial on fleet observability and cost dashboards for parallel runs. News (2026-06-26 to 2026-07-03, from the Claude Code changelog): Claude Sonnet 5 is now the default (v2.1.197, Jun 30): native 1M-token context, promo pricing $2/$10 per Mtok through Aug 31. Shows in /model. (Some trackers misdate it to Jul 1 - the docs changelog is authoritative.) Background subagents by default (v2.1.198, Jul 1): agents keep running and notify on finish; claude agents runs now commit, push, and open a draft PR from a worktree; Notification hook fires agent_needs_input/agent_completed; Explore agent inherits the session model (capped at opus); new /dataviz skill; the /agents wizard was removed. Stacked skills + retry controls (v2.1.199, Jul 2): /skill-a /skill-b loads up to 5; CLAUDE_CODE_RETRY_WATCHDOG raises retries to 300; fixed subagents reporting usage-limit errors as success, plus a Linux daemon that killed all agents every ~50s. Org defaults + durability (v2.1.196, Jun 29): admin org default model, stream idle watchdog on by default, background sessions survive restarts. Tutorial - Fleet observability and cost dashboards: Native OpenTelemetry, opt-in via CLAUDE_CODE_ENABLE_TELEMETRY=1 - Monitoring docs. Metrics like claude_code.cost.usage, claude_code.token.usage, claude_code.active_time.total; log events; beta trace spans (claude_code.interaction root). Reference stack: ColeMurray/claude-code-otel (Collector to Prometheus + Loki to Grafana, six-section dashboard). Cost tools: /cost slash command (Manage costs); ccusage (npx ccusage@latest, ccusage blocks --live); org-level Usage and Cost API and the per-user Claude Code Analytics API. Headless mode: claude -p --output-format json returns total_cost_usd, num_turns, session_id; guard with --max-turns and --max-budget-usd. AWS worked example: Analyzing Claude Code usage with CloudWatch and OpenTelemetry. Pitfall: OTEL_LOG_USER_PROMPTS=1 / OTEL_LOG_TOOL_DETAILS=1 leak prompt text and credentials (Elastic Security Labs); one shared API key breaks per-worktree attribution.
June 25 · length unknown
Label-Driven Runs: Trigger a Claude Code Implement Pass From a GitHub Label
Apply one named label to an issue and Claude Code runs an unattended implement pass that pushes a branch and opens a PR. The label gates who can fire it, not who wrote the issue body, so the spec you splice into the prompt is still attacker-controllable and you must treat it as data. Episode page & show notes Visit website A hands-on tutorial on wiring anthropics/claude-code-action so that applying a GitHub label kicks off an implement pass with no @claude mention. Plus the week's Claude Code news. News (June 21-25, 2026) claude-code-action: v1.0.157, v1.0.156 (June 24), v1.0.155 (June 23). Merged fixes per the releases page: filter PR reviews/inline comments to trigger time (#1385), allow @ in branch names (#1411), format-turns content-type fallback tests (#1421). Bump to v1.0.157. CLI v2.1.191 (June 24): new /rewind to recover a session cleared with /clear; stopped background agents stay stopped; comma-separated hook matchers fixed; MCP retry logic; ~37% lower streaming CPU. CLI v2.1.187 (June 23): new sandbox.credentials setting blocks sandboxed commands from reading secrets, org model restrictions, remote MCP 5-min idle timeout (CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT), /install-github-app workflow setup now optional. Billing: the planned move of Agent SDK / Claude Code usage onto a separate credit is NOT taking effect; being reworked with advance notice. Tutorial: label as the trigger GitHub fires a labeled activity on the issues event. Use on: issues: types: [labeled] and gate with if: github.event.label.name == 'claude-implement' — without the if, every label burns a run. See Events that trigger workflows. Two gates: the action's label_trigger: "claude" input, or workflow-level types: [labeled] + an if. v1 auto-detects automation mode when you set an explicit prompt. v1 consolidated inputs: direct_prompt/override_prompt/mode → prompt; model/max_turns/allowed_tools/custom_instructions → claude_args. Pin @v1, not @beta. Known bug #210: early label_trigger failed on a missing LABEL_TRIGGER env mapping. PRs aren't auto-created (per the action's security docs): Claude pushes a branch and links the PR page. Wire gh pr create yourself. GITHUB_TOKEN can't fire downstream workflows (docs, #25565): a default-token PR won't start CI, and a bot-applied label won't fire the labeled workflow. Use actions/create-github-app-token@v2. Label as a state machine: claude-implement → remove first, add claude-working → claude-done/needs-human. Idempotent + a concurrency group keyed on issue.number. See gh issue edit. The pitfall: splicing issue.body into the prompt is the lethal-trifecta injection surface. The label gates who labels, not who wrote the body. Gate authors, treat body as data, shrink blast radius. Cron alternative: poll with gh issue list --label, run headless claude -p. See the GitHub Actions docs.
June 21 · length unknown
Auto-PR Workflows: Turning a Green Headless Run Into an Open Pull Request
Once a headless Claude run passes, the last rung is delivery: branch, commit, push, and open the PR with nobody at the keyboard. The trap that bites everyone is the PR whose own CI never runs, because GitHub won't trigger workflows for events made by the default token. Episode page & show notes Visit website Act II continues. We turn a passing headless Claude Code run into an open pull request with no human at the keyboard, and we walk straight into the pitfall that breaks most first attempts. News (June 17–21, 2026): v2.1.183 — Auto mode now blocks destructive git commands you didn't ask for (git reset --hard, git checkout -- ., git clean -fd, git stash drop), blocks git commit --amend on commits it didn't make this session, and guards terraform destroy / pulumi destroy / cdk destroy. New attribution.sessionUrl setting omits the claude.ai link from commits and PRs. New /config --help; in the toggle, Esc now SAVES. v2.1.181 — /config key=value inline from the prompt (works in -p and Remote Control), sandbox.allowAppleEvents, CLAUDE_CLIENT_PRESENCE_FILE to mute mobile pings, bundled Bun 1.4, line-by-line streaming, auto-retry on dropped connections. v2.1.185 — Stream-stall hint reworded and now fires after 20s instead of 10s. Tutorial — Auto-PR: Two homes for the logic: a local/cron bash script wrapping claude -p then git + gh, or a GitHub Actions workflow governed by permissions:. Prefer a deterministic shell GATE (tests green? non-empty diff? existing PR?) and scope Claude to the edit. Headless docs, CLI reference. Always git push -u origin <branch> before gh pr create — the push prompt is fatal with no TTY. Actions needs contents: write AND pull-requests: write; missing the second is a silent 403. The big one: PRs opened with the default GITHUB_TOKEN do not trigger downstream workflows. Use a GitHub App token so the PR's own CI actually runs. Idempotency: deterministic branch names + gh pr list --head guard. Empty-diff guard with git diff --quiet. --allowedTools prefix footgun: Bash(git push *) with the trailing space, not Bash(git push*). The pull_request_target footgun only bites on untrusted fork code; internal nightly auto-PR is on the safe side.
June 17 · length unknown
Blast-Radius Engineering in Claude Code: Bounding What an Unattended Run Can Touch with IAM, OIDC, and Branch Protection
Prevention sometimes fails, so engineer the blast radius: layer scope limits on permissions, credentials, network, accounts, spend, and merge rights so one bad turn stays cheap. The trap is assuming "it only opens a PR" is safe, because a PR triggers CI that can hold your secrets. Episode page & show notes Visit website A two-part episode for people running Claude Code unattended. News. Anthropic shelved the planned Agent SDK and claude -p billing split on June 15, the day it was due to land, telling customers "nothing changes for now" and promising a reworked plan with advance notice (The New Stack, digitalapplied, the-decoder). Headless and SDK usage keep drawing from your subscription pool, so don't migrate automation to API keys for this reason. v2.1.178 adds Tool(param:value) permission rules (e.g. Agent(model:opus)), nested .claude/skills auto-load, and runs subagent spawns through the auto-mode classifier (changelog, release). v2.1.179 is fixes only: mid-stream drop recovery, WSL2 scroll restore, and a sandbox glob fix on Linux. Backdrop: short outages and elevated Opus 4.8 errors (StatusGator, TechTimes). Tutorial: blast-radius engineering. The prior episode built layers that prevent a bad action. This one assumes prevention fails and bounds the damage. Defense in depth across five layers: Claude-side: permission deny/ask/allow ordering, defaultMode dontAsk, the sandbox (failIfUnavailable, allowUnsandboxedCommands false, denyRead on credentials), PreToolUse hooks, --bare, --max-turns. Plus CVE-2026-25725 (SecurityWeek): why you bound damage outside the tool. AWS: least-privilege IAM, permissions boundaries, Access Analyzer policy generation, STS short-lived creds, SCPs, egress control, and Budgets actions. GitHub: scoped GITHUB_TOKEN, OIDC to AWS, branch protection, and environment reviewers. The pitfall: "it only opens a PR" ignores pull_request_target, which runs fork code with base-repo secrets (2i2c, OpenSSF). See the spotipy and openlit advisories.
June 13 · length unknown
Autonomous-Run Safety in Claude Code: Sandboxing, Prompt-Injection Defense, and Audit Logs
Before you let Claude run unattended, you need three independent enforcement layers, because a prompt injection can change what the agent wants to do but never what the harness allows. This episode wires up the sandbox, the deny rules, and the audit trail into one locked-down headless run. Episode page & show notes Visit website Act II continues. This is the gate you put up before you let Claude Code run unattended. We build three independent enforcement layers, because they fail differently, and you need all three. The three pillars Sandboxing. The native Bash sandbox (docs) enforced by the OS: Seatbelt on macOS, bubblewrap + socat on Linux/WSL2 (sudo apt-get install bubblewrap socat). Default write is the working dir only; default read is the whole computer except denied dirs, which still includes ~/.aws/credentials and ~/.ssh unless you add denyRead. Network has no domains pre-allowed; the proxy does not inspect TLS, so broad domains like github.com are exfil paths. Key knobs: failIfUnavailable, allowUnsandboxedCommands, excludedCommands, CLAUDE_CODE_SUBPROCESS_ENV_SCRUB. Permissions & modes. Evaluation is deny then ask then allow, first match wins (Permissions). dontAsk is the unattended gem (fully non-interactive). --dangerously-skip-permissions is the anti-pattern: it replaces the prompt with nothing and offers no injection protection (Permission modes). Watch the gitignore-anchor footgun: /Users/alice/file is project-relative, not absolute. Prompt-injection defense. The lethal trifecta (private data + untrusted content + exfil channel). The patched Claude Code GitHub Action attack (Microsoft, oddguan, GMO Flatt): the Read tool bypassed the Bash sandbox and leaked /proc/self/environ. Fixed in claude-code-action v1.0.94. Plus auto mode, Security, and PreToolUse hooks. Audit logs. On-disk JSONL transcripts (.claude directory, unencrypted at rest), headless --output-format json with total_cost_usd (headless), and OpenTelemetry emitting claude_code.tool_decision and claude_code.tool_result out of the box. We close with one copyable locked-down headless workflow and the primary pitfall: the silent success of --dangerously-skip-permissions. Forward pointer: blast-radius engineering, next episode. News: Fable 5 and Mythos 5 pulled under a US export-control directive; Claude Code falls back to Opus 4.8 (switch with /model). Plus the v2.1.172–2.1.176 changelog hardening: enforceAvailableModels, nested sub-agents to 5 levels, and fixed permission-path matching.
June 10 · length unknown
Review-and-Fix Loops: The Cold Critic, the Fixer, and the Gate Before Full Autonomy
A code reviewer who wrote the code is the worst possible reviewer, so wire a cold-context critic against an Edit-capable fixer and an objective test gate. The one pitfall that breaks it: a fixer that games the gate by rewriting the tests instead of the bug. Episode page & show notes Visit website Act II of the agentic coding ladder: the trust rung. We build a review-and-fix loop where one agent critiques a diff while another repairs it, with a human still approving the result. This is wired entirely out of primitives from earlier episodes: subagents, skills, slash commands, hooks, the orchestrator pattern, headless mode, the Agent SDK, git worktrees, and the @claude GitHub Action. The core idea: a reviewer who wrote the code is the worst reviewer. You want a generator, then a critic in a fresh cold context, then a fixer, then an objective gate. Concepts and sources: Building Effective Agents (evaluator-optimizer, iteration caps) Reflexion and Self-Refine LLMs Cannot Self-Correct Reasoning Yet (intrinsic self-correction degrades without an external anchor) Multi-agent research system (verify high-stakes outputs with a separate pass) Building it in Claude Code today: Custom subagents in the agents folder under dot-claude Code Review and security-review ultrareview cloud fleet Headless mode with json-schema findings Agent SDK for the multi-round loop GitHub Actions for the hosted version The pitfall: the fixer reward-hacks the test gate, documented in ImpossibleBench and EvilGenie. Bound it with tool separation, immutable tests, and a PreToolUse hook. News: Claude Fable 5 lands in Claude Code via v2.1.170, plus v2.1.169 safe mode and the /cd command.
June 7 · length unknown
The Claude Code GitHub Action: @claude on Issues and PRs (Setup, Auth, Triggers, Pitfalls)
Install the claude-code-action via /install-github-app, then @-mention Claude on any issue or PR to get a committed branch and a ready-to-click PR link. The biggest gotcha: fork PRs on public repos can't read your ANTHROPIC_API_KEY, so the workflow silently does nothing unless you use pull_request_target on the base branch or Workload Identity Federation. Episode page & show notes Visit website This episode kicks off Act II: moving from power-user-at-the-keyboard toward supervised automation. A human still approves everything here. We set up the Claude Code GitHub Action so you can write @claude on an issue or pull request and have Claude read the repo, make changes, commit to a branch, and hand you a pre-filled PR link. Setup. Fastest path: run /install-github-app from inside the Claude Code CLI. It installs the Claude GitHub App, writes the workflow YAML under .github/workflows/, and creates the repo secrets. Needs repo admin, and works for direct Anthropic API users (cloud providers need manual config). Manual setup: install the App, add ANTHROPIC_API_KEY (or CLAUDE_CODE_OAUTH_TOKEN from claude setup-token for Pro/Max), and copy examples/claude.yml into your workflows folder. Triggers. Default phrase is @claude (word-boundary matched, so not @claude-bot). Default events: issue_comment, pull_request_review_comment, pull_request_review, and issues. Adding a prompt: input flips it into automation mode (runs without a mention). Permissions. Minimal block: contents: write, pull-requests: write, issues: write, id-token: write. Add actions: read for CI log access. Arbitrary Bash is off by default; enable specific commands via --allowedTools. Pitfalls. Fork PRs can't read secrets on public repos (prompt-injection defense). Fix with pull_request_target + checkout of the base branch, Workload Identity Federation, or a same-repo if: guard. Claude's own github-actions[bot] comments can't trigger another run (loop protection). Use a PAT/App token or workflow_run. Branch protection can reject direct pushes; allow claude[bot] to bypass or accept the create-branch-then-PR flow. Every mention is a full agent run on your key. Batch requests, cap with --max-turns. As of 2026-06-06, latest release is v1.0.140. v1.0 replaced v0.x's mode/direct_prompt/max_turns with prompt + claude_args. Builds on the prior Headless Claude Code episode: the Action is essentially headless Claude triggered by a GitHub event.
June 6 · length unknown
Headless Claude Code: drive claude -p and the Agent SDK from your scripts
Take Claude Code out of the terminal and into your scripts. Print mode and structured JSON, the Claude Agent SDK in TypeScript and Python, chaining sessions, and the permission-and-cost discipline that keeps an unattended run from deleting your repo or running up an API bill once the June 15 billing change lands. Episode page & show notes Visit website The Act II pivot from driving one Claude Code session by hand to calling it from a script: same agent, same loop, but you pre-decide what's allowed in code before the run ever starts. The tutorial. Print mode (claude -p) as a Unix citizen — piping stdin (and the 10MB cap), the --bare flag for deterministic CI runs, and structured output via --output-format json (the result, session_id, total_cost_usd, and subtype fields), stream-json with the init and api_retry events, and --json-schema for typed data instead of prose. The run-bounding flags — --max-turns, --max-budget-usd, --model/--fallback-model, --allowedTools/--permission-mode — and chaining turns with --resume/--session-id/--fork-session. Why a model refusal can't be caught from the exit code. Copyable patterns: a commit-message generator (and the space-before-* permission footgun), a stdin-fed typo linter that needs no Bash permission, and a locked-down CI run. Then the Claude Agent SDK (renamed from the Claude Code SDK in September 2025): query() and the options that mirror the CLI flags, custom in-process tools, the Python ClaudeSDKClient, hooks and subagents in code, and the can_use_tool permission callback. Full reference in the headless docs and the migration guide. The pitfalls. --dangerously-skip-permissions in an unattended run — how to recognize the silent-success failure, and the least-privilege allowlist that replaces it — and the June 15, 2026 billing change that moves Agent SDK and claude -p usage to a separate metered credit pool, plus how to watch total_cost_usd and bound it. News. Claude Code 2.1.166 (June 6): a fallbackModel setting (up to three), thinking-off controls, a "*" deny-all glob, and a cross-session permission-escalation fix; latest is 2.1.167 (changelog). 2.1.163 added additionalContext from Stop hooks, /plugin list, and version-pinning settings. And Claude Opus 4.1 is deprecated, retiring on the API August 5, 2026 (release notes). Earlier episodes referenced: CLAUDE.md and --resume, permissions and plan mode, custom slash commands and hooks, skills, subagents and the orchestrator pattern, MCP servers, cost and rate-limit engineering and evals, ultraplan/ultrareview, and parallel sessions with git worktrees.
June 4 · length unknown
The orchestrator pattern: promote one Claude Code session to dispatch waves of subagents
Stop hand-wiring parallel sessions and let one Claude become the dispatcher: it spins up waves of subagents that work in parallel and report back. Your first session that runs a team instead of a task, plus how to keep the roughly fifteen-times token bill from running away with you. Episode page & show notes Visit website The first rung of running a fleet instead of a session: promote one Claude Code session to a lead that dispatches waves of subagents, which work in parallel and report back. The tutorial. The orchestrator-worker pattern, drawn from Anthropic's multi-agent research system writeup (Opus lead plus Sonnet workers beat single-agent Opus by ~90%, at roughly 15x the tokens of a chat, with effort scaled to query complexity). How it maps onto Claude Code today: the Agent tool (renamed from Task in v2.1.63) spawns workers in their own context windows that return only a summary; the two-level limit (subagents can't spawn subagents, so "waves" are batches); foreground vs background workers and Ctrl+B. Writing a custom subagent in your project's agents folder, with the frontmatter that turns earlier episodes' cost levers into per-worker dials: model (Sonnet/Haiku workers under an Opus lead), maxTurns, effort, tools, skills, mcpServers, and isolation: worktree (the callback to last episode's worktrees). A worked fan-out migration: Explore to map files, partition by file ownership, complete delegation prompts, structured returns, and a synthesis-and-test stage, plus the packaged /batch skill (5-30 worktree subagents, a PR each). Where it scales next: agent teams and dynamic workflows. The pitfall: token blowup from over-orchestrating, with the blank-context worker, file collisions, and the lead losing the thread underneath it. How to recognize each on /usage and /context, and how to bound it. The rule: orchestrate for breadth and independence, stay single-agent for depth and coupling. News. Claude Code 2.1.162 (June 3): a waitingFor field in the agents JSON, Read deny rules now hide files from Glob/Grep, and Windows path-matching fixes (changelog). API changes June 2: no billing on zero-output refusals and a max_tokens cap on the advisor tool (release notes). Earlier episodes referenced: subagents, skills, CLAUDE.md, context windows, MCP servers, cost and rate-limit engineering, and parallel sessions with git worktrees.

Showing 1–20 of 29 episodes