awesomeclaude.ai

Agent skills are packaged instructions and resources that extend what a Claude agent can do, and you use them by adding the skill to your agent's workflow so Claude can load and follow it when a task matches. They are best understood as reusable capability modules rather than raw API tools: a skill tells the agent how to perform a class of task, while tools and MCP servers give it access to external systems. The Awesome Claude directory lists agent skills alongside the Claude Code cheatsheet, MCP servers, plugins, SDKs, and integrations, and points to official references for building with them.

How agent skills fit alongside tools, MCP servers, and plugins

These four terms are often used interchangeably, but they play different roles in an agent workflow.

A practical rule: if the agent needs to know a procedure, reach for a skill; if it needs to do something external, reach for a tool or MCP server. Skills and tools compose — a skill can describe when and how to call a tool.

Where to find skills and reference material

The Awesome Claude directory organizes resources into official Anthropic resources, Claude Code and MCP material, community curated lists, and extensions and integrations. For skills specifically, these entries are the most direct starting points:

• Claude Cookbook — official notebooks and recipes for common patterns including RAG, tool use, Skills, and MCP.
• Claude Quickstarts — ready-to-deploy example applications.
• Agent SDKs — claude-agent-sdk-python and claude-agent-sdk-typescript, with documentation at the Agent SDK overview page.
• Official documentation — full reference for the Messages API, tool use, computer use, prompt caching, structured outputs, citations, MCP Connector, and Claude Code.
• Community curated lists — additional skill and integration examples maintained outside Anthropic.

Start with the Cookbook's Skills recipes if you want a working pattern to adapt, and use the Agent SDK docs when you need to wire a skill into an actual agent loop.

How skills are packaged and loaded

A skill is a self-contained bundle: instructions plus any supporting files the agent may need. The loading model is progressive — the agent sees a short description of available skills and pulls in the full instructions only when a task calls for them. That keeps context small when many skills are installed.

To add a skill to an agent workflow:

1. Write the skill — a clear name, a one-line description of when it applies, and step-by-step instructions. Include examples of good output and any reference files.
2. Register it — make the skill discoverable to your agent, either through the Agent SDK's skill configuration or the host environment's skill directory.
3. Describe the trigger precisely — the description is what the agent matches against the user's request, so state the task type, not the implementation.
4. Test with a matching request — confirm the agent loads the skill and follows the steps.
5. Test with a non-matching request — confirm the skill is not loaded, so it doesn't pollute unrelated tasks.

A minimal example

Suppose you want an agent that reviews pull request descriptions for completeness. The skill bundle contains:

• Name: pr-description-review
• Description: "Use when the user asks to review or improve a pull request description."
• Instructions: check for a summary, motivation, test plan, and linked issue; return a checklist with pass/fail per item and suggested edits.
• Example: one well-formed PR description and one that fails the checklist.

When a user asks "can you check this PR description?", the agent matches the description, loads the instructions, and produces the checklist. When the user asks "summarize this issue," the skill stays dormant and the agent handles it normally.

Common pitfalls and debugging

• Skill never triggers. The description is too vague or phrased as an implementation detail. Rewrite it as the user-facing task it covers.
• Skill triggers too often. The description is too broad. Narrow it to a specific task type and add a negative example.
• Agent loads the skill but skips steps. Instructions are ambiguous or too long. Break them into numbered steps with explicit expected outputs.
• Conflicts with tools. If a skill tells the agent to call a tool that isn't available, the workflow stalls. Verify tool availability before relying on it in a skill.
• Context bloat. Installing many verbose skills degrades performance. Keep each skill focused and lean on progressive loading rather than inlining everything.

To debug, log which skills the agent loads for a given request, then compare that against your intended trigger. If the skill loads but output is wrong, the problem is in the instructions; if it doesn't load, the problem is in the description.

For current model IDs, context windows, and pricing, check the official Models & Pricing page rather than relying on secondhand summaries, since these details change between releases.

Claude AI is Anthropic's family of large language models, accessed through a chat interface or, for developers, through the Claude API, official SDKs, and cloud providers such as Amazon Bedrock. You can use it to read and analyze long documents, write and review code, and build tool-using agents — but the right entry point depends on whether you want to chat with Claude or build with it. The sections below cover both, plus the concepts (MCP, agent skills, prompt caching) you'll meet once you start building.

Who makes Claude and what the model family includes

Claude is developed by Anthropic. The model lineup referenced in Anthropic's documentation covers several tiers — the Awesome Claude directory lists Fable 5.1, Opus 5.5, Sonnet 5.5, and Haiku 4.5 among the models available through Amazon Bedrock. In practice, the tiers trade off capability against speed and cost: the larger models handle harder reasoning and coding tasks, while the smaller ones suit high-volume or latency-sensitive work. Anthropic's models overview page is the authoritative place to check current model IDs, context windows, thinking features, and cloud provider IDs before you commit to one.

