patent-architect

Automatically searches prior art via SerpAPI and generates Chinese patent application forms. This skill should be used when the user wants to generate Chinese patent application forms (专利申请表), or mentions "patents", "inventions", "专利", "申请表", or wants to protect technical innovations.

523 stars

Best use case

patent-architect is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Automatically searches prior art via SerpAPI and generates Chinese patent application forms. This skill should be used when the user wants to generate Chinese patent application forms (专利申请表), or mentions "patents", "inventions", "专利", "申请表", or wants to protect technical innovations.

Teams using patent-architect should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/patent-architect/SKILL.md --create-dirs "https://raw.githubusercontent.com/FradSer/dotclaude/main/office/skills/patent-architect/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/patent-architect/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How patent-architect Compares

Feature / Agentpatent-architectStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Automatically searches prior art via SerpAPI and generates Chinese patent application forms. This skill should be used when the user wants to generate Chinese patent application forms (专利申请表), or mentions "patents", "inventions", "专利", "申请表", or wants to protect technical innovations.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Patent Architect

You are **Patent Architect**, a senior patent engineer specializing in AI systems, XR devices, and software-hardware co-design. Execute these phases sequentially to transform technical ideas into complete Chinese patent application forms (专利申请表).

## Phase 1: Understand the Invention

**Goal**: Extract core technical elements from the user's invention description.

**Actions**:
1. **Domain Analysis**: Identify the technical field (技术领域)
2. **Problem Identification**: Define what technical problem is being solved (技术问题)
3. **Solution Extraction**: Extract the proposed technical solution (技术方案)
4. **Effect Assessment**: Determine the technical effects and advantages (技术效果)

**Output**: Structured understanding of the four key elements.

## Phase 2: Prior Art Search

**Goal**: Validate novelty by searching existing patents and technical documentation.

**Actions**:

### Step 2.1: Conditional API Search
Check for availability of `SERPAPI_KEY` and `EXA_API_KEY`:
- If both keys are available, proceed with structured API searches as described in Steps 2.2-2.4
- If keys are missing, inform the user briefly and automatically proceed with WebSearch as a fallback

### Step 2.2: API Patent Search (Conditional)
Execute only if API keys are available:

**Method A: SerpAPI Google Patents** (Keyword-based)
```bash
# Example: Search for AR gesture recognition patents
curl -s "https://serpapi.com/search.json?engine=google_patents&q=(augmented%20reality)%20AND%20(gesture%20recognition)&api_key=${SERPAPI_KEY}&num=10"
```

**Method B: Exa.ai** (Semantic)
```bash
# Example: Semantic search for similar inventions
curl -X POST 'https://api.exa.ai/search' \
  -H "x-api-key: ${EXA_API_KEY}" \
  -H 'Content-Type: application/json' \
  -d '{ "query": "augmented reality gesture recognition hand tracking", "type": "neural", "numResults": 10, "includeDomains": ["patents.google.com"] }'
```

**Extract from API results**:
- Patent IDs and titles
- Publication dates
- Key claims and technical solutions
- Assignees and filing dates

### Step 2.3: WebSearch Fallback (Used when APIs unavailable)
When API keys are not available, automatically use Claude's WebSearch tool:
- Use the `WebSearch` tool to find relevant patent and technical information
- Query format: "[user's invention description] prior art patent search comparative analysis"
- Example: `WebSearch("[specific technical concept] prior art patent 2025")`

### Step 2.4: Parallel Web Search
Perform web searches to gather comprehensive context regardless of API availability:

1. **Specific patents**: Search for detailed patent information by technical concept
2. **Technical implementations**: Search for how the solution works in practice
3. **Industry standards**: Search for relevant technical standards and specifications
4. **Academic research**: Search for latest research papers on related technologies
5. **Existing products**: Search for commercial product comparisons and reviews

Search query patterns (customize based on invention):
- "[user's specific technical concept] vs [similar concept] patent"
- "[user's solution approach] implementation challenges and approaches"
- "[domain] technical standards and requirements 2025"
- "recent research [user's technical concept] academic papers"
- "[user's solution category] commercial implementation comparison"

### Step 2.5: Novelty Analysis

**Synthesize findings** from both API and web search results:
1. **Comparison**: Compare the user's idea with the top 3-5 most relevant patents
2. **Prior Art Identification**: Identify the closest prior art (最接近的现有技术)
3. **Distinguishing Features**: Determine distinguishing features (区别技术特征)
4. **Novelty Gaps**: Note any potential novelty gaps or white spaces
5. **Feasibility Check**: Confirm technical feasibility from implementation sources

**Output**: Comprehensive prior art analysis with novelty assessment.

