@@ -46,7 +46,7 @@ There are three moves here:
 And that's it. `Skills(list_skills=..., get_skill=...)` is all a server needs;
 `resources/directory/read` is optional (more on that below).
 
-## Fetching a skill
+## Inspecting a skill
 
 On the client side, `Skills` is a [`ClientExtension`](extensions.md). You register it the same way
 you register any other one — by passing it to `Client(extensions=[...])` — and then call `extension` to
@@ -56,7 +56,7 @@ get the verbs tied to that connection:
 --8<-- "docs_src/skills/tutorial001_client.py"
 ```
 
-`client.extension(Skills)` hands you a `BoundSkills`, and its methods are the SEP-2640 verbs:
+`client.extension(Skills)` hands you a `BoundSkills` with the SEP-2640 methods:
 
 * `list_skills` and `read_directory` follow `nextCursor` to completion, so a single call gives you
   every page's skills or resources.
@@ -66,25 +66,21 @@ These three validate the server's response against the SEP-2640 conformance rule
 it. A name that doesn't match its URI, a digest in the wrong shape, or an incomplete manifest raises
 `ValueError` rather than reaching your code.
 
-`read_skill_uri` is the exception. It's a thin, discoverable alias for `resources/read` that returns
-a `ReadResourceResult` (text or blob contents) and validates nothing itself — that's the next step.
+Read a skill file with `Client.read_resource(uri)`, the same method you use for any MCP resource.
+It returns raw content without checking it against the skill's manifest.
 
-!!! tip
-    `verify_skill_resource(skill, uri, content)` checks a file's bytes — size, then SHA-256
-    digest — against the entry you hold for it. Call it after `read_skill_uri` and *before* you
-    treat the content as trustworthy.
+!!! warning "Verify files before loading"
+    A host that loads a skill must hold its `Skill` entry. Before using a fetched file, check that
+    its URI appears in that entry's `resources` and that its bytes match the advertised size and
+    SHA-256 digest. A `"dynamic"` skill has no digest to check. Refreshing the entry to accept
+    changed bytes also changes the content to which any prior approval applied.
 
-    `resources/read` returns whatever bytes the server sends *right now*; verification is what ties
-    those bytes back to the manifest you already validated. It applies to a static manifest only —
-    a `"dynamic"` skill carries no digests, so calling it on one raises `ValueError`.
-
-!!! warning
     Skill content is untrusted model input, exactly like any other server-provided text. SEP-2640
     requires a host to tag it with its originating server before it reaches the model, and to
     never grant the frontmatter's `allowed-tools` field (or any other permission-widening field)
     without explicit per-skill user approval.
 
-    A digest match confirms the *bytes*, not the *frontmatter*: it doesn't prove the
+    A matching digest confirms the *bytes*, not the *frontmatter*: it doesn't prove the
     `frontmatter` the server advertised in `skills/get` matches the frontmatter inside the fetched
     `SKILL.md`. If you act on `skill.frontmatter` — especially `allowed-tools` — parse the fetched
     file and compare its frontmatter yourself.
 
@@ -2,8 +2,6 @@
 
 from mcp import Client
 from mcp.client.skills import Skills
-from mcp.shared.skills import verify_skill_resource
-from mcp.types import TextResourceContents
 
 
 async def main() -> None:
@@ -13,11 +11,7 @@ async def main() -> None:
             print(skill.uri, skill.frontmatter["description"])
 
         skill = await catalog.get_skill("skill://git-workflow/SKILL.md")
-        result = await catalog.read_skill_uri(skill.uri)
-        content = result.contents[0]
-        if isinstance(content, TextResourceContents):
-            verify_skill_resource(skill, skill.uri, content.text.encode())
-            print(content.text)
+        print(skill.resources)
 
 
 if __name__ == "__main__":
 
@@ -3,7 +3,7 @@
 `Skills` is an opt-in [`ClientExtension`](../advanced/extensions.md) for talking
 to a skills catalog server. Register it with `Client(extensions=[Skills()])`,
 then call `client.extension(Skills)` for the SEP-2640 verbs — `list_skills`, `get_skill`,
-`read_skill_uri`, and `read_directory` — tied to that connection:
+and `read_directory` — tied to that connection:
 
     async with Client("http://localhost:8000/mcp", extensions=[Skills()]) as client:
         for skill in await client.extension(Skills).list_skills():
@@ -13,13 +13,11 @@
 `get_skill`, and `read_directory` — check that the server advertises the
 extension and validate its response; `list_skills` and `read_directory` follow
 `nextCursor` to completion, so one call returns every page's results.
-`read_skill_uri` is a thin `resources/read` alias that does neither — verify its
-result with `verify_skill_resource`.
 """
 
 from __future__ import annotations
 
-from mcp_types import ReadResourceResult, Resource
+from mcp_types import Resource
 
 from mcp.client.extension import ClientExtension
 from mcp.client.session import ClientSession
@@ -63,9 +61,8 @@ class BoundSkills:
     `get_skill`, and `read_directory` — check that the server advertises the
     extension and validate its response against the SEP-2640 conformance rules
     before returning; `list_skills` and `read_directory` also follow
-    `nextCursor` to completion. `read_skill_uri` is the exception: a thin
-    `resources/read` alias that neither checks advertisement nor validates —
-    pair it with `verify_skill_resource`.
+    `nextCursor` to completion. Read a skill's files with the ordinary
+    `Client.read_resource` method.
     """
 
     def __init__(self, session: ClientSession) -> None:
@@ -136,21 +133,6 @@ async def get_skill(self, uri: str) -> Skill:
             raise ValueError(f"server returned skill {result.skill.uri!r} for requested {uri!r}")
         return result.skill
 
-    async def read_skill_uri(self, uri: str) -> ReadResourceResult:
-        """Read a skill file's content via `resources/read`.
-
-        A thin, discoverable alias: works for any `skill://` (or other-scheme)
-        file regardless of whether the skill was ever enumerated. Verify the
-        result against a held `Skill` entry with `verify_skill_resource` before
-        treating it as trusted content — this call does not verify anything itself.
-
-        Raises:
-            MCPError: If the server returns an error response.
-            RuntimeError: If the server returns an `InputRequiredResult`; this
-                alias does not drive the input-required loop.
-        """
-        return await self._session.read_resource(uri)
-
     async def read_directory(self, uri: str, params: ReadDirectoryParams | None = None) -> list[Resource]:
         """Call `resources/directory/read` for `uri`, following `nextCursor` to completion.
 
 
