Codexer

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

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)

def process_data(data):  # No type hints, vague naming
    result = []
    for item in data:
        result.append(item * 2)  # Magic multiplication
    return result

Pythonic Principles

# 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

---

## Cross-Client Portability

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

- GitHub Copilot: keep the folder in a Copilot-visible skill or plugin path, or wrap the workflow as project instructions if the host does not support portable skill folders directly.
- Claude Code: keep the folder in a local skills directory or a compatible plugin or marketplace source.
- Codex: install or sync the folder into `$CODEX_HOME/skills/` and restart Codex after major changes.
- Gemini CLI: this repository generates a project command named `/skills:codexer` from this skill. Rebuild commands with `python scripts/export-gemini-skill.py codexer` and then run `/commands reload` inside Gemini CLI.

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

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

## Source & license

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

- **Author:** [PracticalSwan](https://github.com/PracticalSwan)
- **Source:** [PracticalSwan/agent-skills](https://github.com/PracticalSwan/agent-skills)
- **License:** MIT

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