Core capabilities

• Chat and long-document analysis. Claude's context window lets you pass in substantial source material — contracts, research papers, codebases — and ask questions against it rather than pasting excerpts.
• Coding. Claude Code is Anthropic's coding-focused product; the directory also tracks a Claude Code 2.1 cheatsheet for developers working with it.
• Tool use and computer use. The Messages API supports tool use (letting the model call functions you define) and computer use, alongside structured outputs, citations, and prompt caching.
• Agent building. The Agent SDK (Python and TypeScript) is designed for constructing agents that plan and act across multiple steps.

How developers access Claude

There are three main routes, and they differ in what you control:

One caveat worth knowing before you pick Bedrock: per the directory's note, Managed Agents and Anthropic server-side tools are not available there — you'd use the Claude API with tool use instead. Bedrock model IDs also take a prefix and are served through the Messages-API endpoint, so code written against the direct API needs that adjustment.

Key concepts for building with Claude

MCP (Model Context Protocol) is the standard for connecting Claude to external tools and data sources; the directory maintains a list of top MCP servers. Agent skills are reusable capabilities you attach to an agent rather than re-prompting each time. Prompt caching reduces cost and latency on repeated context — useful when the same long document or system prompt is sent across many requests. If you're new to these, the official Claude Cookbook (53.4k stars) has notebooks covering RAG, tool use, Skills, and MCP, and Claude Quickstarts (18.0k stars) provides deployable example apps.

Where to start

1. Read the docs first. platform.claude.com/docs is the full reference for the Messages API, tool use, computer use, prompt caching, structured outputs, citations, MCP Connector, and Claude Code.
2. Check models and pricing. The models overview page lists model IDs, pricing, context windows, and thinking features — confirm current figures there rather than relying on secondhand numbers.
3. Get a key and test a prompt. Create one in the Developer Console, then run a small request to confirm your setup before scaling up.
4. Pick an SDK matching your stack and work through a Cookbook notebook for the pattern closest to your use case.
5. Verify your first integration by checking that responses return as expected and that usage appears in the console's monitoring.

A common snag is assuming Bedrock and the direct API behave identically — check the endpoint and model-ID format before porting code. Another is skipping prompt caching on repetitive workloads, which quietly inflates cost.

For a broader map of the ecosystem — plugins, integrations, and community-curated lists — the Awesome Claude directory is a reasonable index, but treat it as a pointer to official sources rather than a substitute for them.

Anthropic is the AI company behind the Claude model family, and its developer platform is where you build with those models. You start by choosing an access path — the Claude apps for direct use, the Claude Developer Console and API for custom applications, or a cloud provider like Amazon Bedrock for managed infrastructure — then pick an SDK in your language and build against the Messages API. The official docs, cookbooks, and quickstarts are the fastest route to a first working project.

Anthropic and Claude in one paragraph

Anthropic builds the Claude models; the Claude platform is the set of products and developer tools around them. For builders, the practical split is:

• Claude apps — using Claude directly, no code.
• Developer Console + API — keys, prompt testing, usage monitoring, and Claude Code sessions at console.anthropic.com.
• Cloud providers — running Claude through infrastructure you already use, such as Amazon Bedrock.

Three ways to access Claude

One caveat worth knowing before you commit to Bedrock: per the directory's notes, Managed Agents and Anthropic server-side tools are not available there — you use the Claude API plus tool use instead. Bedrock serves Claude 5 models through the Messages-API endpoint and takes an ID prefix.

Core developer capabilities to know

The official documentation covers the full reference. The pieces that shape most projects:

• Messages API — the primary interface for sending prompts and receiving responses.
• Tool use — letting the model call functions you define.
• Computer use — model-driven interaction with a computer environment.
• Prompt caching — reusing prompt prefixes to cut repeated work.
• Structured outputs and citations — getting responses in defined shapes, with source attribution.
• MCP Connector — connecting the model to Model Context Protocol servers.
• Claude Code — Anthropic's coding tool, with its own sessions and cheatsheet resources.

Choosing an SDK

Anthropic ships official SDKs across major languages, plus separate Agent SDKs for agent-style applications. Pick by your stack:

If you're building an agent rather than a straightforward API integration, the Agent SDKs (claude-agent-sdk-python, claude-agent-sdk-typescript) are the more direct fit; their docs live under the Agent SDK section of the platform docs. For plain request/response work, the standard SDK for your language is enough.

Where to start a first project

Three official resources shorten the path from zero to working code:

