Code Patent Validator

Turn your code scan findings into search queries — research existing implementations before consulting an attorney. NOT legal advice.

Security Scan

The skill is internally consistent with its stated purpose: it is an instruction-only validator that generates search queries and research strategies from scanner output and requests no credentials, binaries, or installs.

Purpose & Capability

The name/description (generate search queries / research strategies for scanner findings) matches the SKILL.md. It asks for scanner output (patterns.json) and outlines generating queries for patents, GitHub, Stack Overflow, etc. No unrelated credentials, binaries, or installs are requested.

Instruction Scope

The SKILL.md repeatedly emphasizes it will only generate search strategies and not perform searches. It also describes mapping evidence types (source lines, commits, design docs). That is coherent if the user supplies the scanner output with those references; however, the skill assumes the user will provide the underlying evidence rather than the agent autonomously fetching repositories or external resources. This is a design assumption to be aware of.

Install Mechanism

No install spec and no code files — instruction-only. Nothing is written to disk or downloaded as part of the skill installation.

Credentials

The skill requests no environment variables, secrets, or config paths. The metadata and instructions do not require credentials for external services; that matches the stated behavior (generate queries only).

Persistence & Privilege

always is false and there are no claims of modifying other skills or system config. The skill does not request permanent presence or elevated privileges.

Assessment

This skill appears coherent and low-risk from an installation/permission standpoint because it only generates search queries and asks users to supply scanner output. Before using it: (1) Remember it is NOT legal advice — consult a patent attorney for legal conclusions. (2) Be careful about the scanner input you paste: do not paste proprietary source code, secret keys, or private identifiers into the agent if you plan to run generated searches on public services, as that could leak sensitive data. (3) The skill says it will not perform searches, but verify how your agent runs skills and whether it will autonomously contact external search engines — if you want to prevent automatic searches, keep the skill user-invoked and avoid giving the agent external-network access for these queries. (4) If you expect the validator to include commit history or design docs, ensure you provide those references explicitly; the skill does not instruct the agent to fetch repositories on its own. If you want stronger assurance, inspect how your agent logs or stores inputs/outputs so sensitive scanner output is not retained or transmitted.

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

{
  "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):

## [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)

## 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.