@@ -7,7 +7,6 @@
 
 from __future__ import annotations
 
-import hashlib
 import re
 from typing import Annotated, Any, Literal
 from urllib.parse import urlsplit
@@ -27,7 +26,6 @@
     "GetSkillResult",
     "ReadDirectoryParams",
     "ReadDirectoryResult",
-    "verify_skill_resource",
 ]
 
 EXTENSION_ID = "io.modelcontextprotocol/skills"
@@ -297,27 +295,3 @@ def validate_directory_result(uri: str, result: ReadDirectoryResult) -> None:
         if resource.uri in seen_uris:
             raise ValueError(f"directory {uri!r} contains a duplicate child {resource.uri!r}")
         seen_uris.add(resource.uri)
-
-
-def verify_skill_resource(skill: Skill, uri: str, content: bytes) -> None:
-    """Check that `content` (the bytes read from `uri`) matches `skill`'s manifest entry.
-
-    Recomputes the size and SHA-256 digest of `content` and compares them to the
-    entry `skill` holds for `uri` — the byte-integrity check SEP-2640 requires
-    before a host trusts a fetched file. A `"dynamic"` skill carries no digests,
-    so it has nothing to verify against.
-
-    Raises:
-        ValueError: If `uri` is not one of `skill`'s resources, `skill.resources`
-            is `"dynamic"`, or `content`'s size or digest doesn't match the entry.
-    """
-    if skill.resources == "dynamic":
-        raise ValueError(f"skill {skill.uri!r} has dynamic resources and cannot be integrity-verified")
-    entry = next((r for r in skill.resources if r.uri == uri), None)
-    if entry is None:
-        raise ValueError(f"{uri!r} is not in skill {skill.uri!r}'s held manifest")
-    if len(content) != entry.size:
-        raise ValueError(f"resource {uri!r} has size {len(content)}, expected {entry.size}")
-    digest = f"sha256:{hashlib.sha256(content).hexdigest()}"
-    if digest != entry.digest:
-        raise ValueError(f"resource {uri!r} has digest {digest!r}, expected {entry.digest!r}")
@@ -6,7 +6,7 @@
 from typing import Any
 
 import pytest
-from mcp_types import INVALID_PARAMS, Resource, TextResourceContents
+from mcp_types import INVALID_PARAMS, Resource
 
 from mcp.client.client import Client
 from mcp.client.skills import BoundSkills
@@ -28,7 +28,6 @@
     ReadDirectoryResult,
     Skill,
     SkillResource,
-    verify_skill_resource,
 )
 
 pytestmark = pytest.mark.anyio
@@ -196,24 +195,6 @@ async def test_get_skill_propagates_the_servers_unknown_skill_error() -> None:
     assert exc_info.value.code == INVALID_PARAMS
 
 
-async def test_read_skill_uri_reads_the_registered_resource() -> None:
-    async with _skills(_server()) as skills:
-        result = await skills.read_skill_uri(_SKILL_URI)
-    contents = result.contents[0]
-    assert isinstance(contents, TextResourceContents)
-    assert contents.text == _SKILL_CONTENT
-
-
-async def test_read_skill_uri_content_verifies_against_the_held_skill() -> None:
-    """End-to-end: `skills/get`'s digest and `resources/read`'s bytes agree."""
-    async with _skills(_server()) as skills:
-        skill = await skills.get_skill(_SKILL_URI)
-        result = await skills.read_skill_uri(_SKILL_URI)
-    contents = result.contents[0]
-    assert isinstance(contents, TextResourceContents)
-    verify_skill_resource(skill, _SKILL_URI, contents.text.encode())
-
-
 async def test_read_directory_follows_next_cursor_to_completion() -> None:
     async with _skills(_server(with_directory_read=True)) as skills:
         resources = await skills.read_directory("skill://git-workflow/references")
 