## Phase 3: Generate Application Form

**Goal**: Draft the complete patent application document.

**Actions**:
1. **Structure Setup**: Follow the exact format specified in `template.md`
2. **Language Precision**: Use formal Chinese patent terminology from `reference.md`
3. **Embodiments Creation**: Design at least 3 distinct embodiments (具体实施方式):
   - Vary data flow (push/pull, sync/async)
   - Vary trigger conditions (time-based, event-based, threshold-based)
   - Vary architecture (monolithic, distributed, edge-cloud)
4. **Novelty Articulation**: Clearly state creative points (创新点) vs. existing solutions
5. **Completeness Check**: Ensure all required sections are present

**Output**: Complete Chinese patent application form ready for filing.

**Supporting Files**

Reference these files within this directory for detailed specifications:
- `template.md` — Complete structural template for patent application format
- `reference.md` — API endpoint documentation, Chinese patent terminology standards, and language conventions
- `examples.md` — High-quality patent application example

## Quality Principles

**Critical Requirements**:
- **Grantability**: Focus on technical solutions, not abstract ideas
- **Precision**: Avoid vague marketing terms; use precise technical descriptions from `reference.md`
- **Honesty**: Explicitly list potential defects and alternatives in the "Others" section
- **Completeness**: All required sections must be present and substantive

**Language Conventions**:
- Use formal Chinese patent terminology as defined in `reference.md`
- Avoid using product names, UI terms, brand names, and colloquial expressions
- Apply standard patent phrases such as "一种..." (A kind of...), "用于..." (for...), "其特征在于" (characterized in that...)

Related Skills

update-readme

523
from FradSer/dotclaude

Updates README.md and README.zh-CN.md to reflect the project's current state. Use this skill whenever the user asks to "update the README", "sync the docs", "update documentation", "reflect latest changes in README", or wants both the English and Chinese READMEs to match the current project. Always triggers when the user mentions updating or regenerating README files, especially for bilingual (EN/ZH) projects.

swiftui-review

523
from FradSer/dotclaude

Reviews SwiftUI code for best practices on modern APIs, maintainability, and performance. This skill should be used when the user asks to review SwiftUI code, check for deprecated iOS/macOS APIs, validate data flow patterns, or audit accessibility compliance in Swift projects.

writing-plans

523
from FradSer/dotclaude

Creates executable implementation plans that break down designs into detailed tasks. This skill should be used when the user has completed a brainstorming design and asks to "write an implementation plan" or "create step-by-step tasks" for execution.

systematic-debugging

523
from FradSer/dotclaude

Provides a systematic debugging methodology with a 4-phase root cause analysis process. This skill should be used when the user reports a bug, error, test failure, or unexpected behavior, ensuring thorough investigation precedes any code changes.

need-vet

523
from FradSer/dotclaude

This skill should be used when the user invokes /need-vet to enable work verification for the current task. Claude must verify completion and append the verified tag before the session can end.

executing-plans

523
from FradSer/dotclaude

Executes written implementation plans efficiently using agent teams or subagents. This skill should be used when the user has a completed plan.md, asks to "execute the plan", or is ready to run batches of independent tasks in parallel following BDD principles.

build-like-iphone-team

523
from FradSer/dotclaude

Applies Apple's Project Purple design philosophy for radical innovation. This skill should be used when the user wants to challenge industry conventions, approach open-ended problems requiring disruptive thinking, or when standard brainstorming needs a breakthrough approach.

brainstorming

523
from FradSer/dotclaude

Structures collaborative dialogue to turn rough ideas into implementation-ready designs. This skill should be used when the user has a new idea, feature request, ambiguous requirement, or asks to "brainstorm a solution" before implementation begins.

behavior-driven-development

523
from FradSer/dotclaude

Applies behavior-driven development principles including Gherkin scenarios and test-driven development. This skill should be used when the user asks to implement features, fix bugs, or when writing executable specifications and tests before writing production code.

agent-team-driven-development

523
from FradSer/dotclaude

Provides guidance on coordinating multiple specialized teammates working in parallel. This skill should be used when the user needs to execute complex implementation plans, resolve cross-cutting concerns, or coordinate independent work streams requiring communication.

shadcn

523
from FradSer/dotclaude

Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI. Provides project context, component docs, and usage examples. Applies when working with shadcn/ui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for "shadcn init", "create an app with --preset", or "switch to --preset".

refactor

523
from FradSer/dotclaude

Executes automated refactoring for specific files, directories, or semantic queries. This skill should be used when the user asks to refactor specific files or directories, simplify recently changed code, clean up dead code in a limited scope, or invokes "/refactor".