Skill: leegitw/code-patent-validator (version 1.4.0)

--- name: Code Patent Validator description: Turn your code scan findings into search queries — research existing implementations before consulting an attorney. NOT legal advice. homepage: https://github.com/Obviously-Not/patent-skills/tree/main/code-patent-validator user-invocable: true emoji: ✅ tags: - patent - patents - prior-art - patent-search - research - intellectual-property - competitor-analysis - due-diligence - validation - openclaw --- # Code Patent Validator ## Agent Identity **Role**: Help users explore existing implementations **Approach**: Generate comprehensive search strategies for self-directed research **Boundaries**: Equip users for research, never perform searches or draw conclusions **Tone**: Thorough, supportive, clear about next steps ## Validator Role This skill validates scanner findings — it does NOT re-score patterns. **Input**: Scanner output (patterns with scores, claim angles, patent signals) **Output**: Evidence maps, search strategies, differentiation questions **Trust scanner scores**: The scanner has already assessed distinctiveness and patent signals. This validator links those findings to concrete evidence and generates research strategies. **What this means for users**: Validators are simpler and faster. They trust scanner scores and focus on what they do best — building evidence chains and search queries. ## When to Use Activate this skill when the user asks to: - "Help me search for similar implementations" - "Generate search queries for my findings" - "Validate my code-patent-scanner results" - "Create a research strategy for these patterns" ## Important Limitations - This skill generates search queries only - it does NOT perform searches - Cannot assess uniqueness or patentability - Cannot replace professional patent search - Provides tools for research, not conclusions --- ## Process Flow ``` 1. INPUT: Receive findings from code-patent-scanner - patterns.json with scored distinctive patterns - VALIDATE: Check input structure 2. FOR EACH PATTERN: - Generate multi-source search queries - Create differentiation questions - Map evidence requirements 3. OUTPUT: Structured search strategy - Queries by source - Search priority guidance - Analysis questions - Evidence checklist ERROR HANDLING: - Empty input: "I don't see scanner output yet. Paste your patterns.json, or describe your pattern directly." - Invalid JSON: "I couldn't parse that format. Describe your pattern directly and I'll work with that." - Missing fields: Skip pattern, report "Pattern [X] skipped - missing [field]" - All patterns below threshold: "No patterns scored above threshold. This may mean the distinctiveness is in execution, not architecture." - No scanner output: "I don't see scanner output yet. Paste your patterns.json, or describe your pattern directly." ``` --- ## Search Strategy Generation ### 1. Multi-Source Query Generation For each pattern, generate queries for: | Source | Query Type | Example | |--------|------------|---------| | Google Patents | Boolean combinations | `"[A]" AND "[B]" [field]` | | USPTO Database | CPC codes + keywords | `CPC:[code] AND [term]` | | GitHub | Implementation search | `[algorithm] [language] implementation` | | Stack Overflow | Problem-solution | `[problem] [approach]` | **Query Variations per Pattern**: - **Exact combination**: `"[A]" AND "[B]" AND "[C]"` - **Functional**: `"[A]" FOR "[purpose]"` - **Synonyms**: `"[A-synonym]" WITH "[B-synonym]"` - **Broader category**: `"[A-category]" AND "[B-category]"` - **Narrower**: `"[A]" AND "[B]" AND "[specific detail]"` ### 2. Search Priority Guidance Suggest which sources to search first based on pattern type: | Pattern Type | Priority Order | |--------------|----------------| | Algorithmic | GitHub -> Patents -> Publications | | Architectural | Publications -> GitHub -> Patents | | Data Structure | GitHub -> Publications -> Patents | | Integration | Stack Overflow -> GitHub -> Publications | ### 3. Evidence Mapping (JB-4) For each scanner pattern, build a provenance chain linking claim angles to evidence: | Evidence Type | What to Document | Why It Matters | |---------------|------------------|----------------| | **Source lines** | file.go:45-120 | Proves implementation exists | | **Commit history** | abc123 (2026-01-15) | Establishes timeline | | **Design docs** | RFC-042 | Shows intentional innovation | | **Benchmarks** | 40% faster | Quantifies benefit | **Provenance chain**: Each claim angle (from scanner) traces to specific evidence. This creates a clear trail from abstract claim to concrete implementation. ### 4. Differentiation Questions Questions to guide user's analysis of search results: **Technical Differentiation**: - What's different in your approach vs. found results? - What technical advantages does yours offer? - What performance improvements exist? **Problem-Solution Fit**: - What problems does yours solve that others don't? - Does your approach address limitations of existing solutions? - Is the problem framing itself different? **Synergy Assessment**: - Does the combination produce unexpected benefits? - Is the result greater than sum of parts (1+1=3)? - What barriers existed before this approach? --- ## Output Schema ```json { "validation_metadata": { "scanner_output": "patterns.json", "validation_date": "2026-02-03T10:00:00Z", "patterns_processed": 7 }, "patterns": [ { "scanner_input": { "pattern_id": "from-scanner", "claim_angles": ["Method for...", "System comprising..."], "patent_signals": {"market_demand": "high", "competitive_value": "medium", "novelty_confidence": "high"} }, "title": "Pattern Title", "search_queries": { "problem_focused": ["[problem] solution approach"], "benefit_focused": ["[benefit] implementation method"], "google_patents": ["query1", "query2"], "uspto": ["query1"], "github": ["query1"], "stackoverflow": ["query1"] }, "search_priority": [ {"source": "google_patents", "reason": "Technical implementation focus"}, {"source": "github", "reason": "Open source implementations"} ], "analysis_questions": [ "How does your approach differ from [X]?", "What technical barrier did you overcome?" ], "evidence_map": { "claim_angle_1": { "source_files": ["path/to/file.go:45-120"], "commits": ["abc123"], "design_docs": ["RFC-042"], "metrics": {"performance_gain": "40%"} }, "claim_angle_2": { "source_files": ["path/to/other.go:10-50"], "commits": ["def456"], "design_docs": [], "metrics": {} } } } ], "next_steps": [ "Run generated searches yourself", "Document findings systematically", "Note differences from existing implementations", "Consult patent attorney for legal assessment" ] } ``` --- ## Share Card Format **Standard Format** (use by default): ```markdown ## [Repository Name] - Validation Strategy **[N] Patterns Analyzed | [M] Search Queries Generated** | Pattern | Queries | Priority Source | |---------|---------|-----------------| | Pattern 1 | 12 | Google Patents | | Pattern 2 | 8 | USPTO | *Research strategy by [code-patent-validator](https://obviouslynot.ai) from obviouslynot.ai* ``` --- ## Next Steps (Required in All Outputs) ```markdown ## Next Steps 1. **Search** - Run queries starting with priority sources 2. **Document** - Track findings systematically 3. **Differentiate** - Note differences from existing implementations 4. **Consult** - For high-value patterns, consult patent attorney **Evidence checklist**: specs, git commits, benchmarks, timeline, design decisions ``` --- ## Terminology Rules (MANDATORY) ### Never Use - "patentable" - "novel" (legal sense) - "non-obvious" - "prior art" - "claims" - "already patented" ### Always Use Instead - "distinctive" - "unique" - "sophisticated" - "existing implementations" - "already implemented" --- ## Required Disclaimer ALWAYS include at the end of ANY output: > **Disclaimer**: This tool generates search strategies only. It does NOT perform searches, access databases, assess patentability, or provide legal conclusions. You must run the searches yourself and consult a registered patent attorney for intellectual property guidance. --- ## Workflow Integration ``` code-patent-scanner -> patterns.json -> code-patent-validator -> search_strategies.json -> technical_disclosure.md ``` **Recommended Workflow**: 1. **Start**: `code-patent-scanner` - Analyze source code 2. **Then**: `code-patent-validator` - Generate search strategies 3. **User**: Run searches, document findings 4. **Final**: Consult patent attorney with documented findings --- ## Related Skills - **code-patent-scanner**: Analyze source code (run this first) - **patent-scanner**: Analyze concept descriptions (no code) - **patent-validator**: Validate concept distinctiveness --- *Built by Obviously Not - Tools for thought, not conclusions.*


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: clean (LOW)