Core Sub-Skills of the Patent-Disclosure-Skill: A Complete Technical Breakdown

The patent-disclosure-skill bundles six specialized sub-skills—patent-disclosure, patent-application, patent-reader, patent-oa, patent-search, and patent-exam-policy—that automate the complete patent workflow from initial disclosure drafting through Office-Action responses.

The handsomestWei/patent-disclosure-skill repository provides an end-to-end automation framework for Chinese patent workflows. Understanding the core sub-skills of the patent-disclosure-skill is essential for practitioners who want to streamline invention documentation, prior-art searches, and examination responses. Each sub-skill operates as an independent module within a unified AgentSkills runtime, allowing selective reuse across different stages of the patent lifecycle.

The Six Core Sub-Skills at a Glance

The repository defines six tightly integrated sub-skills in the top-level SKILL.md file. Each entry maps a natural-language trigger phrase to a specific functional module responsible for a distinct stage of patent work.

Sub-skill	Trigger Phrase	Primary Function
patent-disclosure	"交底书"	Generates invention disclosures, utility models, or design-patent templates with prior-art search capabilities.
patent-application	"申请文件" / "申请底稿"	Converts completed disclosures into formal claim sets, specifications, abstracts, and submission-ready drawings.
patent-reader	"读专利"	Parses published patent PDFs or publication numbers to create plain-language summaries and Obsidian-compatible knowledge graphs.
patent-oa	"审查答复" / "审查意见"	Assists with Office-Action responses through examiner query analysis and reply draft generation.
patent-search	"著录检索"	Queries the CNIPA EP-pub database by inventor, applicant, or IPC/LOC classification to produce structured bibliographic reports.
patent-exam-policy	"政策简报" / "政策雷达"	Analyzes recent CNIPA policy releases and generates concise impact reports for drafting guideline alignment.

Deep Dive into Each Patent-Disclosure-Skill Sub-Skill

Patent-Disclosure (交底书)

The patent-disclosure sub-skill initiates the invention workflow by generating structured disclosure documents. Located in skills/patent-disclosure/, this module extracts patent points from raw technical descriptions and performs automated prior-art searches. The implementation uses Python scripts to populate templates for invention patents, utility models, or design patents, then produces iterative drafts stored in the outputs/ directory.

Patent-Application (申请文件)

The patent-application sub-skill transforms finalized disclosures into legally compliant application packages. As documented in skills/patent-application/README.md, this module generates claim sets, technical specifications, abstracts, and black-and-white line drawings required for CNIPA submission. It bridges the gap between technical disclosure language and formal patent prose.

Patent-Reader (读专利)

The patent-reader sub-skill parses published patent documents into actionable knowledge assets. This module accepts publication numbers (e.g., CN209861402U) or PDF files, creates plain-language summaries, and exports structured notes into Obsidian vaults. The implementation leverages markdown converters and knowledge-graph generators to map technical relationships between patents.

Patent-OA (审查答复)

The patent-oa sub-skill streamlines Office-Action responses through intelligent examiner query analysis. This module answers specific rejection objections, produces formal reply drafts, and optionally performs knowledge-distillation using vector-based retrieval systems. The workflow handles both technical claim amendments and formal procedural responses.

Patent-Search (著录检索)

The patent-search sub-skill provides bibliographic intelligence through the CNIPA EP-pub database interface. This module supports queries by inventor name, applicant entity, IPC/LOC classification codes, or title keywords, emitting structured JSON or Markdown reports. The implementation includes Playwright crawlers for web-scraping fallback sources when API limits are reached.

Patent-Exam-Policy (政策简报)

The patent-exam-policy sub-skill monitors regulatory changes and produces policy impact assessments. This module aligns recent CNIPA guideline releases with internal drafting standards, generating concise briefs that inform prosecution strategy. The analysis draws from official policy documents to flag compliance requirements affecting pending applications.

Modular Architecture Implementation

Front-End Trigger Layer

The front-end trigger layer parses natural-language commands through the AgentSkills runtime. When a user issues a trigger phrase like "交底书" or "著录检索", the system consults SKILL.md to route the request to the appropriate sub-skill handler. This routing mechanism decouples user interaction from backend processing logic.

Core Processing Modules

