Codexer

---
name: codexer
version: "2.0"
last_updated: 2026-08-24
tags: [codexer, agents, delegation, workflow, automation]
description: "Python research assistant with Context7 MCP. Use for Python library research, evaluating packages, enforcing strict Python coding standards, or fetching up-to-date library docs via Context7."
---
# 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.

- Leverage native parallel subagent dispatch and 200k+ context windows where available.



## Activation Conditions

Use symptom -> action triggers: when one matches, apply this skill and verify with the protocol below.

- 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

---

## Anti-Patterns

- Delegating or evaluating without a scoped success condition: The output becomes hard to review and easy to overbuild.
- Skipping the evidence step: A workflow that cannot be re-checked quickly is not ready for handoff.
- Bundling unrelated subtasks together: It creates noisy prompts, weaker ownership, and avoidable integration risk.

## Verification Protocol

Before claiming "skill applied successfully":

1. Pass/fail: The Codexer workflow names the agent boundary, delegated scope, and expected return artifact.
2. Pass/fail: Context passed to helpers is minimal, task-local, and free of hidden expected answers.
3. Pass/fail: Results are integrated only after evidence, diffs, or citations are checked by the controller.
4. Pressure-test scenario: Run the workflow on two similar tasks that must not share assumptions or leaked context.
5. Success metric: Zero context leakage; every delegated output is independently reviewable.

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


---

<!-- MCP:START -->

<!-- PORTABILITY:START -->
## Cross-Client Portability

This skill is written to stay usable across GitHub Copilot, Claude Code, and Codex.

- GitHub Copilot: keep the folder in a Copilot-visible skill path or wrap the
  workflow in project instructions when folder discovery is unavailable.
- Claude Code: keep the folder in a local skills directory or a compatible plugin source.
- Codex: install or sync the folder into
  `$CODEX_HOME/skills/codexer` and restart Codex after major changes.

<!-- PORTABILITY:END -->

## MCP Availability And Fallback

Preferred MCP Server: Context7 MCP

- Fallback prompt: "Use the Codexer - Python Research Assistant skill without MCP. Rely on the local `SKILL.md`, bundled references or scripts, and manual verification. Show the exact commands, evidence, and final checks you used before concluding."
- Use the official package documentation, changelogs, and release notes directly when Context7 is unavailable.
- Confirm installed package behavior locally with the language toolchain, `--help`, or small reproducible examples.

<!-- MCP:END -->

## Related Skills

- [agent-task-mapping](../agent-task-mapping/SKILL.md): Use it when the workflow also needs task-to-agent routing decisions.
- [custom-agent-usage](../custom-agent-usage/SKILL.md): Use it when the workflow also needs loading and invoking custom agent definitions safely.
- [subagent-delegation](../subagent-delegation/SKILL.md): Use it when the workflow also needs safe, scoped delegation to helper agents.
- [subagent-driven-development](../subagent-driven-development/SKILL.md): Use it when the workflow also needs plan-driven implementation with reviewer loops.