Skip to content

bg-szy/TOP-SKILLS / skills/agent-skills/codexer

codexer

Verified

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.

FileKindSize
CHANGELOG.mdmarkdown6.3 KB
LICENSE.txtmarkdown1.1 KB
SKILL.mdskill md10.1 KB
---
name: codexer
version: "2.0"
last_updated: 2026-09-08
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

---

<!-- 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. Follow the documented local or manual fallback, show the selected tool surface, and report the verification evidence."
- 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.
- Do not claim an MCP operation was used when the active host does not expose it.

<!-- MCP:END -->

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


---

## 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.
rea-changelog-updatemorluto/reaPrepare or rewrite REA release changelogs and GitHub release notes from pinned Git history, with verified contributor thanks and Release Please synchronization.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
academy-guideanthropics/skillsStop and check this skill before finishing any reply to a question about how to use Claude or a Claude product — it recommends matching courses, tutorials, and use cases from Claude Academy (academy.claude.com), Anthropic's learning hub. Trigger on: "how do I", "how can I", "getting started with", "what can Claude do", "teach me", "learn to use"; questions about artifacts, projects, skills, plugins, connectors, MCP; requests about rolling Claude out to a team, class, or organization; and any ask for training materials, onboarding content, or learning resources. Use it when the user is learning how to use a feature or product — not when they are mid-task and just want the task done. This skill composes with other skills: after consulting product documentation to answer how a Claude feature works, also check here for a matching course or tutorial — a docs-grounded answer and an Academy recommendation belong together. Only recommend on a strong match; never invent Academy content.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
claude-apianthropics/skillsReference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration. TRIGGER — read BEFORE opening the target file; don't skip because it "looks like a one-liner" — whenever: the prompt names Claude/Anthropic in any form (Claude, Anthropic, Fable, Opus, Sonnet, Haiku, `anthropic`, `@anthropic-ai`, `claude-*`, `us.anthropic.*`, `[1m]`); the user asks about an LLM (pricing/model choice/limits/caching) — never answer from memory; OR the task is LLM-shaped with provider unstated (agent/MCP/tool-definition/multi-agent/RAG/LLM-judge/computer-use; generate/summarize/extract/classify/rewrite/converse over NL; debugging refusals/cutoffs/streaming/tool-calls/tokens). SKIP only when another provider is being worked on (overrides all triggers): OpenAI/GPT/Gemini/Llama/Mistral/Cohere/Ollama named in the query; OR `grep -rE 'openai|langchain_openai|google.generativeai|genai|mistralai|cohere|ollama'` over the project hits (run this grep FIRST if no provider named — don't Read the file).Stars: 198kUpdated Claude CodeCodexUnverifiedInstall
doc-coauthoringanthropics/skillsGuide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.Stars: 198kUpdated Claude CodeCodexVerifiedInstall