Video summary

How Anthropic Engineers ACTUALLY Prompt Claude Code

Main summary

Key takeaways

Technology

Overview

The video argues that “Anthropic engineers” prompt Claude Code incorrectly at first glance—most users over-focus on one-off prompts instead of building reusable Claude skills. These skills (application-level artifacts) improve over time.

Core technological ideas & product features

1) Prompt skills, not Claude (reframing workflow)

  • Traditional usage: people write custom prompts for everything, even though many tasks are repetitive.
  • Anthropic’s approach: create Claude Skills—described as “organized collections of files” that package procedural knowledge for agents (effectively “folders” that bundle how to do a task).

Mental model shift (layering):

  • Layer 1: the AI model
  • Layer 2: agents + prompts (common today)
  • Layer 3: skills as the “app layer” (like building apps on a phone instead of remaking prompts constantly)

Example provided: Instead of writing a long prompt to draft an email, you’d use something like {/}draft email and provide the content. Claude uses the skill rather than bespoke prompting.

Skill-creation value: The speaker suggests prompts should explicitly reference skills rather than reinvent instructions each time.

2) Skills are more than prompts (3 internal layers)

A skill contains:

  1. Description (routing/selection)

    • Claude checks this to decide whether to use the skill.
    • A more specific description improves Claude’s selection.
    • Key claim: if descriptions are good, you often don’t need to manually call the skill—Claude can select it automatically.

  2. Instructions (the playbook)

    • Step-by-step process for completing the task.

  3. Tools (where leverage lives)

    • Access to code scripts, API calls, and reference files.

Contrast highlighted in the video:

  • Many people perfect prompt text but provide barebones/poorly documented tools.
  • Anthropic engineers prioritize strong tooling.

Concrete example: A “check domains” skill verifies domains programmatically so model outputs are already validated. It also enables scaling (e.g., sub-agents checking thousands of domains).

3) Build composable skills (small reusable units)

Rule: create composable, portable, efficient skills rather than one giant “do-everything” skill.

  • Composability: multiple skills can work together while Claude automatically coordinates which to use.
  • Speaker’s example: they initially made one content-creation skill (ideas → scripts → social posts). It became unmanageable and hard to change.
  • They refactored into focused skills (e.g., YouTube idea research, YouTube script writer, LinkedIn post) that can chain together.

Why decomposition helps (3 reasons):

  1. Easier debugging: when a focused skill fails, you know where to look.
  2. Compounding improvements: update one skill → all workflows using it benefit.
  3. Reuse: validated components can be plugged into new workflows without rebuilding.

4) Patterns to make skills stronger

Pattern A: Save scripts inside skills

  • Anthropic engineers observed Claude repeatedly rewriting the same Python script (e.g., styling slides).
  • Fix: save that script as a tool inside the skill so Claude reruns it next time.

Rationale:

  • Code is deterministic (same input → same output).
  • AI scripting costs tokens and is less repeatable; using code trades tokens for cheaper compute.

Guideline: If you can use code instead of “AI guessing,” do it—generate the code once, then reuse it.

Pattern B: control invocation using skill flags

The video highlights two Claude skill configuration flags:

  • user invocable = false

    • Hides the skill from the user’s slash menu.
    • Intended for agents only, not direct user triggering.

  • disable model invocation

    • Only the user can run it; the model can’t.
    • Intended for higher-risk actions (e.g., sending messages or deploying production code).

Audit suggestion: The speaker recommends a prompt/workflow to audit whether flags are applied correctly.

5) Skills/prompts get smarter every session (compounding loop)

  • A core advantage: when prompted with a skill, improvements persist because the skill can be updated.
  • The video claims Anthropic engineers standardize a format so outputs remain usable for “future Claude” improvements.

Improvement method:

  • After running a skill:
    • Decide whether an incorrect result is a one-time fix or should be added to the skill permanently.
    • If permanent: update the skill (add rules/examples/edge cases).
    • Use chat history as evidence to modify the skill so the same mistake doesn’t recur.

Key “4 rules” summarized

  1. Use skills, not prompts (prompt the skill framework instead of writing bespoke prompts).
  2. Skills are more than prompts (especially leverage the tools layer).
  3. Build composable skills, not custom monoliths.
  4. Update skills every session so they improve over time.

Reviews / guides / tutorial emphasis

The video functions like a guide/tutorial, providing:

  • Conceptual frameworks (layer model)
  • Actionable rules and practical patterns:
    • skill structure (description / instructions / tools)
    • tool-first approach
    • composability + refactoring advice
    • saving code scripts inside skills
    • using skill flags to restrict invocation
    • an iterative auditing/updating loop

Main speakers / sources

  • Anthropic engineers interviewed/quoted throughout (including Barry / Barry Cherny).
  • Eric (explicitly referenced as being from the Anthropic team; discussing focus on tools).
  • Boris Cherny (referenced as the creator of Claude Code).

Original video