# Code Patent Validator

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

- Skill: `obviously-not/code-patent-validator` (Agent Skill)
- Install (CLI): `npx skillmds@latest add obviously-not/code-patent-validator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/obviously-not/code-patent-validator/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Research & Search
- Author: Obviously-Not (https://skillmd.com/u/obviously-not)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/obviously-not/code-patent-validator

---


# 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", "distinctiveness_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.*