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 an AI-generated synthetic voice.

Episodes

  1. 1 day ago

    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. 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.

  2. 12 Sept

    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. 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.

  3. 10 Sept

    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. 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.

  • 3 Episodes

About

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 an AI-generated synthetic voice.

Information

  • Creator
    OCDevel
  • Years Active
    2026
  • Episodes
    3
  • Rating
    Clean
  • Copyright
    © All rights reserved 2026, OCDevel
  • Show Website
    OCDevel Claude Code