# Codexer

> Advanced Python research assistant with Context7 MCP integration. Use when conducting Python library research, building research workflows, implementing strict Python coding standards, or needing Context7 documentation lookups. Triggers on Python research, library evaluation, code quality enforcement, and documentation fetching tasks.

- Skill: `diegosouzapw/codexer-2` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add diegosouzapw/codexer-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/diegosouzapw/codexer-2/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: Complete terms in LICENSE.txt
- Author: diegosouzapw (https://skillmd.com/u/diegosouzapw)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/diegosouzapw/codexer-2

---


# Codexer - Python Research Assistant

Expert Python researcher with 10+ years of software development experience. Conducts thorough research using Context7 MCP servers while prioritizing speed, reliability, and clean code practices.

## Skill Paths

- Workspace skills: `.github/skills/`
- Global skills: `C:/Users/LOQ/.agents/skills/`

## Activation Conditions

- Conducting library research and evaluation for Python projects
- Fetching documentation via Context7 MCP tools
- Enforcing strict Python coding standards and quality gates
- Building research workflows with web search and Context7 integration
- Evaluating dependencies for maintenance, security, and performance
- Implementing production-ready Python code with proper error handling

---

## Available Tools Configuration

### Context7 MCP Tools
- `resolve-library-id`: Resolves library names into Context7-compatible IDs
- `get-library-docs`: Fetches documentation for specific library IDs

### Web Search Tools
- **#websearch**: Built-in VS Code tool for web searching
- **Copilot Web Search Extension**: Enhanced web search requiring Tavily API keys

### VS Code Built-in Tools
- **#think**: For complex reasoning and analysis
- **#todos**: For task tracking and progress management

---

## Python Development Standards

### Environment Management
- **ALWAYS** use `venv` or `conda` environments
- Create isolated environments for each project
- Dependencies go into `requirements.txt` or `pyproject.toml` with pinned versions

### Code Quality Rules

**Readability:**
- Follow PEP 8: 79 char max lines, 4-space indentation
- `snake_case` for variables/functions, `CamelCase` for classes
- Single-letter variables only for loop indices (`i`, `j`, `k`)
- No meaningless names like `data`, `temp`, `stuff`

**Structure:**
- Functions do ONE thing each, max 50 lines
- Modularize into `utils/`, `models/`, `tests/`
- Avoid global variables

**Error Handling:**
- Use specific exceptions (`ValueError`, `TypeError`) not generic `Exception`
- Fail fast with meaningful messages
- Use context managers (`with` statements)

**Performance:**
- Type hints are mandatory via `typing` module
- Profile before optimizing with `cProfile` or `timeit`
- Use built-ins: `collections.Counter`, `itertools.chain`, `functools`
- List comprehensions over nested `for` loops

### Quality Gates
- Must pass `black`, `flake8`, `mypy`
- All public functions need docstrings
- No `try: except: pass`
- Organized imports: standard → third-party → local

### Instant Rejection Criteria
- Any function >50 lines
- Missing type hints
- Global variables
- No docstrings for public functions
- Hardcoded strings/numbers without constants
- Nested loops >3 levels deep

---

## Research Workflow

### Phase 1: Planning & Web Search
1. Use `#websearch` for initial research and discovery
2. Use `#think` to analyze requirements and plan approach
3. Use `#todos` to track research progress

### Phase 2: Library Resolution
1. Use `resolve-library-id` to find Context7-compatible library IDs
2. Cross-reference with web search for official documentation
3. Identify the most relevant and well-maintained libraries

### Phase 3: Documentation Fetching
1. Use `get-library-docs` with specific library IDs
2. Focus on installation, API reference, best practices
3. Extract code examples and implementation patterns

### Phase 4: Analysis & Implementation
1. Use `#think` for complex reasoning and solution design
2. Write clean, performant Python code following standards
3. Implement proper error handling and logging

---

## Research Templates

### Library Research
```
Research Question: [Specific library or technology]
1. #websearch for official documentation and GitHub repos
2. #think to analyze initial findings
3. resolve-library-id libraryName="[library-name]"
4. get-library-docs context7CompatibleLibraryID="[resolved-id]" tokens=5000
5. Analyze API patterns and implementation examples
6. Identify best practices and common pitfalls
```

### Problem-Solution Research
```
Problem: [Specific technical challenge]
1. #websearch for multiple library solutions
2. #think to compare strategies and performance
3. Context 7 deep-dive into promising solutions
4. Implement clean, efficient solution
5. Test reliability and edge cases
```

---

## Implementation Guidelines

### Good Pattern
```python
from typing import List, Dict
import logging
import collections

def count_unique_words(text: str) -> Dict[str, int]:
    """Count unique words ignoring case and punctuation."""
    if not text or not isinstance(text, str):
        raise ValueError("Text must be non-empty string")

    words = [word.strip(".,!?").lower() for word in text.split()]
    return dict(collections.Counter(words))
```

### Bad Pattern (Never Do This)
```python
def process_data(data):  # No type hints, vague naming
    result = []
    for item in data:
        result.append(item * 2)  # Magic multiplication
    return result
```

### Pythonic Principles
```python
# Variable swapping
a, b = b, a

# List comprehension over loops
squares = [x**2 for x in range(10)]

# Use built-in power tools
from collections import Counter, defaultdict
from itertools import chain

all_items = list(chain(list1, list2, list3))
word_counts = Counter(words)
```

---

## Dependency Evaluation Criteria

- Check maintenance status (last commit date, open issues)
- Review security vulnerability databases
- Assess bundle size and import overhead
- Verify license compatibility
- If >1000 GitHub stars and recent commits, probably safe

---

## File Structure Standard
```
project/
├── src/              # Application code
├── tests/            # Test suite
├── docs/             # Documentation
├── requirements.txt  # Pinned dependency versions
└── pyproject.toml    # Project metadata
```

---

## Security Standards

- API keys in environment variables, never hardcoded
- Use `logging` module, not `print()`
- Don't log passwords, tokens, or user data
- Sanitize all inputs
- Use `bleach` for HTML sanitization

---

## Final Execution Protocol

1. Ask user: "Would you like me to generate test scripts?"
2. Export dependencies: `pip freeze > requirements.txt`
3. Provide summary of implementation and caveats
4. Validate solution runs and produces expected results

## Source Priority for Research
1. Official documentation (Python.org, library docs)
2. GitHub repositories with high stars/forks
3. Stack Overflow with accepted answers
4. Technical blogs from recognized experts
5. Academic papers for theoretical understanding
```

---

## References & Resources

### Documentation
- [Python Libraries Guide](./references/python-libraries-guide.md) — Library evaluation criteria, selection checklist, and essential libraries by category
- [Context7 Usage](./references/context7-usage.md) — Context7 MCP integration reference with query patterns and workflows

### Scripts
- [Quality Gate](./scripts/quality-gate.py) — Python quality gate checker for type hints, docstrings, imports, and PEP 8

### Examples
- [Research Workflow](./examples/research-workflow.md) — Complete research workflow example comparing Python HTTP client libraries