Skip to content
Sign in
Artwork for OCDevel Claude Code
Technology

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.

Play
Open in
  • 27 episodes
  • English

Episodes 27

NewestOldestLongest
All7Unplayed7In progress0Played0
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • June 2 · length unknown

    Cost and rate-limit engineering for Claude Code, plus evals so your prompts don't rot

    The two skills most Claude Code power users skip: keeping token spend and rate limits predictable, and regression-testing the prompts, skills, and commands you depend on so they can't quietly get worse. What the cost command actually measures, the model and caching levers that really move the bill, reading your usage with ccusage and OpenTelemetry, and a small eval suite built on headless print mode and promptfoo. Episode page & show notes Visit website The last rung of doing everything by hand: spend less, and keep what you've built from quietly getting worse. Cost and rate-limit engineering. Why the /cost command is meaningful only on a pay-as-you-go API key and misleading on a subscription (use /status and /usage instead), and the gotcha where a stray ANTHROPIC_API_KEY bills you through the API while your Max plan sits unused. The two stacked limit windows (the five-hour rolling window and the seven-day weekly caps, including the separate cap on the top model), drawn from Anthropic's usage and limits docs and the Pro/Max plan guide. Current per-token pricing and the clean five-times pattern (output is 5x input; each model tier is ~5x cheaper than the one above), prompt caching at a 90% read discount and why a stable CLAUDE.md keeps the cache hot, and the batch path at 50% off. Reading your real usage with ccusage and exporting OpenTelemetry metrics to a dashboard. The levers that move the bill most: /model, /compact and /clear, subagents that return summaries, --max-turns, and the thinking-budget setting (thinking tokens bill as output). More in Manage costs effectively. Evaluating your own prompts, skills, and agents. Why your setup drifts (model updates, CLAUDE.md edits, accumulating instructions) and how regressions stay silent. Building a tiny eval suite with headless print mode: a fixtures folder, a pinned model, and code-based checks (does it compile, do tests pass, does it contain the required clause) before reaching for an LLM-as-judge rubric. promptfoo for assertions and judging, Anthropic's evals guidance that code-based grading wins when feasible, and four ways evals lie to you: tiny overfit sets, judging style over correctness, eval cost, and non-determinism. News up top: Opus 4.8 as the new Claude Code default with extra-high effort and Dynamic Workflows (docs), and today's 2.1.160 write-guard prompts (changelog). Earlier episodes referenced: permissions and plan mode, custom slash commands, skills, subagents, MCP servers, and context windows.

  • June 1 · length unknown

    Context windows and CLAUDE.md hierarchies: why long sessions go dumb, and how to keep them sharp

    Two hours into a session, Claude starts re-reading files and forgetting the conventions you set at the start. That's a full context window, not a smarter assistant. Learn to read the /context meter, when to /compact versus /clear, how to push noisy work into a subagent, and how to structure a multi-file CLAUDE.md hierarchy so the right instructions load at the right depth instead of silently eating your token budget. Episode page & show notes Visit website The context window is the scarce resource Claude Code thinks inside of, and managing it turns out to be the same skill as managing your CLAUDE.md files. This episode covers both halves and the one idea underneath them: a fuller window is a slower, more forgetful, more expensive Claude, not a smarter one. Anthropic frames the whole craft in Effective context engineering for AI agents as finding the smallest set of high-signal tokens that does the job, and we build practical habits around that. First, the mechanics. What's already loaded before you type (system prompt, tools, skills, MCP servers, and your CLAUDE.md), and why long sessions degrade: context rot, the attention budget, the quadratic cost of attention, and lost in the middle. The context-window docs ship an interactive walkthrough and the load order we use throughout. Then the workflow. Reading the /context meter (including the autocompact buffer it reserves), /compact with focus instructions, what survives a compaction versus what silently vanishes, and the /clear-versus-/compact-versus-fresh-session decision rule. Plus offloading noisy work to a subagent (the docs' own example reads 6,100 tokens and returns 400), and quick memory with the # shortcut and /memory. Sources: Manage costs effectively. The second half is the memory hierarchy: managed policy, user, project, and local CLAUDE.md files, how they concatenate rather than override, and how Claude discovers them by walking up the directory tree at launch and loading nested subdirectory files on demand. We cover @-imports (and why they don't save context), the monorepo pattern with path-scoped rules in .claude/rules/, and what belongs in CLAUDE.md versus a skill or a hook. The pitfall: a bloated, stale CLAUDE.md silently eats your window on every turn and you can't see it in the terminal. How to catch it with /context and /memory, and how to fix it by moving instructions to where they load on demand. Earlier episodes referenced: subagents, skills, hooks, and MCP servers.

  • June 1 · length unknown

    MCP servers: connect your database, browser, and GitHub to Claude Code

    Wire external tools into Claude Code through the Model Context Protocol: a real browser, your Postgres database, your GitHub repos, your error tracker in production. We add a server from scratch, sort out the three config scopes and which file gets committed, and fix the mistake that quietly floods your context window and dulls the model. Episode page & show notes Visit website A subagent keeps work out of your context; an MCP server does the opposite job, it reaches out of Claude Code to systems you didn't build. This episode is the rung where Claude Code stops being a smart thing in your terminal and starts touching your real database, a real browser, your GitHub repos, and your error tracker. We cover what the Model Context Protocol is (Anthropic's open "USB-C for AI," the N-by-M integration problem, the host/client/server roles, and the three things a server exposes: tools, resources, and prompts), plus the adoption wave through OpenAI, Google, and Microsoft. Then the hands-on part: the two transports you actually use (local stdio and remote HTTP, with SSE deprecated), the claude mcp add command and the load-bearing double-dash rule, and the three config scopes, local, project, and user, including which file gets committed to git and why project-scoped servers trigger an approval prompt. Worked examples a web dev wires up: the official Playwright browser server, a read-only Postgres/Supabase server, the remote GitHub server, Sentry over OAuth, and Context7 for live docs. We cover OAuth versus header auth and the environment-variable expansion pattern that keeps secrets out of a committed config. The pitfall gets real time: tool-surface bloat. Real numbers on how MCP tool definitions eat the context window (GitHub's server alone is ~17.6k tokens), how tool-selection accuracy collapses when the menu is too long, how to recognize it, and the deferred tool-loading fix that went GA in 2026. Plus the security half, Simon Willison's lethal trifecta and why least privilege and that approval prompt matter. Closing contrast: MCP adds capabilities, skills add knowledge, subagents add workers, hooks add guardrails. Docs: Claude Code MCP.

  • June 1 · length unknown

    Subagents: one-off delegation that keeps your main context clean

    A subagent is a fresh Claude instance that does a noisy, self-contained job in its own context window and hands back only the summary. Learn to delegate codebase searches and code reviews, restrict each agent's tools and model, and avoid the blank-context pitfall that produces confident wrong answers. Episode page & show notes Visit website A subagent is a fresh Claude instance that does a self-contained job in its own context window and hands back only a summary. This episode covers using them the Act I way: one-off delegation to keep your main session's context clean. Why isolation matters. The context window fills fast and Claude's performance degrades as it does. From Anthropic's context-window walkthrough: a research subagent read ~6,100 tokens of files and returned a 420-token result. The reading never touched your main thread. The best-practices guide calls subagents one of the most powerful tools available because context is your fundamental constraint. The Agent tool. As of Claude Code 2.1.63 the Task tool was renamed to Agent (old Task(...) references still work as aliases). Subagents cannot spawn other subagents, which is why the orchestrator pattern needs agent teams later. Built-in subagents. Explore (read-only, Haiku, codebase search), Plan (read-only, used in plan mode), general-purpose (all tools, inherits your model), plus helpers statusline-setup and claude-code-guide. Explore and Plan skip CLAUDE.md and git status to stay fast. Custom subagents. Markdown files with YAML frontmatter in .claude/agents/ (project, checked into git) or ~/.claude/agents/ (user). The fields that matter: name, description (drives automatic delegation), tools (allowlist; omit to inherit all), and model (sonnet/opus/haiku/full ID/inherit). Manage them with the /agents command. See Create custom subagents. Proactive delegation. Put "use proactively" in the description field so Claude reaches for the agent on its own. Worked examples. A codebase-search delegation that keeps file reads out of your window, and the official read-only code-reviewer (restricted to Read, Grep, Glob, Bash) that judges your diff with fresh eyes. Subagent vs skill vs slash command. A skill runs in your main context; a subagent runs isolated and returns a summary; a slash command is a typed entry point. Offload noisy, self-contained work to a subagent. The pitfall. Subagents start blank, with no conversation history. Vague delegation produces confident, wrong answers. Scope tightly and restate load-bearing constraints. Plus the costs: tokens still get spent, cold-start latency, and no mid-task steering (a subagent can't even ask you a clarifying question).

  • June 1 · length unknown

    Skills: reusable expertise Claude loads only when the task matches

    You keep pasting the same procedure into chat. Package it once as a skill, a folder with a SKILL.md, and Claude loads it on demand when the task matches, deep when you need it and nearly free when you don't. We build one from scratch, wire live shell output straight into it, and fix the number one reason a good skill silently never fires. Episode page & show notes Visit website Episode 5 of Act I. Custom slash commands turned a repeated prompt into one word. Skills are the next rung: a folder of reusable expertise Claude pulls in on its own when the task matches, plus supporting files and scripts that ride along. The core idea: progressive disclosure. Three loading levels. The name and description are always loaded (~100 tokens each). The SKILL.md body loads only when the skill is triggered. Reference files and scripts load only when referenced, and scripts execute without their code ever entering context. That's why a 2,000-line skill costs almost nothing on the days you don't use it. See Claude Code's skills documentation and the Agent Skills overview. The copyable workflow. Build a summarize-changes skill: YAML frontmatter with a trigger-shaped description, plus a body that injects live git diff output using the !`command` dynamic-context syntax. Where skills live (personal in ~/.claude/skills/, project in .claude/skills/ committed to git so the team inherits them, plus plugin and managed scope), name-collision precedence, and live reload with no restart. A worked second example: a Postgres migrations skill with a bundled template and a type-generation step. The knobs that matter. disable-model-invocation and user-invocable to control who triggers a skill, allowed-tools and disallowed-tools tying back to the permissions episode, named arguments, and a peek at context: fork. When to use what. Facts that are always true go in CLAUDE.md; a prompt you retype becomes a command; a procedure with depth becomes a skill; a task you want quarantined becomes a subagent (coming up next). The pitfall: the skill that never fires. Almost always a vague description, the only thing Claude sees before invoking. How to diagnose it with "what skills are available?" and /doctor, the description-budget truncation that bites once you have many skills, and the opposite fix when a skill triggers too eagerly. Plus bundled skills, treating untrusted skills like untrusted software, and letting Claude author and refine the skill for you. From Anthropic's skill-authoring best practices.

  • June 1 · length unknown

    Custom slash commands and hooks: shortcuts you trigger, guarantees that fire on their own

    You've been using the slash commands Claude Code ships with. Now write your own, and wire the hooks that fire on their own. Bundle a repeatable workflow into a command you trigger with a slash, then back it with hooks that enforce the rules a command can only ask for: build a /commit command, auto-lint after every edit, block writes to your migrations folder, and force the tests to pass before a turn can end. Episode page & show notes Visit website Episode 3 covered the slash commands Claude Code ships with. This one is about writing your own, plus the automation that fires whether Claude remembers it or not. Two primitives, one rule for choosing between them: a custom slash command is a shortcut you trigger; a hook is a guarantee that runs on its own. Custom slash commands. Where they live (a per-command folder under your project's .claude or your home .claude, with the folder name becoming the command), the SKILL.md file and its YAML frontmatter, and the fields that matter: description, argument-hint, allowed-tools, model, and disable-model-invocation. Passing arguments with $ARGUMENTS and positional $1/$2, injecting live shell output into the prompt with the !`...` prefix, and pre-approving tools so a workflow runs without permission prompts. Worked example: a /commit command that stages, writes a real message, pushes, and opens a PR. From the skills documentation. Hooks. The lifecycle events (PreToolUse, PostToolUse, UserPromptSubmit, Stop, SessionStart/End, compaction, notifications, subagent events), how they're configured under the hooks key in settings.json, the matcher syntax, the JSON a hook receives on stdin, and how it answers back through exit codes (0 success, 2 blocks) and a decision JSON that can allow, deny, ask, modify tool input, or add context. Three hooks worth stealing: auto-lint and format after every edit, block writes to the migrations folder, and a Stop hook that forces tests to pass before a turn can end. From the hooks documentation. The pitfall. Putting an "always" or "never" rule inside a command's prose and trusting it. Command instructions are advice, like CLAUDE.md; if the cost of the model forgetting is real, that rule belongs in a hook. Plus quick traps: hook timeouts, unquoted arguments, and vague descriptions that never auto-invoke. Browse what you've built with /hooks, /skills, and /help.

  • June 1 · length unknown

    Built-in slash commands and the keyboard habits that make a session fast

    A tour of the commands that ship in the box, the four steering keys you will use every run, and the decision you make constantly: clear versus compact, plus how to spot when compaction silently drops the context you were relying on. Episode page & show notes Visit website Episode three of the OCDevel Claude Code arc, and the first one that's purely about speed. You can already drive a session from episodes one and two. This one makes you fast: the commands that ship in the box, and the keyboard moves you stop thinking about. What we cover: The reframe. On the 2.1 line, custom slash commands have been merged into skills, so the / menu is now one surface mixing built-in commands, bundled skills and workflows, your own skills, plugin commands, and MCP prompts. Type / to see exactly what your install has, since a command is only recognized at the start of a message and availability varies by plan and platform. See the commands reference. The catalog, grouped by when you reach for it — setup (/init, /memory, /config), steering (/model, /effort, /plan, /context), review (/diff, /code-review, /review, /security-review, /simplify), the between-sessions family (/clear, /resume and its alias /continue, /branch, /rename, /export), recovery (/rewind, /doctor), and cost (/usage, aka /cost). The everyday decision: /clear vs /compact. Clear starts a fresh conversation (the old one parks in /resume); compact keeps the thread and replaces verbatim history with a steerable summary. The rule: clear for unrelated work, compact to keep going. Details in exploring the context window and managing costs. The pitfall: silent context loss. Auto-compaction keeps intent and key snippets but drops full tool outputs and intermediate reasoning, and path-scoped rules are lost until a matching file is read again. How to recognize the drift and stay ahead of it with /context and focused compaction. The safety net and its blind spots. /rewind (or double-Escape) restores code and conversation, but bash side effects aren't tracked. Checkpoints are local undo; git is permanent history. See checkpointing. The keyboard. The four steering keys (Escape to interrupt, double-Escape to rewind, Shift+Tab for modes, Ctrl+C), history recall with Ctrl+R, the fast-input symbols (@ files, ! shell, # memory, / commands), plus /btw for a tool-less side question. Reference: interactive mode. Recency note for mid-2026: /vim moved into /config → Editor mode (removed in 2.1.92), /cost is now an alias for /usage, and the auto-compact threshold is version-dependent. Verify against /help in your own install. Next episode: writing your own custom slash commands.

Showing 21–27 of 27 episodes