Claude patent-search skill: 10 prior-art and freedom-to-operate workflows

The prompt

Read `disclosure.md` and extract the 6–10 most discriminating technical terms. Build a PatentsView `/patent/` POST with `_text_any` over `patent_title` and `patent_abstract`, restricted to `patent_date >= 2014-01-01`. Return 25 candidates sorted by `patent_date` desc, with `patent_id`, `patent_title`, `assignees.assignee_organization`, and a `https://patents.google.com/patent/US{patent_id}` link. Save the JSON as `out/prior-art.json` and a markdown table as `out/prior-art.md`.

What slides.md looks like

import os, requests, json
HEADERS = {"X-Api-Key": os.environ["PATENTSVIEW_API_KEY"]}
TERMS = ["adaptive cruise", "lidar fusion", "lane curvature"]
body = {
    "q": {"_and": [
        {"_text_any": {"patent_abstract": " ".join(TERMS)}},
        {"_gte": {"patent_date": "2014-01-01"}},
    ]},
    "f": ["patent_id", "patent_title", "patent_date", "assignees"],
    "s": [{"patent_date": "desc"}],
    "o": {"size": 25},
}
r = requests.post("https://search.patentsview.org/api/v1/patent/",
                  headers=HEADERS, json=body, timeout=30)
json.dump(r.json(), open("out/prior-art.json", "w"), indent=2)

Pairs with

The prompt

Build an FTO sweep for assignees in `competitors.json` (Tesla, Waymo, Cruise) intersected with CPC subclass `B60W30/00`. Use `_and` over `assignees.assignee_organization` (`_text_any`) and `cpc_at_issue.cpc_subclass_id` (`_eq`), filtered to `patent_type = utility` and `patent_date >= 2010-01-01`. Return the first 100 records with claim-1 text and a derived `expires_on` (issue date + 20 years). Flag rows where `expires_on > today` as `risk = active`.

What slides.md looks like

body = {
    "q": {"_and": [
        {"_text_any": {"assignees.assignee_organization": "Tesla Waymo Cruise"}},
        {"_eq":  {"cpc_at_issue.cpc_subclass_id": "B60W30"}},
        {"_eq":  {"patent_type": "utility"}},
        {"_gte": {"patent_date": "2010-01-01"}},
    ]},
    "f": ["patent_id", "patent_title", "patent_date",
          "assignees.assignee_organization", "claims.claim_text"],
    "s": [{"patent_date": "desc"}],
    "o": {"size": 100, "after": None},
}
r = requests.post(URL, headers=HEADERS, json=body, timeout=30).json()

Pairs with

The prompt

Generate a landscape report for CPC class `H04L9` (cryptographic mechanisms). Run three PatentsView queries: (a) top 20 `assignees.assignee_organization` by patent count over 2014–2024 sorted desc, (b) annual patent counts grouped by `patent_year` for the same class, (c) top 10 patents by `cited_by_us_patents.patent_id` count in the class. Write the result as `landscape-H04L9.md` with three tables and a one-paragraph executive summary.

What slides.md looks like

for year in range(2014, 2025):
    body = {
        "q": {"_and": [
            {"_eq":  {"cpc_at_issue.cpc_subclass_id": "H04L9"}},
            {"_eq":  {"patent_year": year}},
        ]},
        "f": ["patent_id"],
        "o": {"size": 1},  # we only need total_hits
    }
    r = requests.post(URL, headers=HEADERS, json=body, timeout=30).json()
    print(year, r["total_hits"])

Pairs with

The prompt

Take patent `US10891295` as the focal node. Use the PatentsView `/patent/` endpoint to fetch its `cited_patents.patent_id` array (outbound) and its `cited_by_us_patents.patent_id` array (inbound). For each inbound and outbound patent, write a row `(focal_id, neighbor_id, direction)` to `out/edges.csv`. Stop at depth 1 — do not recurse on the neighbors.

What slides.md looks like

body = {
    "q": {"_eq": {"patent_id": "10891295"}},
    "f": ["patent_id", "patent_title",
          "cited_patents.patent_id",
          "cited_by_us_patents.patent_id"],
}
focal = requests.post(URL, headers=HEADERS, json=body, timeout=30).json()["patents"][0]
with open("out/edges.csv", "w") as fh:
    fh.write("source,target,direction\n")
    for c in focal["cited_patents"]:
        fh.write(f"{focal['patent_id']},{c['patent_id']},out\n")
    for c in focal["cited_by_us_patents"]:
        fh.write(f"{c['patent_id']},{focal['patent_id']},in\n")

Pairs with

The prompt

Find every patent listing inventor `Andrej Karpathy`. Use the PatentsView `/patent/` endpoint with `_and` over `inventors.inventor_name_first` (`_eq` Andrej) and `inventors.inventor_name_last` (`_eq` Karpathy). Return `patent_id`, `patent_title`, `patent_date`, `assignees.assignee_organization`, `inventors.inventor_state`. Sort by `patent_date` desc, page 100 at a time.

What slides.md looks like

body = {
    "q": {"_and": [
        {"_eq": {"inventors.inventor_name_first": "Andrej"}},
        {"_eq": {"inventors.inventor_name_last":  "Karpathy"}},
    ]},
    "f": ["patent_id", "patent_title", "patent_date",
          "assignees.assignee_organization",
          "inventors.inventor_state"],
    "s": [{"patent_date": "desc"}],
    "o": {"size": 100},
}
r = requests.post(URL, headers=HEADERS, json=body, timeout=30).json()
for p in r["patents"]:
    print(p["patent_date"], p["patent_id"], p["patent_title"])

