Smorster

How Anthropic Engineers ACTUALLY Prompt Claude Code

Austin Marchese · 10m 46s · Watch on YouTube · 9 sources

Decision Card

Effort: One afternoon — read Anthropic’s Agent Skills engineering post (~20 min), convert your two most-repeated prompts into SKILL.md folders (~1–2 h), and add one saved script to a skill’s tools layer.

Honest take: The video is a repackaging of Anthropic’s own blog/talks rather than original research — the “four rules” framing is the creator’s invention, and it glosses over that the invocation flags (rule 3, pattern 2) are Claude Code-specific extensions, not part of the portable agentskills.io open standard; it also claims “no technical experience needed” while rule 2’s whole point is that the leverage lives in writing code tools.

Concrete next steps:

  • Rule 1 — prompt skills, not Claude (adopt): Convert recurring prompts into skills per Anthropic’s Agent Skills post — ~1 h for the first two.
  • Rule 2 — tools layer over prompt polish (try): Add one executable script to an existing skill instead of re-describing the procedure in prose — ~30 min; skip if your skills are pure writing/style guides with no deterministic steps.
  • Rule 3 — composable small skills + invocation flags (adopt the splitting, try the flags): Split any “does everything” skill; set disable-model-invocation: true on side-effect skills per the Claude Code skills docs — ~20 min; skip flags if you have no deploy/send-message-style skills.
  • Rule 4 — update the skill after every use (adopt): After a correction mid-session, ask Claude to fold the fix back into the skill — ~2 min each time; skip only for genuinely one-off tasks.

TL;DR

The video distills Anthropic engineers’ published guidance on Claude Code into four rules: prompt reusable skills instead of writing ad-hoc prompts, invest in the tools/scripts layer of skills rather than just the prompt text, build small composable skills instead of one monolith, and update skills after every session so they compound. It’s an accessible, mostly accurate summary of Anthropic’s Agent Skills material, aimed at non-technical viewers.

Key Points

  • Rule 1: stop writing ad-hoc prompts for repetitive tasks; write prompts that invoke reusable skills instead 00:17
  • Anthropic defines skills as organized collections of files packaging “composable procedural knowledge for agents” — i.e., folders 00:42
  • Mental model: layer 1 is the model, layer 2 is agents/prompts, layer 3 is skills — the “application layer” you control, like apps on a phone Anthropic builds 01:25
  • Rule 2: a skill has three layers — description (how Claude decides to use it), instructions (the playbook), and tools (scripts, API calls, reference files) 02:34
  • A well-written description lets Claude auto-invoke the skill without you naming it 02:51
  • Most people obsess over the prompt and neglect the tools layer, where most of the leverage lives — Anthropic engineers do the opposite 03:14
  • Rule 3: build small, focused, composable skills, not one giant custom skill — issues are easier to spot, improvements compound, and components get reused 04:37
  • Pattern: save scripts Claude keeps rewriting inside the skill folder — code is deterministic, and you trade AI tokens for cheaper, repeatable compute 06:58
  • Two frontmatter flags control invocation: user-invocable: false (agent-only skill, hidden from the slash menu) and disable-model-invocation (human-only, for risky actions like deploys) 07:43
  • Rule 4: after each use, ask whether a correction is a one-time fix or belongs in the skill forever — updating the skill creates a compounding improvement loop across sessions 09:42

Notable Quotes

“Skills are organized collections of files that package composable procedural knowledge for agents.” 00:42

“A general rule of thumb is if you can use code instead of AI, you should.” 07:26

“Anything that Claude writes down can be used efficiently in by the future version of itself. Our goal is that Claude on day 30 of working with you is going to be a lot better on Claude on day one.” 09:18

Verified Claims

  1. Claim: Anthropic defines skills as organized collections/folders of files packaging procedural knowledge for agents. 00:42 Sources: Anthropic Engineering — Equipping agents for the real world with Agent Skills (defines skills as “organized folders of instructions, scripts, and resources that agents can discover and load dynamically”). Verdict: Confirmed (video’s quote is a close paraphrase of the talk/blog wording).

  2. Claim: Claude checks a skill’s description to decide when to use it, and will auto-invoke a well-described skill without an explicit call. 02:51 Sources: Claude Code skills docs (“Claude uses skills when relevant, or you can invoke one directly with /skill-name”); Anthropic Agent Skills post (name/description frontmatter is “the first level of progressive disclosure”). Verdict: Confirmed.

  3. Claim: Skills are more than prompts — they bundle executable tools/scripts, and that’s where the leverage is. 03:07 Sources: Anthropic Agent Skills post (skills bundle scripts and resources; code execution gives “the deterministic reliability that only code can provide”). Verdict: Confirmed.

  4. Claim: Anthropic positions skills as composable and portable, with multiple skills working together and Claude coordinating which to use. 04:41 Sources: Anthropic Agent Skills post (composable capabilities; published as an open standard for cross-platform portability); Claude Code skills docs (skills follow the agentskills.io open standard). Verdict: Confirmed.

  5. Claim: Saving a script inside a skill folder replaces token generation with deterministic, cheaper code execution (“trading AI tokens for code compute”). 07:21 Sources: Anthropic Agent Skills post (“sorting a list via token generation is far more expensive than simply running a sorting algorithm”). Verdict: Confirmed.

  6. Claim: Two frontmatter flags exist — user-invocable: false (hides the skill from the user’s slash menu; agent-only) and disable-model-invocation: true (only the user can run it; suited to risky actions like deploys). 07:43 Sources: Claude Code skills docs — Control who invokes a skill (documents both flags with exactly these semantics, including the deploy example). Verdict: Confirmed — with the caveat that these are Claude Code extensions to the open standard, which the video doesn’t mention.

  7. Claim: “Barry” from Anthropic presented skills at the AI (Engineer) Code Summit, including the goal that “Claude on day 30… a lot better than Claude on day one.” 06:36 Sources: Don’t Build Agents, Build Skills Instead — Barry Zhang & Mahesh Murag, Anthropic (YouTube); AI Engineering Code Summit speaker page — Barry Zhang (summit coverage repeats the “day 30 vs day one” continuous-learning framing). Verdict: Confirmed.

  8. Claim: Boris Cherny is the creator of Claude Code and uses skills/commands heavily in his own workflow. 10:35 Sources: Building Claude Code with Boris Cherny — Pragmatic Engineer; Boris Cherny on X — his Claude Code setup (uses slash commands for every inner-loop workflow, checked into .claude/commands/). Verdict: Confirmed (though Cherny describes his setup as “surprisingly vanilla,” which cuts slightly against the video’s heavy-customization framing).

  9. Claim: “Almost everyone is prompting Claude Code wrong.” 00:05 Sources: none — no usage data exists in the cited Anthropic material to support a claim about how “almost everyone” prompts. Verdict: Inconclusive (rhetorical hook, not a verifiable claim).

Tools, Papers & Standards Mentioned

Follow-up Questions

  1. How does progressive disclosure actually budget context — how many skill descriptions can live in the system prompt before skill discovery itself degrades, and how should large skill libraries be organized?
  2. The invocation-control flags are Claude Code extensions — which parts of a skill library survive intact when ported to other agentskills.io-compatible runtimes, and which silently stop working?
  3. Rule 4’s manual “update the skill after each session” loop overlaps with Claude Code’s memory features and CLAUDE.md — when is a correction better placed in a skill vs. CLAUDE.md vs. persistent memory?

Sources