pytest
TestingCommonly used with
Skills using pytest (298)
finishing-a-development-branch
当实现完成、所有测试通过、需要决定如何集成工作时使用——通过提供合并、PR 或清理等结构化选项来引导开发工作的收尾
executing-plans
当你有一份书面实现计划需要在单独的会话中执行，并设有审查检查点时使用
writing-plans
当你有规格说明或需求用于多步骤任务时使用，在动手写代码之前
skill-finish-branch
Wrap up a branch — run tests, create PR, merge or discard — use when implementation is done
makefile-generation
Generates Makefiles with testing, linting, formatting, and automation targets. Use when starting a project or standardizing build automation.
python-quality-gate
Python quality checks: ruff, pytest, mypy, bandit in deterministic order.
autoresearch-agent
Autonomous experiment loop that optimizes any file by a measurable metric. Inspired by Karpathy's autoresearch. The agent edits a target file, runs a fixed evaluation, keeps improvements (git commit), discards failures (git reset), and loops indefinitely. Use when: user wants to optimize code speed, reduce bundle/image size, improve test pass rate, optimize prompts, improve content quality (headlines, copy, CTR), or run any measurable improvement loop. Requires: a target file, an evaluation command that outputs a metric, and a git repo.
plugin-dev-workflow
Guide plugin development workflow — editing skills, agents, hooks, or eval framework in this repo. Use when modifying files in plugins/elixir-phoenix/, lab/eval/, or lab/autoresearch/. Ensures changes pass eval, lint, and tests before committing.
add-rtk
Install rtk token-compression proxy into agent containers. Routes Bash tool calls through rtk for 60–90% token savings on dev commands (git, cargo, pytest, docker, kubectl, etc.).
agent-implementer-sparc-coder
Agent skill for implementer-sparc-coder - invoke with $agent-implementer-sparc-coder
ci
Detect/generate/debug CI pipeline config (GitHub Actions, GitLab CI). Triggers: CI setup, build pipeline, GitHub Actions config, debug CI, GitLab CI.
git-mastery
Advanced Git: rebase, bisect, reflog, cherry-pick, worktrees, LFS. Triggers: rebase, bisect, cherry-pick, reflog, force push, merge conflict, worktree.
check-and-test
Run lint checks (ruff for Python, Biome for TS/JS), type checks (pyright for Python, tsc for TS/JS), and the standard pytest tiers (unit + e2e + tests skipped during pre-commit). Investigates failures to determine if they are application bugs or test issues, and fixes application bugs rather than weakening tests. Does not run paid-LLM real-API tests or scenario probes from the test-* command family.
test-fixing
Run tests and systematically fix all failing tests using smart error grouping. Use when user asks to fix failing tests, mentions test failures, runs test suite and failures occur, or requests to make tests pass.
cross-review
Verify an implementer's diff with an INDEPENDENT, different-vendor sub-agent (diff plus contract only); turn blocking issues into fix-tasks and loop until clean.
finishing-a-development-branch
Use when implementation is complete, verification has passed, and the user needs to choose merge, PR, branch cleanup, or follow-up integration handling.
api-test-suite-builder
Use when the user asks to generate API tests, create integration test suites, test REST endpoints, or build contract tests.
harness-audit
Score a project's agent harness across 5 subsystems (Instructions / State / Verification / Scope / Lifecycle), identify the bottleneck, and produce a prioritized improvement plan. Use when assessing if a project is ready to graduate to [LONG-RUN] status, when an agent keeps failing despite good models, or when adopting our stack on a new codebase. Do NOT use to design or build a new harness from scratch — this only scores an existing one; for greenfield harness/agent architecture use harness-design (or agent-harness-design).
robotics-testing
Testing strategies, patterns, and tools for robotics software. Use this skill when writing unit tests, integration tests, simulation tests, or hardware-in-the-loop tests for robot systems. Trigger whenever the user mentions testing ROS nodes, pytest with ROS, launch_testing, simulation testing, CI/CD for robotics, test fixtures for sensors, mock hardware, deterministic replay, regression testing for robot behaviors, or validating perception/planning/control pipelines. Also covers property-based testing for kinematics, fuzz testing for message handlers, and golden-file testing for trajectories.
night-market-operations
Run and ship this repo: make targets, artifacts, release runbook. Use when testing, linting, or releasing. Do not use for setup; use night-market-build-and-env.
ship
Build, commit, push & version bump workflow - automates the complete release cycle
backend
Python server code, APIs, async, strict typing.
qa
Test writing - pytest suites, edge cases, regressions.
commit
Commit workflow for Job Hunter development, including preflight tests, schema validation, linting, safe staging, and intentional commit messages.
finishing-a-development-branch
Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup
test-first-bugs
This skill should be used when the user reports a bug, describes unexpected behavior, says something is "broken", "not working", "failing", mentions an "error", "issue", or "problem" in code, or asks to "fix" something. Enforces test-driven bug fixing workflow.
tokf-run
Compress verbose CLI output with tokf before returning results. Activates for git, cargo, npm, docker, go, gradle, kubectl, and other supported commands.
agf-running-sit-tests
Use when an execution-layer dev (frontend-dev / backend-dev / ai-agent-dev / ml-engineer / miniapp-dev) has finished feature code + Unit tests and is about to enter code-review. Provides the SIT scope, environment, AC-driven integration walk, and evidence sink (progress/<role>.md). SIT is now a dev-owned step, not a separate QA stage.
debug
Investigation-first debugging — gather evidence, form confirmed root-cause hypothesis, hand off to fix mode with diagnosis file. TRIGGER when: user reports a symptom or failing test with Python traceback, or asks to investigate a runtime/CI failure with reproducible evidence; phrases: "debug this failure", "why is X broken", "find the root cause of <error>", "investigate this CI failure". SKIP when: pure config quality issues (use `/foundry:audit`); broad system-wide diagnosis without traceback (use `/foundry:investigate`); user already knows the fix (use `/develop:fix`); non-Python project.
feature
TDD-first feature development — crystallise API as a demo test, drive implementation to pass it, run quality stack and progressive review loop. TRIGGER when: user asks to build new functionality, add a capability, or implement a feature in a Python project; phrases: "add X", "implement Y", "build Z feature", "create a new module for". SKIP when: bug fixes (use `/develop:fix`); refactoring without new behaviour (use `/develop:refactor`); non-Python projects; `.claude/` config changes (use `/foundry:manage`).
fix
Reproduce-first bug resolution — capture bug in failing regression test, apply minimal fix, run quality stack and review loop. TRIGGER when: user reports a bug, regression, or unexpected behaviour in Python code with a traceback, failing test, or issue number; phrases: "fix this bug", "repair X", "broken since Y", "test failing". SKIP when: CI-only failures without local traceback (use `/develop:debug` first); new features (use `/develop:feature`); `.claude/` config issues (use `/foundry:audit`); non-Python projects.
refactor
Test-first refactoring — audit coverage, add characterization tests, apply changes with safety net, run quality stack and review loop. TRIGGER when: user wants to restructure existing Python code without changing behaviour; phrases: "refactor X", "clean up Y", "extract Z", "restructure this module", "improve code quality". SKIP when: bug fixes (use `/develop:fix`); new features (use `/develop:feature`); mixed refactor+feature — run `/develop:refactor` first, then `/develop:feature`; non-Python projects.
python-build-tools
Python project tooling with uv, mise, ruff, basedpyright, and pytest. Use when setting up pyproject.toml, running builds, typechecking, configuring tests, linting, formatting, or managing Python environments.
python-monorepo
Python monorepo architecture with uv workspaces, mise, and apps/packages pattern. Use when setting up project structure, configuring workspaces, managing dependencies across packages, or designing multi-app Python repositories.
python-testing
Stub-Driven TDD and layer boundary testing with pytest. Use when writing tests, deciding what to test, testing at component boundaries, or implementing test-driven development.
spec-finish
Post-implementation completion workflow for Spec-backed Plans. Use after spec-implement completes to validate, review, create stacked commits, and open a PR via code-pull-request. Triggers only with an active Spec-backed Plan after spec-implement completes, including when the user says "finish", "done", or "complete" in that context.
ci-fixer
CI failures - read error, minimal fix, verify.
python-env
Fast Python environment management with uv (10-100x faster than pip). Triggers on: uv, venv, pip, pyproject, python environment, install package, dependencies.
python-pytest-patterns
pytest testing patterns for Python. Triggers on: pytest, fixture, mark, parametrize, mock, conftest, test coverage, unit test, integration test, pytest.raises.
python-dev
Opinionated Python development setup with uv + ty + ruff + pytest + just. Use when creating new Python projects, setting up pyproject.toml, configuring linting, type checking, testing, or build tooling. Triggers on "python project", "uv init", "pyproject.toml", "ruff config", "ty check", "pytest setup", "justfile", "python linting", "python formatting", "type checking python".
github
GitHub operations — issues, PRs, commits, code search, CI/CD via gh CLI
telemetry
Unified pipeline telemetry — collects per-stage performance metrics (CPU, memory, I/O) and diagnostic events into structured reports (JSON, text).
template-academic-paper
Template-native manuscript planning, outline, drafting, revision, formatting, citation check, and AI-use disclosure routing. USE WHEN the user asks to write, outline, revise, format, or prepare a paper inside the Research Project Template.
template-academic-paper-reviewer
Read-only manuscript review, methodology review, re-review, and calibration workflow for template projects. USE WHEN the user asks for peer review, referee-style critique, methods/statistics review, or verification that revisions addressed prior comments.
template-academic-pipeline
Research-to-publication orchestrator for template projects: research, write, verify, review, revise, reproduce, validate, and finalize. USE WHEN the user wants the whole paper workflow or enters midstream with an existing paper or reviewer comments.
template-agentic-use
Agentic-use and skill-routing workflow for the Research Project Template. USE WHEN discovering relevant skills, making template easier for agents to navigate, auditing docs/prompts skill coverage, checking .cursor/skill_manifest.json, evaluating external skills, reviewing external agentic operating models such as Steward OS, AutoResearch CLI, LEANN, or Agent Skills for Context Engineering, or improving agent onboarding/routing without changing project behavior.
template-code-development
Standards-compliant code for the Research Project Template — infrastructure or project src/, thin orchestrators, type hints, no mocks. USE WHEN implementing an algorithm, utility, analysis method, optimizer, new module in projects/*/src or infrastructure/, or user says add code following template architecture — even without docs/prompts. Not for end-to-end feature spanning manuscript + pipeline (use template-feature-addition).
template-comprehensive-assessment
Full checkout audit for the Research Project Template — tests, architecture, docs, manuscript, pipeline. USE WHEN user asks for comprehensive assessment, full repo review, health check across projects, audit everything, or pre-merge sanity sweep for template exemplars — even without naming docs/prompts or a skill. Not for single failing stage only.
template-deep-research
Template-native research intake, literature search, source verification, synthesis, fact-checking, and systematic-review planning. USE WHEN the user asks to research a topic, build a literature corpus, fact-check claims, prepare a PRISMA-style review, or clarify a research question before manuscript work.
template-manuscript-claim-verification
Triple-pass verification of every manuscript claim against code, data, refs, and renderer; repair prose while staying renderable. USE WHEN pre-submission, pre-Zenodo, pre-arXiv, abstract numbers disagree with CSV, citations do not support sentences, or user asks to triple-check / verify every claim — even without docs/prompts. Not for casual PDF summary.
template-manuscript-creation
Scaffold a research manuscript and project layout from a research brief — sections, config.yaml, src/, scripts/, tests. USE WHEN starting a new paper, new projects/ tree, manuscript from topic description, or aligning with template_code_project exemplar — even without copy-paste prompts.
template-manuscript-cross-references
Audit or author registry-driven manuscript cross-refs — labels.yaml, [[FIG:]], [[THMREF:]], [[VAR:]] tokens. USE WHEN fixing figure/equation/theorem numbering, orphan registry keys, hard-coded "Theorem 7.3" in prose, or [[MISSING:]] injection failures — even for Pandoc projects that also use a YAML registry.
template-pipeline-debugging
Systematic pipeline DAG failure triage for the Research Project Template. USE WHEN ./run.sh or execute_pipeline.py fails, a stage stalls (setup, tests, analysis, render, validate, LLM, copy), pytest/coverage gate fails mid-pipeline, PDF render or validate breaks, Project Analysis finishes too fast with no figures, or user says pipeline debug, stage failed, resume checkpoint, core-only triage — even without naming this skill or docs/prompts.
template-reproducibility-audit
Deterministic reproducibility audit — fixed seeds, regenerate-from-clean, double-run diff before Zenodo/arXiv/release. USE WHEN outputs drift between runs, "worked on my machine", need regenerate-from-clean proof, or pre-release reproducibility check — even without naming docs/prompts.
template-startup
Full installation and validation workflow for a fresh clone of the Research Project Template. Installs dependencies, runs pre-commit hooks, executes the core pipeline against template_code_project, validates outputs, and reports a structured PASS / FAIL for each checkpoint. USE WHEN the user says "start", "set up the repo", "install and validate", "does everything work", "first time setup", or any variant of bootstrapping a fresh or unknown checkout.
template-workflows
Router and workflow hub for the Research Project Template — code, tests, manuscripts, pipeline, validation, docs, and reproducibility. USE WHEN the user wants to audit the repo, debug ./run.sh or execute_pipeline.py, add a feature, write tests, scaffold a manuscript, verify claims, fix cross-references, run validation gates, refactor, or prepare a Zenodo release, discover relevant template skills, improve agent routing, review external agentic operating models or retrieval references such as Steward OS, AutoResearch CLI, or LEANN, research a topic, write/review/revise a paper, or run a research-to-publication workflow — even if they never say "prompt", "skill", or docs/prompts. Also USE WHEN intent is ambiguous ("something wrong with my manuscript", "full health check", "fix the pipeline") — pick ONE child skill from the routing table and follow it. Do NOT use for generic homework, unrelated app security scans, or casual PDF summarization.
tdd
Test-driven development — write a failing test that names the behavior, watch it fail, implement the minimum to make it pass, then refactor with tests green. Works for new features, bug fixes, and behavior changes. Use when the user says "tdd", "test-first", "write tests first", or wants a change built test-first.
auto-setup
Auto-configure quality gates, hooks, and settings for a new project. Detects project type and sets up appropriate tooling. Use when onboarding a new codebase.
verify
Active QA verification - full validation before completion
testing-strategy
Testing strategy, patterns, and quality assurance for the project. Covers vitest patterns, external integration test design (mocking transport, simulating reconnect, checksum validation for streaming sources), domain math test design (boundary values, precision edge cases), E2E multi-process testing (IPC, worker lifecycle), route testing (auth verification, input validation), database test patterns (mocking data layer), chaos test framework design, test quality metrics (mutation testing, branch coverage), React component/hook testing (RTL query priority, MSW network mocking, axe a11y), test-first TDD (RED/GREEN/REFACTOR discipline), and CI integration. Use when writing tests, reviewing test quality, designing test strategies, setting up CI pipelines, or evaluating test coverage gaps.
python-testing
Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements.
agent-supply-chain
Generate and verify integrity manifests for AI agent plugins and tools -- detect tampering, enforce version pinning, and establish supply chain provenance (the SLSA/Sigstore gap for agent ecosystems).
neo-python
Use this skill when writing, reviewing, debugging, or architecting Python 3.10+ code, including type hints, structural pattern matching, dataclasses, async/task groups, packaging-aware project structure, testability, and maintainability.
test-impact
Identify which tests need rerunning after a code change — traces static call graph (function-level) or import graph (module-level) to find affected test files, then emits a ready-to-run pytest command. Trigger with `$codemap-py:test-impact <module::symbol | module> [--no-mocks]` for: "which tests are affected", "what tests cover this", "test impact of", "what tests to rerun".
root-cause-by-layer
Use when encountering a bug, failing test, or unexpected behavior — especially under time pressure where try/except, retry loops, xfail, type-tolerance shims, "I'll clean up later," or compat-for-both-shapes feel like the fastest path. Forbids symptom patches until structural and conceptual origins are named.
python-architect
Creates high-level Python architecture with protocols, test stubs, and module structure. Use when designing Python projects or features.
ros2-testing
Testing: launch_testing, gtest/pytest, rosbag2 C++/Python APIs, ros2trace profiling.
godot-e2e
Write and run E2E (end-to-end) game tests using the godot-e2e framework. Python controls a live Godot game over TCP — Locator-based semantic queries, expect() auto-retry assertions, and engine log capture make failures self-diagnosing. Use this skill whenever you need to: - Test actual gameplay: player movement, collisions, scoring, scene transitions - Verify UI interactions: button clicks, label text, menu navigation - Write integration tests that run the real game (not mocked unit tests) - Debug E2E test failures or set up E2E test infrastructure Triggers: "E2E test", "end-to-end test", "gameplay test", "test the game running", "simulate input", "test player movement", "test UI clicks", "godot-e2e", "integration test for game", "test scene transitions".
advanced-evaluation
This skill should be used for advanced LLM evaluation: LLM-as-judge systems, direct scoring, pairwise comparison, rubric calibration, evaluator bias mitigation, confidence scoring, and automated quality assessment.
bdi-mental-states
This skill should be used when modeling agent mental states with BDI concepts: beliefs, desires, intentions, RDF-to-belief transformations, rational agency traces, cognitive agents, BDI ontologies, and neuro-symbolic AI integration.
context-compression
This skill should be used when long-running agent sessions need context compression, structured summarization, compaction, token-per-task optimization, or durable handoff summaries that preserve decisions, files, risks, and next actions.
context-degradation
This skill should be used for diagnosing and mitigating context degradation: lost-in-middle failures, context poisoning, context clash, context confusion, attention-pattern issues, and agent performance degradation caused by accumulated or conflicting context.
context-fundamentals
This skill should be used to explain or reason about the foundational concepts of context engineering: what context is, the anatomy of a context window, how attention mechanics work, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret every other context-engineering decision. Use this for conceptual explanation, onboarding, and background reading. Route operational work to the specialized skills: debugging attention failures goes to context-degradation, token-efficiency work goes to context-optimization, conversation summarization goes to context-compression, and project-shape decisions go to project-development.
continual-learning
Orchestrate continual learning by delegating transcript mining to agents-memory-updater and writing durable memory to local JSON (never root AGENTS.md Learned sections). USE WHEN continual learning, mine prior chats, maintain agent memory, or the stop hook triggers this skill.
evaluation
This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and outcome measurement for agent pipelines.
filesystem-context
This skill should be used when agent work needs file-backed context: durable scratchpads, tool-output offloading, just-in-time discovery, cross-agent handoff files, filesystem memory, or cleanup policies for context stored outside the prompt.
harness-engineering
This skill should be used when designing autonomous agent harnesses: research loops, evaluation scaffolds, locked and editable surfaces, durable logs, novelty gates, pruning, rollback, PR preparation, and human approval boundaries.
hosted-agents
This skill should be used when designing hosted or background agent infrastructure: sandboxed execution, remote coding environments, warm pools, session persistence, multiplayer collaboration, self-spawning agents, or Modal-style sandboxes.
infrastructure-autoresearch
Skill for deterministic AutoResearch readiness planning. Use when adding, validating, or documenting opt-in autoresearch.yaml controls, stage-gate readiness, evidence-grounded claims, artifact readiness reports, or AutoResearchClaw-inspired workflow checks in template projects.
infrastructure-core
Skill for the core infrastructure module providing logging, configuration, exception handling, progress tracking, checkpoints, retry logic, pipeline execution, performance monitoring, security, file operations, and multi-project orchestration. Use when setting up logging, loading config, handling errors, running pipelines, or monitoring performance.
infrastructure-doctor
Skill for the doctor infrastructure module providing repository-level diagnostics and safe, reversible automated repair. Use when the local checkout is acting up, before opening a bug, when onboarding a fresh clone, or as a periodic health probe. Every mutation is backed up under .doctor/backups/ and journalled in .doctor/actions.jsonl so any change can be undone byte-for-byte.
infrastructure-documentation
Skill for the documentation infrastructure module providing figure management, image handling, markdown integration, and API glossary generation. Use when managing research figures, inserting images into manuscripts, auto-numbering figures, or generating API documentation.
latent-briefing
This skill should be used when the user asks to "share memory between agents", "KV cache compaction for multi-agent", "orchestrator worker context", "latent briefing", "reduce worker tokens", "cross-agent memory without summarization", or discusses Attention Matching compaction, recursive language models with workers, or token explosion in hierarchical agents.
long-horizon-prompting
This skill should be used when writing, enhancing, or evaluating the launch prompt for a long-running autonomous agent or a parallel multi-agent orchestration attacking a hard problem: pseudo-formal task briefs that define terms and an exact success predicate linguistically, enumerate non-counting outcomes, set persistence rules with explicit stop and return conditions and effort floors, manage a diverse portfolio of parallel approaches with an approach registry and blocked-route bookkeeping, and gate the return on adversarial audit. Route agent topology and coordination protocols to multi-agent-patterns, runtime control surfaces and loop governance to harness-engineering, evaluator and quality-gate construction to evaluation, judge design to advanced-evaluation, and compaction or memory mechanics to context-compression and memory-systems.
memory-systems
This skill should be used for persistent semantic memory in agent systems: cross-session knowledge retention, entity tracking, temporal validity, graph or vector retrieval, memory consolidation, and memory benchmark selection. Route file-backed scratchpads to filesystem-context, handoff summaries to context-compression, and token-efficiency tactics to context-optimization.
multi-agent-patterns
This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs, parallel execution, or a decision on whether multiple agents are justified.
project-development
This skill should be used for project-level decisions about LLM-powered systems: whether an LLM is the right primitive for the task at hand, the shape of a multi-stage batch or agent pipeline, token and cost estimation, choosing between single-agent and multi-agent at the project level, structured output design for downstream parsing, and structuring agent-assisted iteration. Use this when the unit of work is a whole project or a multi-stage pipeline. Route individual tool design to tool-design and individual skill-loading or context-budget tactics to context-optimization.
self-improvement-loops
This skill should be used when the harness, scaffold, workflow, or optimizer itself is the optimization target: recursive self-improvement (RSI) loops, meta-harnesses, self-improving harnesses that mine their own failures and propose bounded edits, evolutionary or population-based search over agent scaffolds, acceptance gates for self-modifying systems, and agentic context evolution where the mechanism that produces context is versioned and evolved. Route governance of a single autonomous loop (locked surfaces, durable logs, rollback, novelty gates, approval boundaries) to harness-engineering, measurement and quality-gate design to evaluation, judge design to advanced-evaluation, and remote sandbox infrastructure to hosted-agents.
template-documentation-creation
Author or refresh AGENTS.md and README.md for template directories — accurate commands, Mermaid where helpful, link _generated/active_projects.md. USE WHEN folder needs AGENTS, README audit, doc contract fix, or signposting after code change — even without documentation_creation prompt.
template-feature-addition
End-to-end feature work across src/, scripts/, tests/, manuscript, and docs for the Research Project Template. USE WHEN adding a pipeline-visible feature, new analysis stage, manuscript-facing output, or cross-layer integration — even without feature_addition prompt.
template-infrastructure-module
Add or extend generic infrastructure/ packages — Layer 1 modules with SKILL.md, AGENTS.md, tests in tests/infra_tests/, 60% coverage. USE WHEN new reusable package under infrastructure/, extending validation/rendering/llm, or skill manifest entry — even without infrastructure_module prompt.
template-literature-synthesis
LLM prompt blocks for per-paper and corpus literature synthesis after a search pipeline. USE WHEN synthesizing arXiv/Crossref results, writing per-paper notes, thematic clusters, gap analysis from a literature corpus, or wiring template_search_project synthesis — even without naming infrastructure.llm templates.
template-methods-orchestration
Repo-wide methods orchestration workflow for the Research Project Template. USE WHEN the user asks to add, audit, improve, or validate methods, methodology, method contracts, stage-to-method wiring, artifact/evidence provenance, or orchestration across template projects.
template-publication-audit
End-to-end publication-readiness audit for public template exemplars — tests, no-mocks, methods contracts, claims, evidence, figures, references, rendered outputs, and deterministic regeneration. USE WHEN preparing a template or project for release, DOI deposit, peer review, or a publication sign-off.
template-refactoring
Clean-break refactors with migration for the Research Project Template — move logic to src/, split modules, rename APIs with test updates. USE WHEN restructuring code, extracting modules, removing duplication, or migration without behavior change.
template-test-creation
Create pytest suites under the no-mocks policy — real data, temp files, subprocess, pytest-httpserver. USE WHEN adding tests, raising coverage, testing new src/ module, or user forbids mocks.
template-validation-quality
Run validation CLI, prerender, markdown/PDF/integrity gates, and QA workflows for the Research Project Template. USE WHEN validate manuscript, check PDF for ?? refs, prerender gate, link checker, output integrity, or pre-commit validation — even without validation_quality prompt.
tool-design
This skill should be used for the tool-interface layer of an agent system specifically: writing tool descriptions agents can route on, designing tool schemas and response formats, naming conventions, actionable error recovery messages, MCP server design, tool-set consolidation, and deciding when to add or remove an individual tool. Use this when the unit of work is a single tool or a set of tools. Route project-shape, pipeline architecture, and task-model-fit decisions to project-development; route deciding whether to introduce sub-agents to multi-agent-patterns.
security-audit
Security audit + fix — scans for hardcoded secrets, injection vectors, path traversal, input validation gaps, then implements all fixes
python-project-setup
Sets up Python projects with modern tooling including pyproject.toml, linting with ruff, formatting, type checking with mypy or pyright, testing with pytest, and pre-commit hooks. Triggers on: "setup Python project", "create Python package", "python project structure", "pyproject.toml".
Showing top 100 of 298 skills using pytest by quality score.
See all 298 skills via search →Integration detected automatically from skill content. Some results may be false positives.