Requirements for Utility Model and Design Patent Applications: A Technical Guide

Utility model patents require a single technical claim with at least one drawing and lower inventiveness thresholds, while design patents demand purely ornamental visual claims with complete multi-view drawings, as enforced by the patent-disclosure-skill framework.

The handsomestWei/patent-disclosure-skill repository automates Chinese patent search and disclosure generation for utility model and design patent applications. Understanding the specific requirements for these two patent families is critical for developers building automated filing tools or researchers navigating CNIPA (China National Intellectual Property Administration) procedures. This guide breaks down the technical constraints encoded in the repository's validation logic.

Utility Model Patent Application Requirements

Utility model patents (实用新型) protect technical solutions with a reduced inventive step requirement compared to invention patents. The repository enforces strict structural constraints through the TYPE_UTILITY_MODEL constant defined in skills/patent-search/tools/patent_type.py.

Subject Matter and Inventiveness Threshold

A utility model must present a new technical solution that solves a technical problem without involving an inventive step—meaning the innovation need not reach the non-obviousness standard required for invention patents. The repository maps this type to the CNIPA query string "实用新型" when the --type utility_model flag is invoked.

Single Claim Constraint

Unlike invention patents, utility models are limited to exactly one claim describing the technical solution. The validation logic in skills/patent-disclosure/tools/structure_lineart_gate.py explicitly checks this constraint:

def validate_utility_model(patent_dict):
    errors = []
    if (patent_dict.get("patent_type") or "") != "utility_model":
        errors.append("patent_type must be utility_model")
    # Ensure exactly one claim

    if len(patent_dict.get("claims", [])) != 1:
        errors.append("Utility model must contain exactly one claim")
    return errors

Multiple dependent claims are prohibited, and the repository's prompt template at skills/patent-disclosure/prompts/utility_model/disclosure_builder.md forces users to consolidate their technical solution into a single independent claim.

Mandatory Drawings Requirement

Utility model applications require at least one drawing that fully discloses the technical solution. The structure_lineart_gate.py module validates that submitted drawings match the "utility_model" type flag, ensuring structural diagrams are provided rather than ornamental renderings.

Prior Art Search Implementation

The skill performs automated novelty checks using skills/patent-search/tools/cnipa_search.py, which appends a specific query filter for utility models:

$ python skills/patent-search/tools/cnipa_search.py --type utility_model "卡扣"

This executes with query_extra: 'country:CN (实用新型 OR "utility model")', limiting results to existing utility model registrations to satisfy legal novelty requirements before filing.

Design Patent Application Requirements

Design patents (外观专利) protect the ornamental appearance of products without covering technical features or functional improvements. The repository handles these through the TYPE_DESIGN constant, mapped to CNIPA's "design" classification.

Ornamental Subject Matter Exclusion

Design patents must represent a new ornamental design for a product containing no technical features. The design_lineart_gate.py module enforces this by checking that the patent_type field equals "design" before accepting any figure data, preventing contamination with structural technical disclosures.

Visual Claim Structure

A design patent application contains a single design claim defining the product's visual appearance. Unlike utility models, this claim describes aesthetic elements—shapes, patterns, and color combinations—rather than functional mechanisms.

Drawing View Requirements

Design patents demand full, clear line drawings from all relevant perspectives (front, rear, top, bottom, left side, right side). The image_gen.py utilities reject submissions missing required views when the --type design flag is active. The CLI pipeline validates completeness through:

$ python skills/patent-disclosure/tools/run_step_to_views.py --type design \
    --case-dir my_case --figures fig1.png fig2.png

Concise Description Limits

The description must remain brief (≤ 500 words), merely explaining the design's visual features. The prompt template at skills/patent-disclosure/prompts/design/patent_points.md requires users to submit a structured "design point" table rather than extensive technical exposition.

Design-Specific Prior Art Search

When --type design is specified, cnipa_search.py constrains queries to aesthetic prior art:

query_extra: 'country:CN (外观专利 OR "design patent")'

This ensures the novelty search examines only existing design registrations, not technical utility models or invention patents.

Shared Validation Logic

Both patent types enforce common procedural safeguards through the repository's core architecture:

• Strict Type Flagging: The CLI requires explicit --type utility_model or --type design arguments, preventing ambiguity
• Type Isolation: The skill explicitly blocks --type all when processing utility model or design applications, preventing requirement-set mixing
• Publication Code Translation: The infer_patent_type_from_pub() function in patent_type.py automatically maps CNIPA publication suffixes (U for utility model, D for design) to internal constants, ensuring correct rule application:

def infer_patent_type_from_pub(pub_code: str) -> str:
    """
    Map CNIPA publication code suffix to internal patent type.
    - Ends with 'U' → utility_model
    - Ends with 'D' → design
    - Otherwise → invention
    """
    if search(r"U$", pub_code, re.I):
        return "utility_model"
    if search(r"D$", pub_code, re.I):
        return "design"
    return "invention"

Summary

• Utility models require single claims, technical drawings, lower inventiveness thresholds, and map to CNIPA type "实用新型" (TYPE_UTILITY_MODEL)
• Design patents require visual claims, multi-view ornamental drawings, no technical features, and map to CNIPA type "design" (TYPE_DESIGN)
• Both types enforce strict type validation through structure_lineart_gate.py and design_lineart_gate.py
• The repository automates prior art filtering via cnipa_search.py using type-specific query extras
• Publication code suffixes (U and D) automatically trigger the appropriate requirement sets through infer_patent_type_from_pub()

Frequently Asked Questions

What is the maximum number of claims allowed in a Chinese utility model application?

Chinese utility model applications permit only one claim according to the validation logic in structure_lineart_gate.py. The repository explicitly checks len(patent_dict.get("claims", [])) != 1 and rejects submissions containing multiple claims or dependent claims. This differs from invention patents, which allow complex claim hierarchies.

Can a design patent application include technical functional descriptions?

No. Design patents must exclude technical features entirely. The design_lineart_gate.py module validates that submissions contain purely ornamental visual claims, and the prompt template at design/patent_points.md restricts descriptions to visual characteristics (shape, pattern, color) with a 500-word maximum. Including functional technical explanations will trigger validation errors.

How does the repository determine whether a patent is a utility model or design?

The system uses CNIPA publication code suffixes parsed by infer_patent_type_from_pub() in patent_type.py. Codes ending with U indicate utility models, while codes ending with D indicate design patents. For manual filings, the --type CLI flag explicitly sets the validation path, triggering either the single-claim checks for utility models or the multi-view drawing requirements for designs.

What drawing formats are required for design patent submissions?

Design patents require complete multi-view line drawings showing all exterior surfaces—typically front, rear, top, bottom, left, and right perspectives. The run_step_to_views.py pipeline validates that figure sets include all mandatory views before generating disclosure documents. Missing views result in pipeline termination with validation errors logged by design_lineart_gate.py.

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