# Development Assistant

> Guides through adding new features, MCP tools, analyzers, and extending the patent creator system.

- **Type:** Skill
- **Install:** `agentstack add skill-robthepcguy-claude-patent-creator-development-assistant`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [RobThePCGuy](https://agentstack.voostack.com/s/robthepcguy)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [RobThePCGuy](https://github.com/RobThePCGuy)
- **Source:** https://github.com/RobThePCGuy/Claude-Patent-Creator/tree/main/skills/development-assistant
- **Website:** https://github.com/RobThePCGuy/Claude-Patent-Creator

## Install

```sh
agentstack add skill-robthepcguy-claude-patent-creator-development-assistant
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Development Assistant Skill

Expert system for developing and extending the Claude Patent Creator. Guides through adding new MCP tools, analyzers, configuration options, and features while following best practices and existing patterns.

## When to Use This Skill

Activate when adding MCP tools, analyzers, configuration options, BigQuery queries, slash commands, or implementing performance optimizations.

## Development Workflow

```
Feature Request -> Planning -> Implementation (Code + Validation + Monitoring + Tests) -> Testing -> Documentation -> Integration
```

## Adding New MCP Tools

**Quick Start:**
1. Define inputs, outputs, dependencies
2. Create Pydantic model in `mcp_server/validation.py`
3. Add tool function in `mcp_server/server.py` with decorators
4. Create test script in `scripts/`
5. Update CLAUDE.md

**Key Decorators:**
```python
@mcp.tool()                    # Register as MCP tool
@validate_input(YourInput)     # Pydantic validation
@track_performance             # Performance monitoring
```

**Template:**
```python
def your_tool(param: str, optional: int = 10) -> dict:
    """Comprehensive docstring (Claude sees this).

    Args:
        param: Description
        optional: Description with default

    Returns:
        Dictionary containing: key1, key2, key3
    """
    # Implementation
    return {"result": "data"}
```

## Adding New Analyzers

**Overview:** Analyzers inherit from `BaseAnalyzer` and check USPTO compliance.

**Minimal Example:**
```python
from mcp_server.analyzer_base import BaseAnalyzer

class YourAnalyzer(BaseAnalyzer):
    def __init__(self):
        super().__init__()
        self.mpep_sections = ["608", "2173"]

    def analyze(self, content: str) -> dict:
        issues = []
        if violation:
            issues.append({
                "type": "violation_name",
                "severity": "critical",
                "mpep_citation": "MPEP 608",
                "recommendation": "Fix description"
            })
        return {"compliant": len(issues) == 0, "issues": issues}
```

## Adding Configuration Options

Use Pydantic settings in `mcp_server/config.py`:

```python
# In config.py
class AppSettings(BaseSettings):
    enable_feature_x: bool = Field(default=False, description="Enable X")

# In your code
from mcp_server.config import get_settings
if get_settings().enable_feature_x:
    # Feature enabled
```

## Adding Performance Monitoring

```python
@track_performance
def your_function(data):
    with OperationTimer("step1"):
        result1 = step1(data)
    with OperationTimer("step2"):
        result2 = step2(result1)
    return result2
```

## Modifying RAG Search Pipeline

Pipeline: `Query -> HyDE -> Vector+BM25 -> RRF -> Reranking -> Results`

**Customization Points:** Query expansion, custom scoring, filtering, reranking strategies

## Adding New Slash Commands

1. Create `.claude/commands/your-command.md`
2. Add frontmatter: `description`, `model`
3. Write workflow instructions
4. Restart Claude Code

**Template:**
```markdown
---
description: Brief command description
model: claude-sonnet-4-5-20250929
---

# Command Name

## When to Use
- Use case 1

## How It Works
Step 1: ...
```

## Development Best Practices

1. Follow existing patterns
2. Use type hints
3. Write docstrings (Google style)
4. Handle errors gracefully
5. Validate inputs (Pydantic)
6. Log operations
7. Monitor performance

## Common Development Tasks

**Add BigQuery Query:** Add method in `mcp_server/bigquery_search.py`

**Add Validation Rule:**
```python
class YourInput(BaseModel):
    field: str

    @field_validator("field")
    @classmethod
    def validate_field(cls, v):
        if not meets_requirement(v):
            raise ValueError("Error message")
        return v
```

**Add Logging:**
```python
from mcp_server.logging_config import get_logger
logger = get_logger()
logger.info("event_name", extra={"context": "data"})
```

## Quick Reference: File Locations

| Task | Primary File | Related Files |
|------|-------------|---------------|
| Add MCP tool | `mcp_server/server.py` | `mcp_server/validation.py` |
| Add analyzer | `mcp_server/your_analyzer.py` | `mcp_server/analyzer_base.py` |
| Add config | `mcp_server/config.py` | `.env`, `CLAUDE.md` |
| Add BigQuery query | `mcp_server/bigquery_search.py` | - |
| Add test | `scripts/test_your_feature.py` | - |

## Key Patterns

**MCP Tool Pattern:**
```python
@mcp.tool()
@validate_input(InputModel)
@track_performance
def tool_name(param: type) -> dict:
    """Docstring visible to Claude."""
    from module import Component
    if invalid:
        return {"error": "message"}
    result = process(param)
    return {"key": "value"}
```

**Analyzer Pattern:**
```python
class YourAnalyzer(BaseAnalyzer):
    def analyze(self, content: str) -> dict:
        issues = []
        issues.extend(self._check_x(content))
        return {
            "compliant": len(issues) == 0,
            "issues": issues,
            "recommendations": self._generate_recommendations(issues)
        }
```

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [RobThePCGuy](https://github.com/RobThePCGuy)
- **Source:** [RobThePCGuy/Claude-Patent-Creator](https://github.com/RobThePCGuy/Claude-Patent-Creator)
- **License:** MIT
- **Homepage:** https://github.com/RobThePCGuy/Claude-Patent-Creator

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-robthepcguy-claude-patent-creator-development-assistant
- Seller: https://agentstack.voostack.com/s/robthepcguy
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.