Each sub-skill maintains its own core processing module as a self-contained Python package under the skills/ directory. These modules encapsulate specialized toolboxes including Playwright crawlers for web automation, pandas pipelines for data processing, and python-docx generators for document output. This independence allows developers to modify or extend individual sub-skills without affecting the broader system.

Shared Utility Layer

The shared utility layer provides cross-cutting infrastructure to ensure consistent behavior across all sub-skills. Common helpers such as stdio_utf8.py handle UTF-8 I/O operations, while centralized configuration loaders and logging frameworks reduce code duplication. This architectural pattern enforces uniform error handling and output formatting standards across the patent workflow.

Invoking Sub-Skills Programmatically

You can trigger any sub-skill programmatically using the SkillRunner class from the AgentSkills SDK. Below is a complete example demonstrating invocation patterns for all six core sub-skills:

from agentskills import SkillRunner

# 1. Draft an invention disclosure document

runner = SkillRunner("patent-disclosure")
runner.run(trigger="交底书", inputs={"project_path": "./my_project"})

# 2. Convert disclosure to formal application package

runner = SkillRunner("patent-application")
runner.run(trigger="申请文件", inputs={"disclosure_dir": "./outputs/2024-05-01"})

# 3. Parse published patent into Obsidian notes

runner = SkillRunner("patent-reader")
runner.run(trigger="读专利", inputs={"pub_number": "CN209861402U"})

# 4. Generate Office-Action response draft

runner = SkillRunner("patent-oa")
runner.run(trigger="审查答复", inputs={"oa_text": "权利要求1不具备创造性..."})

# 5. Query CNIPA bibliographic records

runner = SkillRunner("patent-search")
runner.run(trigger="著录检索", inputs={"inventor": "张三", "class_code": "G06F"})

# 6. Produce policy brief for latest guidelines

runner = SkillRunner("patent-exam-policy")
runner.run(trigger="政策简报", inputs={"policy_date": "2024-04-01"})

Each run() call loads the corresponding module’s main() function and returns structured results—typically Markdown, Word documents, JSON data, or Obsidian notes—to the outputs/ directory.

Summary

• The patent-disclosure-skill comprises six specialized sub-skills mapped to distinct patent workflow stages: disclosure drafting, application generation, patent reading, Office-Action response, bibliographic search, and policy monitoring.
• Each sub-skill is triggered by specific Chinese phrases (e.g., "交底书", "审查答复") defined in the repository's SKILL.md registry.
• The modular architecture separates front-end triggers, core processing logic, and shared utilities, enabling independent extension of individual capabilities.
• All sub-skills support programmatic invocation via the AgentSkills SkillRunner class, returning standardized outputs to the outputs/ directory.
• Technical implementation relies on Python automation with Playwright crawlers, document converters, and vector-based retrieval systems for comprehensive patent lifecycle management.

Frequently Asked Questions

What triggers each sub-skill in the patent-disclosure-skill?

Each sub-skill responds to a specific natural-language trigger phrase in Chinese. The patent-disclosure sub-skill activates on "交底书", while patent-application responds to "申请文件" or "申请底稿". The patent-oa sub-skill triggers on "审查答复" or "审查意见", and patent-search activates with "著录检索". These mappings are centrally defined in the repository's SKILL.md file.

Can I use individual sub-skills without the full patent-disclosure-skill suite?

Yes. The architecture treats each sub-skill as an independent Python package under the skills/ directory. You can import and execute individual modules by invoking their specific SkillRunner with the appropriate trigger phrase. The shared utility layer ensures consistent behavior even when running isolated components.

What output formats do the patent-disclosure-skill sub-skills generate?

The sub-skills produce Markdown documents, Word files (.docx), JSON structured data, and Obsidian-compatible notes depending on the specific workflow. Disclosure and application sub-skills typically output Word documents for legal submission, while the reader and search sub-skills favor Markdown and JSON for knowledge management and data interchange.

How does the patent-oa sub-skill handle Office-Action analysis?

The patent-oa sub-skill processes examiner rejection text through natural-language analysis to identify specific statutory grounds. It generates formal reply drafts that address claim amendments or argumentation strategies. The module optionally employs vector-based retrieval to perform knowledge-distillation from prior responses or technical literature, enhancing the quality of rebuttal arguments.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}