Pairs with

The prompt

Build a portfolio summary for assignee `Stripe Inc`. Run four PatentsView queries: (1) total count of `patent_id` where `assignees.assignee_organization` contains 'Stripe'; (2) annual counts by `patent_year`; (3) top 5 `cpc_at_issue.cpc_subclass_id` by frequency; (4) top 5 `inventors.inventor_name_last` by count. Render the result as `out/stripe-portfolio.md`.

What slides.md looks like

body = {
    "q": {"_text_phrase": {"assignees.assignee_organization": "Stripe Inc"}},
    "f": ["patent_id", "patent_year",
          "cpc_at_issue.cpc_subclass_id",
          "inventors.inventor_name_last"],
    "o": {"size": 1000},  # 45 req/min — plan for paging on large portfolios
}
r = requests.post(URL, headers=HEADERS, json=body, timeout=30).json()
years = {}
for p in r["patents"]:
    years[p["patent_year"]] = years.get(p["patent_year"], 0) + 1
print(sorted(years.items()))

Pairs with

The prompt

Take focal patent `US9711050`. Use PatentsView's `/publication/` endpoint with `_eq` on `priority_claim.priority_doc_number` set to the focal's earliest priority application number. Return one row per `publication_country_code` with `publication_number` and `publication_date`. Save as `out/family-9711050.csv`.

What slides.md looks like

# Step 1: read focal's priority application number from /patent/
focal = requests.post(URL_PAT, headers=HEADERS, json={
    "q": {"_eq": {"patent_id": "9711050"}},
    "f": ["patent_id", "earliest_application.application_id"],
}, timeout=30).json()["patents"][0]

# Step 2: pivot on /publication/ for the family
fam = requests.post(URL_PUB, headers=HEADERS, json={
    "q": {"_eq": {"earliest_application.application_id":
                  focal["earliest_application"]["application_id"]}},
    "f": ["publication_number", "publication_country_code", "publication_date"],
    "s": [{"publication_date": "asc"}],
}, timeout=30).json()
print(len(fam["publications"]), "family members")

Pairs with

The prompt

Pull claim 1 text for `US10891295` and `US10963735` from the PatentsView `/patent/` endpoint with `f = ['claims.claim_text', 'claims.claim_number']`. Filter to `claim_number = 1`. Split each claim into clauses on the literal token `; `. Render a 3-column markdown table: `Clause`, `In US10891295`, `In US10963735`. Write to `out/claim-compare.md`.

What slides.md looks like

def claim1(patent_id):
    body = {
        "q": {"_and": [
            {"_eq": {"patent_id": patent_id}},
            {"_eq": {"claims.claim_number": "1"}},
        ]},
        "f": ["patent_id", "claims.claim_text", "claims.claim_number"],
    }
    r = requests.post(URL, headers=HEADERS, json=body, timeout=30).json()
    text = r["patents"][0]["claims"][0]["claim_text"]
    return [c.strip() for c in text.split("; ")]

a, b = claim1("10891295"), claim1("10963735")
for clause in sorted(set(a) | set(b)):
    print(f"| {clause} | {clause in a} | {clause in b} |")

Pairs with

The prompt

Read `targets.txt` (one patent number per line). For each, fetch `claims.claim_text`, `claims.claim_number`, and `claims.claim_dependent` from PatentsView's `/patent/` endpoint. Keep only rows where `claim_dependent` is null or empty. Write `out/claims/{patent_id}.json` with the surviving independent claims plus their `claim_number`.

What slides.md looks like

import json, pathlib, time
for pid in pathlib.Path("targets.txt").read_text().splitlines():
    body = {
        "q": {"_eq": {"patent_id": pid.strip()}},
        "f": ["patent_id", "claims.claim_text",
              "claims.claim_number", "claims.claim_dependent"],
    }
    r = requests.post(URL, headers=HEADERS, json=body, timeout=30).json()
    claims = r["patents"][0]["claims"]
    independent = [c for c in claims if not c.get("claim_dependent")]
    pathlib.Path(f"out/claims/{pid.strip()}.json").write_text(
        json.dumps(independent, indent=2))
    time.sleep(1.4)  # 45 req/min cap

Pairs with

The prompt

Read `disclosure.md`. Run the use-case-1 prior-art search. Take the top 5 hits. Write `out/opinion.md` with four sections: (1) Invention summary, 80 words. (2) Prior-art table (patent_id, title, assignee, key disclosure, distance from invention). (3) Novelty argument under 35 USC §102 — for each hit, name the missing limitation. (4) Non-obviousness under §103 — list two unexpected results the combination of references does not teach.

What slides.md looks like

# After running use-case-1 above, prior_art is a list of 5 candidate patents.
opinion = []
opinion.append("# Patentability opinion (DRAFT — not legal advice)\n")
opinion.append(f"## Invention\n{disclosure_summary(open('disclosure.md').read())}\n")
opinion.append("## Prior art\n| Patent | Title | Assignee | Key disclosure | Distance |")
opinion.append("|---|---|---|---|---|")
for p in prior_art[:5]:
    opinion.append(f"| US{p['patent_id']} | {p['patent_title']} "
                   f"| {p['assignees'][0]['assignee_organization']} "
                   f"| {summarize_abstract(p)} | {distance(p, disclosure)} |")
pathlib.Path("out/opinion.md").write_text("\n".join(opinion))

Pairs with