legal-skills: patent skills
legal-skills
Three skills for a US patent application: a 316-item audit, a mock USPTO examination and a design-around check of the claims
- 401 ★ on the repository
- Last commit
- GPL-3.0
Extended access
Why this level
- The draft application and invention facts go to your agent's model, and disclosure before filing can harm patent rights
- Scripts read the application files and write reports and JSON beside them, and model reports may contain wrong citations to the rules
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/gfodor-legal-skillsDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The draft application and invention facts go to your agent's model, and disclosure before filing can harm patent rights
- Scripts read the application files and write reports and JSON beside them, and model reports may contain wrong citations to the rules
This is third-party code. Review the repository files before installing.
What it does
legal-skills is three skills for preparing a US utility patent application. They run in order. patent-audit checks a draft before filing against a 316-item list. First Python scripts parse the application and compute deadlines, reference numerals and claim dependencies. Then three gates look at patentability, inventorship and deadlines, after which eight reviewers and three red-team agents go through the specification, claims, drawings and filing packet. Every fatal finding is re-checked by three fresh agents, and it reaches the report when two of the three confirm it. patent-examine simulates USPTO examination. An examiner agent writes an Office Action, the applicant answers with amendments, and the cycle repeats until two independent examiners find the same version allowable. patent-workaround tests the claims for design-arounds: fresh agents play competitors who try to keep the invention's value while escaping the claims. The skills do not file an application, sign declarations or contact the USPTO. The author states the goal as displacing a patent firm's billable hours, and leaves the output as a simulation, not a legal opinion.
Who it is for. Inventors, startup founders and in-house engineers preparing a US patent application who want to run a draft through a formal checklist before seeing a patent attorney.
Good fit when
- A draft application is ready and fatal defects have to be found before filing: deadlines, co-inventorship, pre-filing disclosure
- You want the claims checked for antecedent basis and dependencies before sending the application
- After edits you want a mock examination to see what a USPTO examiner would write in an Office Action
- You need to see how a competitor would design around the claims and keep the product's substance
- The draft is a PDF or DOCX and has to be parsed into a structure for the checks
Not a fit when
- The application is not filed in the US: the list rests on 35 U.S.C., 37 CFR and the MPEP
- You need a legal opinion on patentability, infringement or freedom to operate: the README rules out that role
- You need to file the application or sign a declaration: the skills do not do that and refuse such acts without separate authorization
Example request
Use $patent-audit to audit this draft before I file itLimitations
Python 3 is required. The parser reads `.txt`, `.md`, `.pdf` and `.docx`; PDF needs PyMuPDF and DOCX needs python-docx, and without them the scripts fail with an error instead of half-parsing.
The drawings agent works only when the sheets are attached as images; given text alone it silently skips the items. 26 items can be answered only from the intake questionnaire: without it they get the cannot_assess status.
Fee amounts, form names and USPTO practice change. The skills require refetching current texts, but you should verify the sources yourself.
How to disable. Delete the patent-audit, patent-examine and patent-workaround folders from your agent's skills directory, for example `~/.claude/skills/`. The reports and JSON files the skills wrote next to the application stay, and you delete them by hand.
FAQ
How do I install the skills in Claude Code?
Copy the three folders patent-audit, patent-examine and patent-workaround into `~/.claude/skills/` or the project `.claude/skills/`. Then ask the agent, for example: "Use $patent-audit to audit this draft before I file it". Python 3 is required.
Does this replace a patent attorney?
No. The project is not a law firm, its reports are not an opinion and promise no grant of a patent. Signing the declaration under penalty of perjury, the final duty-of-candor call, paying fees and anything that needs a registered practitioner stay with a human.
What is the intake questionnaire and why is it needed?
Questions about disclosure dates, inventorship, applicant status and fees. `prepass.py` without `--intake` writes the questionnaire and stops. Without answers, parts A, C and D go unassessed: 26 items get cannot_assess, which is the correct result.
In what order do the skills run?
First patent-audit: is the application fit to file. Then patent-examine: a mock examination until two examiners find it allowable. Then patent-workaround: a design-around check of the claims. The author advises alternating the last two until both pairs of reviewers accept one packet.
Which patents does this work for?
US utility patents. The checklist rests on 35 U.S.C., 37 CFR, the MPEP and current USPTO practice.
Discussion
No questions or reviews yet.
Related
Skillspatent-disclosure-skill for Chinese patents
patent-disclosure-skill
Nine skills for patent work in China: invention disclosures, application documents, CNIPA search, patent reading and office action replies
Paper2Patent drafts a Chinese patent application from a research paper: claims, specification, drawings and self-checks.
The skill leads an inventor by dialogue to a CNIPA technical disclosure and exports it to Word with patent figures
A plugin and skill with 14 agents for patent work: prior-art search, idea storming, drafting, review and figures in Claude Code and Codex
A collection of 71 skills for lawyers in China: OCR and transcription of materials, case and judgment analysis, contracts, patents, trademarks
Skill that prepares a China software copyright package: form data, a user manual and the first and last 30 code pages.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| legal-skills: patent skills (this card) | no | 401 | |
| oh-my-patent | no | 116 | carries patent work from prior-art search and drafting to review, while this one checks a finished draft |
| patent-disclosure-skill for Chinese patents | no | 13,376 | nine skills for patent work in China |
README in short
The README opens with the author's statement that patent work lives in files and need not be paid for. A large disclaimer block follows, then a comparison of paid services with what the repository holds, a suggested order for the three skills and installation. Each skill has its own section, with patent-audit carrying tables of checklist parts and run phases, and the GPL-3.0 license allows paid use but not closing the files.
README badge
Original SKILL.md
---
name: patent-audit
description: Audit a draft U.S. utility patent application before it is filed, against a 316-item checklist grounded in 35 U.S.C., 37 CFR, the MPEP, and current USPTO practice. Runs a deterministic pre-pass over the draft, gates on patentability, inventorship and deadlines, then fans out parallel review agents over the specification, claims, drawings and filing packet, adversarially verifies every fatal finding, and reports ranked defects with honest coverage accounting. Use when asked to audit, review, check, or pre-flight a patent application, provisional, specification, or claim set before filing.
---
# Pre-filing patent application audit
Audit a draft utility patent application against 316 checklist items and return a
ranked defect list with coverage accounting.
**Not legal advice.** The checklist is grounded in 35 U.S.C., 37 CFR, the MPEP,
and current USPTO materials. Fee amounts, form names and filing mechanics must
be re-verified against current PTO practice, and §101 case law moves. Say so
in the report; the template already does.
## What ships with this skill
| Path | Purpose |
|---|---|
| `reference/checklist_index.json` | All 316 items with routing: `id, part, section, title, check, severity, applies_to, inputs, automation, owner, blocking` |
| `reference/parts/{A..I}_*.md` | Full item text per part — **these are the agent payloads** |
| `scripts/prepass.py` | One command for all of Phase 1 |
| `scripts/parse_application.py` | Draft → structured `parsed.json` |
| `scripts/mechanical_checks.py` | Deterministic checks → `findings_mechanical.json` |
| `scripts/deadlines.py` | Intake → `deadlines.json` with weekend/holiday rollover |
| `scripts/synthesize.py` | All findings → ranked report + coverage |
| `assets/intake.yaml` | The intake questionnaire template |
| `assets/sample_draft.md` | A draft with planted defects, for testing the harness |
Routing is precomputed. Every item carries:
- **`inputs`** — what evidence it consumes: `draft_text` (210 items), `intake_facts` (99),
`forms_packet` (68), `drawings` (47), `search_report` (40), `prior_art_refs` (20),
`ppa_text` (20), `parent_app` (13).
- **`automation`** — `mechanical` (28), `assisted` (169), `judgment` (119).
- **`owner`** — which agent runs it.
- **`blocking`** — 105 items halt the audit on failure.
**26 items are answerable only from intake facts.** No document review reaches them:
`A19 A20 A22–A25 A36 C05 C08–C12 C21 D19–D26 D28 D29 I38 I42`. If intake is
skipped, those are `cannot_assess` — never `pass`.
## Core principles
**The draft fits in one context. Parallelize for attention, not capacity.** Every
agent gets the whole application. Never chunk the document across agents —
enablement, antecedent basis and numeral consistency are whole-document properties.
**Never let a model do arithmetic or exhaustive cross-referencing.** Dates, claim
counts, fee tiers, dependency graphs and numeral reconciliation run in code. Models