Effective Claude Code Use

There are 4 Rules to effectively using Claude Code, based from Anthropic Engineers:

1. Use Skills, not just Prompts

Stop using Claude Code with traditional prompting.

• Skills are organized collections of files that package composable procedural knowledge on agents. So, a folder.
• Skills are created to deal with repetitive tasks

Prompt:

based on my recent sessions, what tasks am i doing repeatedly that should be skills instead of one-off prompts? for each one suggest the skill name and what context it would need.

2. Skills are more than prompt

Try to include relevant tools and files to level up the skills.

• There are 3 layers to a skill:
  1. Layer 1 - Metadata: What Claude checks every time you asked a question. This will decide whether Claude will use this skill or not (Comprised of name and description from YAML formatter)
  2. Layer 2 - Instructions: The playbook or the steps to complete the task that Claude will follow if it decides that this skill is relevant based on Layer 1. (Comprised of SKILL.md body with instructions and guidance)
  3. Layer 3+ - Resources: The tools that it needs to complete this task efficiently. This layer will be called if deemed necessary for the Layer 2 task. (Comprised of bash scripts, API calls, reference files, etc)
• People often stops at Layer 2, but Layer 3 is where the leverage lives in. A developer should be able to tell Claude to actually use the right tooling to do the job.

Prompt:

Find a task where I'm doing manual checking, lookup, or verification after Al gives me an output.

Build a skill that does both: generates the
answer AND verifies it. Show me the SKILL.md with description, when-to-trigger examples, and the verification step.

Identify any tools that are needed to help this skill provide a better output.

3. Build composable skills, not custom skills

Think of skills as a reusable, specific, and powerful util functions.

• Skills should be composable, portable, efficient, and powerful. Meaning that they need to have a specific job assigned to them with clear purpose, detailed steps, and small enough that they can work alongside other skills. You can also chain skill with more skills by calling them.
• Why create more specific skills?
  1. Issues are easy to spot: If one break, debugging would be easier.
  2. Improvements compound: If you chain skills in multiple workflows, improving just one skill will improve the quality of many workflows.
  3. Reuse instead of rebuild: If it’s not relevant anymore, you don’t deprecate the whole skill, just need to re-arrange them again for other tasks.
• Patterns to make skills more powerful:
  1. Pattern 1: Save scripts inside skills. Let Claude run the script to make it more consistent, useful for repeated deterministic tasks. To quote: “If you can use code instead of AI, you should.”
  2. Pattern 2: Control who invokes what. Claude has a built-in flag called user-invocable . Disabling this will hide the skills from your slash commands. This will be useful if you have a lot of specific skills that’s only relevant if an agent calls it, not the user. The other way around is disable-model-invocation where if enabled then only the user can call it.

Prompt:

Audit my Claude Skills for:

1. Visibility:
    - Skills with high risk side effects (deploy, commit, send messages): add
    disable-model-invocation: true so Claude can't auto-fire.
    - Skills that are pure background knowledge users would never /run
    themselves: add user-invocable: false to hide from /menu.
2. Deterministic vs non-deterministic:
    - Find any step inside a skill where Al is interpreting something that's
    actually a fixed, repeatable operation.
    - Suggest replacing those steps with a script saved inside the skill folder.
    Code = same result every time, no token cost.
    - Keep Al for the steps that need judgment.
3. Composability:
    - Flag any skill that duplicates logic another skill already has. Suggest
    extracting shared logic into a callable script or a smaller composable
    skill.

Show me the rewrites with a changelog of what changed and why.

4. Skills get smarter on every session

The question is, how do you make them smarter?

• If the skill result is not what you want, ask yourself this: “Is this a one-time fix, or should this be in the skill forever?” If it should be in the skill, then update the skill
• This is a compounding loop: Use Skill → Get the output → Update the skill → repeat

Prompt:

Review the back and forth. I just had after using this skill, can we enhance the skill so this is handled automatically?