Tutorials

Claude Skills vs MCP: Instructions, Tools and Useful Workflows

A minimal skill folder, tool dependency map and fixture-based validation. Explore the interface with Atoms.

Start building for free
7 min readPublished
Illustrative editorial photograph for claude skills
On this page

Claude Skills package instructions for a repeatable task. MCP connects an AI application to tools and resources. A workflow can use both: the skill explains how to review an expense report, while an MCP tool retrieves the report or records an approved decision. Choosing between them starts with what is missing from your current process: a reliable procedure, access to external data, or both.

This guide builds an illustrative expense-review workflow. The files, identifiers and test receipts below are design examples, not evidence that a particular Claude account or app already supports the complete workflow.

Understand what each component supplies

The Agent Skills specification describes a folder containing a required SKILL.md file and optional supporting resources. The file combines YAML metadata with instructions. A compatible agent can discover the metadata and load more detail when the skill is relevant. Progressive loading makes the description important: it helps the agent decide when to use the procedure.

Anthropic documents Agent Skills for Claude, including product-specific execution requirements. An open file format does not establish identical behavior across every host. Check where your chosen surface discovers skills, what execution environment it provides, and which supporting files it can read.

MCP defines a client-server approach for exposing capabilities such as tools and resources to AI applications. A tool description tells the application what an operation accepts and returns. It does not, by itself, supply your organization's entire review procedure.

Missing capability First component to investigate Example
A repeatable sequence of decisions Skill Read the policy, identify exceptions, prepare a review
Access to current external records Tool connection Retrieve one report by its identifier
A reusable output format Skill resource Fill a review receipt with required fields
Permission to change a record Application authorization Allow an authorized reviewer to approve a report

These distinctions matter during debugging. If the agent consistently omits the receipt, inspect the instructions. If it cannot retrieve a record, inspect tool access. If an unauthorized user can approve a report, inspect the application enforcing the write.

Start with a narrow skill folder

The following sample uses a lowercase, hyphenated name and a description that states the task and trigger. Its policy is fictional. Replace it with a policy that your team owns before using real reports.

text
expense-review/
  SKILL.md
  references/
    policy.md
  assets/
    review-receipt.md
yaml
---
name: expense-review
description: Review an expense report against the supplied policy and prepare a source-backed decision receipt when a user requests expense review.
---

Below the metadata, write instructions that identify inputs and stopping conditions:

text
Read references/policy.md before reviewing a report.
Retrieve only the report the user identified.
Check the receipt, currency, category and policy version.
Mark unavailable evidence as missing; do not infer it.
Prepare assets/review-receipt.md with evidence references.
Do not approve or reimburse a report unless the current
user request and application permissions allow that action.
Read back any authorized change and include its record ID.

Keep the primary instructions short enough to scan. Put lengthy policy tables in the reference file, and give each reference a clear reason to be opened. A folder full of unreferenced material is difficult to maintain and may never be used by the agent.

The description should match ordinary user requests. “Expense review” is a better trigger than a vague promise to improve business operations. Avoid triggering the skill for every accounting question: a tax explanation or budgeting discussion may require a different task and different evidence.

Map instructions to tools and permissions

Define a proposed read operation such as get_expense_report(report_id). Its response should include the report identifier, receipt references, submitted amount, currency and current status. These fields let the agent tie a decision to a specific record rather than a loose paragraph of text.

If approval is in scope, define a separate write operation with its own authorization. Include an expected version so that a decision prepared against an older report cannot silently overwrite a newer submission. These are design recommendations; the names below are not standard MCP methods.

Proposed operation Purpose Required check
get_expense_report Read the named submission Caller can access that report
get_policy_version Read the applicable policy Returned version is recorded
record_review Save a review receipt Caller can review; expected version matches
approve_report Change approval status Caller can approve that report

A skill cannot grant permission simply by saying “approve this.” The service receiving a write must enforce the caller's authority. Tool credentials also should not be stored inside the skill folder, where they could travel with the instructions or appear in a shared repository.

Return structured errors for a missing report, expired authorization or version conflict. The agent can then stop with a concrete reason instead of treating every failed operation as a prompt-writing problem.

Validate with fixtures before live records

Use synthetic reports to test whether the skill produces useful decisions. This fixture set covers more than the easiest success case:

Fixture Input condition Expected review
EXP-101 Complete receipt and matching currency Cite receipt and policy; prepare decision
EXP-102 Receipt absent Mark missing evidence; do not invent merchant details
EXP-103 Policy version unavailable Explain that policy applicability is unresolved
EXP-104 Report changes after review begins Reject stale write and retrieve current version
EXP-105 User lacks approval permission Prepare permitted review only

For each run, save the request, fixture version, tool responses and final receipt. Inspect whether the agent opened the intended reference and used the returned record identifiers. A fluent answer alone does not show that the tool data was read correctly.

The receipt can contain report_id, report_version, policy_version, evidence, missing_fields, proposed_decision and write_result. Keep a proposed decision separate from the stored status. If no write was requested, the receipt should make that clear without implying a completed approval.

Try an unrelated request as well. Asking for a general explanation of travel budgeting should not cause the expense-review skill to fetch an arbitrary report. Trigger precision is part of workflow quality, alongside correct execution once the skill is loaded.

Build a review interface with Atoms

Atoms helps turn a written brief into a website or web app that you can iterate on. For this workflow, an interface can display synthetic reports, policy versions and review receipts. A standalone interface is separate from Claude skill discovery and an MCP connection; those integrations require their own implementation and testing.

Use this starter prompt in Atoms:

text
Build an expense-review workbench using synthetic records.
Show a report list, report detail and review-receipt panel.
Include report version, policy version, evidence links,
missing fields and proposed decision. Use three demo reports:
complete, missing receipt and version conflict. Display saved
review status separately from proposed approval. Add viewer
and reviewer roles. Begin with local demo data and explain
which backend checks are required before real records.

The AI app builder guide provides context for starting an application from a brief. If the workbench needs privileged actions, apply the server-side checks in the admin panel guide before connecting a real approval service.

Review the saved receipt after reloading the interface. Then test whether a viewer can submit the same write through a direct request. A disabled button is useful feedback, but the service must still reject a caller who lacks permission.

Maintain the procedure as dependencies change

Give the policy and skill a clear owner. When a tool response changes, update the mapping and rerun the fixtures that depend on those fields. When the policy changes, retain the version used for earlier receipts so historical decisions remain understandable.

Track changes that affect behavior: a new evidence requirement, a different approval boundary or a new missing-data state. Editing a date without changing or checking the underlying content does not demonstrate freshness.

Use the sample brief to start a expense review workbench in Atoms.

Build my expense review workbench

Conclusion

A useful Claude Skills workflow joins a clear procedure with the right data access and enforceable permissions. Begin with one task, a small fixture set and a receipt that distinguishes a proposal from a saved result. Build the review workbench with Atoms, then verify the actual skill and tool integration before introducing real expense data.

Create a first version with synthetic data and review the results.

Start with Atoms

FAQs

Q1: Do Claude Skills replace MCP servers?

They serve different purposes and can work together. A skill packages task instructions and supporting resources; an MCP server exposes tools or other capabilities to a compatible AI application. An expense-review skill can explain how to evaluate a report while an MCP tool retrieves the current submission. If your task only needs instructions and local files, an external connection may be unnecessary. If it needs current records or authorized changes, you need an appropriate access mechanism. Check the capabilities of the particular host rather than assuming every skills-enabled product supports the same tools.

Q2: Can a skill safely approve records automatically?

Automatic approval requires more than an instruction file. The workflow needs a defined policy, reliable inputs, permission checks and a service that controls the actual status change. Start by producing proposed decisions against synthetic fixtures. Test missing receipts, stale versions and callers who cannot approve. If automatic writes are later authorized, record the exact report and policy versions and read back the saved result. The skill should stop when required evidence is absent. Treat approval authority as an application decision, rather than a capability created by wording in the skill.

Q3: How do I know whether my skill is useful?

Compare its output against concrete task expectations. For an expense review, the receipt should cite the right report, identify the applicable policy and explain missing evidence. Repeat the task with a changed record and confirm that stale information is handled correctly. Also test an unrelated request to see whether the skill activates unnecessarily. Save these fixtures and expected results so later edits can be evaluated consistently. A useful skill improves a repeatable process and makes its evidence easier to inspect; a longer instruction file or polished response is not sufficient proof.

Share this article
Made with Atoms

Your next idea starts here.

Turn what you learned into a working app or website.

Start building for free