@@ -7,7 +7,6 @@
 from mcp import Client
 from mcp.client.skills import Skills
 from mcp.shared.exceptions import MCPError
-from mcp.shared.skills import verify_skill_resource
 
 pytestmark = pytest.mark.anyio
 
@@ -46,16 +45,3 @@ async def test_the_skill_file_is_served_as_an_ordinary_resource() -> None:
     assert isinstance(contents, TextResourceContents)
     assert contents.mime_type == "text/markdown"
     assert contents.text == tutorial001.SKILL_MD
-
-
-async def test_read_skill_uri_content_verifies_against_the_held_skill() -> None:
-    """tutorial001_client: fetch the entry, read the file, verify the bytes against it -
-    the digest/size check `verify_skill_resource` performs."""
-    skills = Skills()
-    async with Client(tutorial001.mcp, extensions=[skills]) as client:
-        catalog = client.extension(Skills)
-        skill = await catalog.get_skill(tutorial001.SKILL_URI)
-        result = await catalog.read_skill_uri(skill.uri)
-    contents = result.contents[0]
-    assert isinstance(contents, TextResourceContents)
-    verify_skill_resource(skill, skill.uri, contents.text.encode())
@@ -1,10 +1,9 @@
-"""SEP-2640 conformance checks in `mcp.shared.skills`: types, validation, and verification.
+"""SEP-2640 conformance checks in `mcp.shared.skills`: types and validation.
 
 Server- and client-side end-to-end wiring live in `tests/server/test_skills.py` and
 `tests/client/test_skills.py`; this file pins the pure functions both depend on.
 """
 
-import hashlib
 from typing import Any
 
 import pytest
@@ -21,7 +20,6 @@
     parse_directory_uri,
     skill_name_from_uri,
     validate_directory_result,
-    verify_skill_resource,
 )
 
 _DIGEST = "sha256:" + "a" * 64
@@ -356,51 +354,3 @@ def test_validate_directory_result_rejects_a_uri_outside_the_directory() -> None
     result = ReadDirectoryResult(resources=[Resource(uri="skill://other/file.md", name="file.md")])
     with pytest.raises(ValueError, match="not a child"):
         validate_directory_result("skill://pdf/templates", result)
-
-
-def test_verify_skill_resource_accepts_matching_content() -> None:
-    content = b"hello skill"
-    digest = f"sha256:{hashlib.sha256(content).hexdigest()}"
-    uri = "skill://git-workflow/SKILL.md"
-    skill = Skill(
-        uri=uri,
-        frontmatter={"name": "git-workflow", "description": "d"},
-        resources=[SkillResource(uri=uri, digest=digest, size=len(content))],
-    )
-    verify_skill_resource(skill, uri, content)
-
-
-def test_verify_skill_resource_rejects_a_digest_mismatch() -> None:
-    """SEP-2640 Integrity and verification: a mismatch MUST be treated as a verification failure."""
-    uri = "skill://git-workflow/SKILL.md"
-    skill = Skill(
-        uri=uri,
-        frontmatter={"name": "git-workflow", "description": "d"},
-        resources=[SkillResource(uri=uri, digest=_DIGEST, size=5)],
-    )
-    with pytest.raises(ValueError, match="digest"):
-        verify_skill_resource(skill, uri, b"wrong")
-
-
-def test_verify_skill_resource_rejects_a_size_mismatch_before_hashing() -> None:
-    uri = "skill://git-workflow/SKILL.md"
-    skill = Skill(
-        uri=uri,
-        frontmatter={"name": "git-workflow", "description": "d"},
-        resources=[SkillResource(uri=uri, digest=_DIGEST, size=999)],
-    )
-    with pytest.raises(ValueError, match="size"):
-        verify_skill_resource(skill, uri, b"short")
-
-
-def test_verify_skill_resource_rejects_dynamic_resources() -> None:
-    uri = "skill://generated/SKILL.md"
-    skill = Skill(uri=uri, frontmatter={"name": "generated", "description": "d"}, resources="dynamic")
-    with pytest.raises(ValueError, match="dynamic"):
-        verify_skill_resource(skill, uri, b"anything")
-
-
-def test_verify_skill_resource_rejects_a_uri_not_in_the_manifest() -> None:
-    skill = _skill()
-    with pytest.raises(ValueError, match="not in skill"):
-        verify_skill_resource(skill, "skill://git-workflow/unlisted.md", b"x")