Master Claude Chat, Cowork, Code

In Episode 17 of Beyond Prompting, author Sho Shimoda breaks down the Model Context Protocol (MCP)—the open standard that connects Claude Code to external systems like ticket trackers, wikis, and databases. We explore how MCP replaces custom one-off integrations with a universal wire protocol, and examine the major 2026 specification revision. In this episode, we cover:
The Three Primitives: Distinguishing between Tools (model-controlled functions), Resources (application-controlled context and documents), and Prompts (user-controlled command templates).
The July 2026 Protocol Shift: How the updated MCP specification (2026-07-28) eliminated connection handshakes (initialize) and persistent session IDs (Mcp-Session-Id) in favor of stateless, standalone HTTP POST requests carrying capabilities in _meta.
Configuring .mcp.json: Setting up stdio and HTTP transports across local (~/.claude.json), project (.mcp.json), and user scopes, and leveraging tool search (ENABLE_TOOL_SEARCH) to prevent schema overload.
Security & Host Access: Why stdio MCP servers run as unconstrained processes on the host machine outside the shell sandbox, and what security teams must verify before connecting third-party servers.
(Note for listeners: This episode covers Chapter 17 of Sho Shimoda's book RUNNING CLAUDE: The Operator’s Guide to Chat, Cowork and Claude Code, available on Amazon as the successor book to Master Claude: Chat, Cowork and Code).

In Episode 16 of Beyond Prompting, author Sho Shimoda breaks down how to turn your team's recurring instructions and workflows into executable Agent Skills. Rather than re-explaining multi-step procedures in every new session, Skills allow you to encapsulate standard operating procedures once so Claude can discover and execute them automatically. In this episode, we cover:
The Anatomy of a Skill: How a Skill is structured as a directory containing a SKILL.md file with YAML frontmatter and instructions written specifically for an AI agent.
The Description Is the Whole Mechanism: Why there are no trigger fields, regex rules, or keyword matchers—Claude decides to invoke a Skill strictly by evaluating its description field against the user's current request.
Progressive Loading & Context Economics: How loading works in three cost-effective stages—only descriptions load at session start, the full SKILL.md body loads when invoked, and supporting reference files load only on demand.
Executable Procedures with Inline Shell: Leveraging $ARGUMENTS, path variables, and inline shell commands (! prefix) to gather real-time situational facts before Claude begins executing steps.
Building Skills That Work: Starting from real organizational repetition, writing intent-focused descriptions, and testing Skills by describing situations naturally rather than explicitly invoking them.
(Note for listeners: This episode covers Chapter 16 of Sho Shimoda's book RUNNING CLAUDE: The Operator’s Guide to Chat, Cowork and Claude Code, available on Amazon as the successor book to Master Claude: Chat, Cowork and Code).

In Episode 15 of Beyond Prompting, author Sho Shimoda breaks down prompt caching—the single largest cost lever in the Claude Code ecosystem—and demonstrates how to manage long-term project memory. We explore why two identical sessions can vary dramatically in cost based on how they handle cached context and how to structure state that outlives individual sessions. In this episode, we cover:
The Three Cached Layers: How prompt caching organizes context into three ordered layers—system prompt, project context, and conversation—allowing routine turns to run at roughly a tenth of standard input costs by reading cached prefixes.
What Discards the Cache: Unintentional actions that invalidate the cached prefix—such as switching models mid-task, changing effort levels, toggling fast mode, or connecting MCP servers on the fly—and how planning session parameters upfront avoids expensive cache rebuilds.
Cache Lifetimes (5-Minute vs. 1-Hour TTL): How cache retention periods operate across subscription plans and usage credits, and how to configure TTL settings to match your working rhythm.
Durable State Beyond Sessions: Why conversation history is the wrong place to store architectural history, and how to maintain version-controlled decision records (decisions.md) that agents read at session start and update upon completing tasks.
(Note for listeners: This episode covers Chapter 15 of Sho Shimoda's book RUNNING CLAUDE: The Operator’s Guide to Chat, Cowork and Claude Code, available on Amazon as the successor book to Master Claude: Chat, Cowork and Code).

In Episode 14 of Beyond Prompting, author Sho Shimoda breaks down how to manage context budgets and session state when conversations run long. We examine the three core mechanisms that control what Claude retains, what gets summarized, and how to recover when an exploration strays off track:
Auto Memory Across Sessions: How Claude Code automatically records durable preferences and project facts under ~/.claude/projects/<project>/memory/, loading the top of MEMORY.md while keeping topic-specific files available on demand.
Reading the Context Budget: Using the /context command to visualize exact token usage across system prompts, tool definitions, rules, memory, skills, and conversation history.
What Compaction Keeps (and Drops): Understanding what survives automatic or manual compaction—system prompts, CLAUDE.md, unscoped rules, plan mode plans, and auto memory are re-injected from disk—and how to direct summaries using /compact focus on <topic>.
Going Backwards with Checkpoints: Using /rewind or pressing Esc Esc twice to restore code, conversation, or both across the 100 most recent prompt snapshots, alongside the four structural limits where Git commits remain essential.
(Note for listeners: This episode covers Chapter 14 of Sho Shimoda's book RUNNING CLAUDE: The Operator’s Guide to Chat, Cowork and Claude Code, available on Amazon as the successor book to Master Claude: Chat, Cowork and Code).

In Episode 13 of Beyond Prompting, author Sho Shimoda breaks down how to configure persistent repository instructions using CLAUDE.md and rule files. Rather than treating CLAUDE.md as a generic style guide or dumping ground for historical bugs, this episode focuses on treating instruction files as a concise briefing for a capable colleague. We cover:
The 200-Line Rule: Why CLAUDE.md should be kept concise (under ~200 lines) by focusing strictly on non-derivable facts, build environments, and explicit boundaries—leaving out generic advice and formatting rules the model can see for itself.
Concatenative Inheritance: How instruction files concatenate rather than override across four scopes: managed enterprise policy, user-level ~/.claude/CLAUDE.md, project ./CLAUDE.md, and uncommitted ./CLAUDE.local.md.
Scoped Rules (.claude/rules/): How to split large instruction sets into modular files inside .claude/rules/ using paths: frontmatter globs so that topic-specific rules (like frontend React conventions) only load when matching files are opened.
Deterministic Tools vs. Reasoning Context: Why mechanical syntax and formatting rules belong in deterministic linters and git hooks, reserving CLAUDE.md for architectural context and edge-case rationale that static analysis cannot check.
Preventing Instruction Sediment: Using CLI commands like /init, /memory, and /doctor to audit, prune, and maintain instruction files like code.
(Note for listeners: This episode covers Chapter 13 of Sho Shimoda's book RUNNING CLAUDE: The Operator’s Guide to Chat, Cowork and Claude Code, available on Amazon as the successor book to Master Claude: Chat, Cowork and Code).