# Rules for Drafting Claims in Patent-Disclosure-Skill: 8 Enforced Guidelines

> Master patent claim drafting with 8 enforced guidelines in patent-disclosure-skill. Learn mandatory fields, legal referencing, and automated auditing for precise patent applications.

- Repository: [handsomestWei/patent-disclosure-skill](https://github.com/handsomestWei/patent-disclosure-skill)
- Tags: how-to-guide
- Published: 2026-09-08

---

**The patent-disclosure-skill enforces eight strict rules for drafting claims, requiring one claim per JSON node, mandatory preamble and technical features fields, automatic legal referencing for dependents, and automated auditing before export.**

Drafting patent claims requires precision and consistency. The `handsomestWei/patent-disclosure-skill` repository implements a programmatic approach to claim drafting through a structured JSON-based claim tree system. These **rules for drafting claims** are hard-coded into the Python utilities, ensuring every claim meets legal and technical standards before export to Markdown or Word documents.

## Structural Requirements for Claim Drafting

The foundation of the system rests on a hierarchical tree structure that strict enforces separation between independent and dependent claims while preventing duplication.

### One Claim Per JSON Node

The system stores claims as a hierarchical "claim tree" where each node represents a single, distinct claim. In [`skills/patent-reader/tools/vault/write_patent_obsidian_note.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-reader/tools/vault/write_patent_obsidian_note.py), the `normalize_claim_tree` function processes raw input and builds a normalized tree structure. This ensures that every claim occupies exactly one node in the JSON tree before rendering to the vault.

### Independent vs. Dependent Claim Hierarchy

Independent claims function as **root** nodes, while dependent claims attach as **children** to their parent claims. The `claim_tree_to_mermaid` function in [`skills/patent-reader/tools/vault/obsidian.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-reader/tools/vault/obsidian.py) traverses these `roots` and `nodes` to generate Mermaid diagrams that visually separate independent claims from their dependent counterparts. When a claim includes a `parent` field referencing another claim number, the system automatically recognizes it as dependent.

### Deduplication and Unique Identifiers

Duplicate claim numbers are prohibited. The `claim_deltas_from_tree` utility in [`skills/patent-reader/tools/vault/obsidian.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-reader/tools/vault/obsidian.py) checks for duplicate `claim` keys during processing. Additionally, the `merge_claim_summaries` function ensures each claim appears exactly once in the final markdown output, preventing accidental redundancies in the patent draft.

## Content and Formatting Standards

Every claim must contain specific fields and follow standardized legal formatting, enforced through schema validation and rendering logic.

### Mandatory Preamble and Technical Features

The claim-tree schema requires two critical fields: a `preamble` field (the introductory portion) and a `features` list (the technical specifics). The rendering pipeline in [`skills/patent-reader/tools/vault/write_patent_obsidian_note.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-reader/tools/vault/write_patent_obsidian_note.py), specifically the `render_claim_tree_markdown` function, concatenates these components into a single claim sentence. The preamble introduces the invention, while the features list details the novel technical elements.

### Automatic Legal Referencing for Dependents

When rendering dependent claims, the system automatically prefixes them with the legal reference "根据权利要求 X" (according to claim X). This occurs in `render_claim_tree_markdown` within [`write_patent_obsidian_note.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/write_patent_obsidian_note.py), which detects the `parent` relationship and inserts the proper Chinese legal language, ensuring compliance with patent formatting standards without manual intervention.

### Schema Enforcement for Consistent Terminology

All claim-related utilities read from and write to a canonical JSON schema defined in [`skills/patent-reader/tools/vault/schema_vault.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-reader/tools/vault/schema_vault.py). This schema enforces consistent field names including `claim`, `preamble`, `features`, and `delta`, preventing vocabulary mixing across different modules and ensuring interoperability between the reading, auditing, and export tools.

## Validation and Quality Assurance

Before claims reach the export stage, they undergo automated validation to catch structural and syntactic errors.

### Automated Claim Auditing

The `audit_claims` function in [`skills/patent-application/tools/audit_claims.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-application/tools/audit_claims.py) performs comprehensive validation checks on each claim. It verifies claim length, screens for forbidden characters, and confirms the presence of required elements (both preamble and features). If a claim violates any rule, the auditor raises an error and lists specific violations, blocking export until resolved.

## Export and Documentation

Once validated, claims move through the final output pipeline that preserves formatting across document types.

### Markdown and Word Document Generation

The skill outputs claims as a Markdown file ([`draft.md`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/draft.md)) through the rendering pipeline. For Word document generation, [`skills/patent-disclosure/tools/md_to_docx.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/md_to_docx.py) processes the markdown while preserving the critical formatting rule: one claim per paragraph. This conversion maintains the hierarchical structure and legal formatting established during the drafting phase.

## Working with the Claim Tree Programmatically

The following example demonstrates building a claim tree that satisfies all eight rules:

```python
from tools.patent_reader.vault.write_patent_obsidian_note import (
    normalize_claim_tree,
    render_claim_tree_markdown,
)

# Define a claim tree with one independent and one dependent claim

raw_tree = {
    "roots": [1],
    "nodes": [
        {
            "claim": 1,
            "preamble": "一种用于电动汽车的动力系统",
            "features": ["包括电池组", "以及控制单元"]
        },
        {
            "claim": 2,
            "parent": 1,
            "features": ["其中所述电池组为锂离子电池"]
        },
    ],
}

# Normalize and render

claim_tree = normalize_claim_tree(raw_tree)
markdown = render_claim_tree_markdown(claim_tree, pub=False)
print(markdown)

```

This produces legally formatted markdown output:

```text
1. 一种用于电动汽车的动力系统，包括电池组，以及控制单元。
2. 根据权利要求 1，其中所述电池组为锂离子电池。

```

To validate the tree against drafting rules before export, run the audit tool:

```bash
python skills/patent-application/tools/audit_claims.py --claim-tree claim_tree.json

# Output: "All claims pass audit" or a list of specific violations

```

## Summary

The patent-disclosure-skill implements a rigorous, code-enforced framework for patent claim drafting:

- **One claim per node**: Each JSON node represents exactly one claim via `normalize_claim_tree`
- **Hierarchical structure**: Independent claims are roots; dependent claims are children with `parent` references
- **Mandatory fields**: Every claim requires a `preamble` and `features` list
- **Legal formatting**: Dependent claims automatically receive "根据权利要求 X" prefixes
- **Schema consistency**: [`schema_vault.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/schema_vault.py) enforces uniform field names across all utilities
- **Deduplication**: `claim_deltas_from_tree` prevents duplicate claim numbers
- **Automated validation**: [`audit_claims.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/audit_claims.py) checks length, characters, and required elements
- **Multi-format export**: [`md_to_docx.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/md_to_docx.py) preserves formatting when converting to Word documents

## Frequently Asked Questions

### How does the claim tree structure work in patent-disclosure-skill?

The claim tree consists of a `roots` array containing claim numbers of independent claims and a `nodes` array containing claim objects. Each node includes a `claim` number, optional `parent` reference for dependents, a `preamble` string, and a `features` list. The `normalize_claim_tree` function in [`write_patent_obsidian_note.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/write_patent_obsidian_note.py) validates this structure before rendering.

### What validation does audit_claims.py perform?

The `audit_claims` function in [`skills/patent-application/tools/audit_claims.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-application/tools/audit_claims.py) validates that each claim contains both a preamble and features, checks for forbidden characters that could corrupt patent documents, verifies claim lengths are within acceptable bounds, and ensures no duplicate claim numbers exist in the tree.

### How does the system handle dependent claims differently from independent claims?

In the JSON structure, independent claims appear in the `roots` array and omit the `parent` field. Dependent claims include a `parent` field referencing their parent claim number. During rendering in `render_claim_tree_markdown`, dependent claims automatically receive the "根据权利要求 X" prefix, while independent claims stand alone. The `claim_tree_to_mermaid` function visualizes this relationship by placing dependent claims as child nodes in the diagram.

### Can I export the drafted claims to formats other than Markdown?

Yes. While the primary output is Markdown ([`draft.md`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/draft.md)), the [`skills/patent-disclosure/tools/md_to_docx.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/md_to_docx.py) utility converts the final markdown to Word document format. This conversion specifically preserves the one-claim-per-paragraph rule and maintains the hierarchical formatting established during the drafting phase, ensuring the Word document matches the validated markdown structure.