1. Claude Cookbook — notebooks and recipes for common patterns: RAG, tool use, Skills, and MCP. Start here if you want to see a pattern working before adapting it.
2. Claude Quickstarts — ready-to-deploy example apps. Start here if you'd rather run something end-to-end and modify it.
3. Official documentation — the full reference for the Messages API, tool use, prompt caching, and the rest. Keep it open while you build.

A reasonable first sequence: get an API key from the Developer Console, run one cookbook notebook in your language's SDK, then adapt a quickstart into your own project. If you're on AWS, evaluate Bedrock first so you don't build against the direct API and then migrate.

Practical notes before you build

• Model selection matters. The models overview page lists current model IDs, context windows, thinking features, and cloud provider IDs — check it rather than assuming a model name.
• Pricing is documented, not assumed. The directory links to a models and pricing page; consult it directly for current figures rather than relying on secondhand numbers.
• Beta SDKs carry risk. The C#/.NET and PHP SDKs are marked Beta, so plan for API changes if you adopt them.
• Community lists help with discovery. Curated lists and extension/integration directories are useful for finding MCP servers, plugins, and tooling beyond the official set — treat them as pointers and verify against official docs.

Claude Code is Anthropic's agentic coding tool that works directly in your terminal and codebase, rather than as a chat window. You point it at a project, and it reads files, writes and edits code, runs commands, debugs, refactors, and automates multi-step development tasks under your direction. It is the right starting point if you want an AI agent operating on real repositories; it is not the same thing as the Claude chat app, the raw Claude API, or the Agent SDK. This article covers what it does, how it relates to the surrounding tools, how to start, and where the common limits are.

What Claude Code actually is

Claude Code is a developer-facing agent that lives where your code lives. Instead of pasting snippets into a chat, you start a session in a project and give it a task in natural language. The agent then works against the files and commands in that environment.

The distinction that matters:

• Claude app / chat — conversational assistant for questions, drafting, and analysis.
• Claude API — the programmatic interface (Messages API, tool use, prompt caching, structured outputs) you call from your own code.
• Claude Code — an agentic coding tool that operates on your codebase and terminal.
• Agent SDK — libraries (claude-agent-sdk-python, claude-agent-sdk-typescript) for building your own agents on the same foundation.

So Claude Code is the "do it in my repo" layer; the API and SDKs are the "build it into my product" layer.

What you can use it for

The core value is delegating concrete, multi-step work on a real codebase:

• Reading and navigating a repository — locating where a feature lives, tracing how a function is used.
• Writing and editing files — implementing changes, adding tests, updating configs.
• Running commands — executing builds, test suites, linters, and scripts, then reacting to the output.
• Debugging — reproducing an error, reading stack traces, and iterating on a fix.
• Refactoring — restructuring code across files while keeping behavior intact.
• Automating routine development tasks — repetitive edits, migrations, and scaffolding.

For example, a typical task is: "add input validation to the signup handler, update the tests, and run the suite." The agent reads the relevant files, makes edits, runs the tests, and reports back — you review the diffs.

How it fits with the rest of the Claude stack

The official documentation at platform.claude.com/docs is the reference for the Messages API, tool use, computer use, prompt caching, structured outputs, citations, MCP Connector, and Claude Code itself. Model IDs, context windows, and pricing live on the models overview page.

How to get started

The general path, based on the official resources:

1. Get access. Create or sign in to your Anthropic account through the Claude Developer Console (console.anthropic.com), which is where API keys, prompt testing, usage monitoring, and Claude Code sessions are managed.
2. Install and authenticate. Set up Claude Code and authenticate — either through your account or with an API key from the console. (Exact install commands and menu paths change between versions; follow the current Claude Code docs rather than a copied snippet.)
3. Start a session in a project. Open your repository and launch Claude Code there, so it operates on that codebase.
4. Give it a scoped task. Start with something bounded — a single bug, one test file — and review the changes it proposes.
5. Verify. Run your tests and inspect the diffs. The agent's output is a proposal; your test suite and review are the check.

The Claude Code 2.1 cheatsheet on Awesome Claude is a practical companion for commands and workflows once you're set up.

Extending what it can do

Claude Code is designed to be extended:

• MCP servers — connect the agent to external tools and data sources via the Model Context Protocol.
• Agent skills — reusable, packaged capabilities for specific tasks.
• Plugins and integrations — community and official extensions listed in the Awesome Claude directory.
• SDKs — if you outgrow the tool and want to build your own agent, the Agent SDKs (Python, TypeScript) and the official claude-cookbooks (patterns for RAG, tool use, Skills, MCP) are the next step.

Common limits and things to watch

• Permissions. An agent that writes files and runs commands needs appropriate access; expect to grant and review permissions rather than assume full autonomy.
• Context window. Large repositories exceed what fits in context at once. Scope tasks and let the agent navigate rather than assuming it has read everything.
• Cloud provider differences. On Amazon Bedrock, Claude 5 models are served through the Messages-API Bedrock endpoint and take an ID prefix, and support cross-region inference, latency optimizations, fine-tuning, agents, and guardrails. However, Managed Agents and Anthropic server-side tools are not available on Bedrock — there you use the Claude API plus tool use instead. Check the provider-specific docs before assuming feature parity.
• Model and pricing details change. Confirm current model IDs, context windows, and pricing on the official models overview rather than relying on secondhand figures.

Where to go next

If you want to use an agent on your code, start with Claude Code and the 2.1 cheatsheet. If you want to build agents into your own product, move to the Claude API and the Agent SDKs, using the cookbooks and quickstarts as templates. The Awesome Claude directory is a reasonable index for finding the current cheatsheet, MCP servers, skills, and SDK links in one place.

Claude Code is Anthropic's terminal-based coding agent, and a useful cheatsheet centers on four things: how you start and resume sessions, what you type inside a session, how you configure project memory and permissions, and how you extend it with MCP servers and agent skills. The official reference for all of this lives at platform.claude.com/docs, and the Claude Code 2.1 cheatsheet is curated on awesomeclaude.ai. Use this page as a working map of those areas; confirm exact flags and syntax against the official docs before scripting anything.

Starting and Managing Sessions

Claude Code runs from your terminal and works against your local repository. The general pattern is: you launch it from the project directory, describe a task in natural language, and it reads files, proposes edits, and runs commands with your approval.

Because the docs are the authoritative source for exact command names and flags, treat any third-party cheatsheet as a starting index rather than a spec.

In-Session Commands and Shortcuts

Inside a session, the workflow is conversational: you ask for a change, Claude Code reads the relevant files, and you review what it proposes. The recurring actions a cheatsheet should help you with are:

• Reviewing diffs before accepting. Edits are presented for approval, so read the diff rather than approving blindly, especially in files you haven't opened.
• Approving or rejecting commands. When Claude Code wants to run a shell command, you decide whether it proceeds. This is your main safety checkpoint.
• Correcting course mid-task. If it heads in the wrong direction, redirect in plain language instead of restarting the session.
• Referencing specific files. Point it at the files or directories that matter so it doesn't spend turns searching.

For the exact slash commands and keyboard shortcuts available in your version, check the official Claude Code documentation, since these change between releases.

Configuration: Project Memory and Permissions

The configuration layer is what makes Claude Code repeatable across sessions and across a team. Two pieces matter most:

CLAUDE.md project memory. A CLAUDE.md file at the project root gives Claude Code standing context: build commands, conventions, architecture notes, and things to avoid. Write it the way you'd onboard a new contributor — concrete commands and rules beat vague descriptions.

Permissions and settings. Settings files control what Claude Code may do without asking, such as which commands are pre-approved. Tighten these for shared or sensitive repositories and loosen them only where you've reviewed the risk.

A practical setup order: create CLAUDE.md with your build/test commands and conventions, then define permissions for the commands you run constantly, then commit both so every session and teammate starts from the same baseline.

Extending Claude Code: MCP Servers and Agent Skills

Claude Code's capabilities extend through two mechanisms highlighted in the Awesome Claude directory:

• MCP servers (Model Context Protocol) connect Claude Code to external tools and data sources — the directory lists top MCP servers, and Anthropic's docs cover the MCP Connector.
• Agent skills package reusable instructions and workflows so Claude Code handles recurring task types consistently.

Anthropic's Claude Cookbook (github.com/anthropics/claude-cookbooks, ~53k stars) includes official notebooks and recipes for common patterns including RAG, tool use, Skills, and MCP — the most reliable place to see these extensions in working code. The Agent SDKs (claude-agent-sdk-python, ~8.3k stars, and claude-agent-sdk-typescript) are the path if you want to build agents on top of Claude programmatically rather than only using the CLI.

Where to Go Beyond the Cheatsheet

A cheatsheet goes stale; the sources below don't:

If you're on Bedrock, plan around that limitation: the Messages-API endpoint serves Claude 5 models with an ID prefix and supports cross-region inference and guardrails, but agent-style server-side tooling needs the direct Claude API.

Bottom Line

Learn Claude Code in this order: get comfortable starting and resuming sessions, build the habit of reviewing diffs and approving commands deliberately, write a solid CLAUDE.md and permissions file, then extend with MCP servers and skills once the basics are routine. Keep platform.claude.com/docs open as the source of truth and use awesomeclaude.ai to discover what to add next.