持續整合/部署

Context-aware progressive module loading with hub-and-spoke pattern for token optimization. Triggers: progressive loading, lazy loading, hub-spoke, module selection Use when: optimizing skill loading or reducing upfront context usage

Construct temporary, session-specific memory palaces for complex projects and conversations. Triggers: session context, project memory, conversation state, temporary storage, session palace, context preservation, complex project, extended conversation Use when: working on complex multi-step projects, preserving context across interruptions, tracking session-specific state DO NOT use when: permanent knowledge structures needed - use memory-palace-architect. DO NOT use when: searching existing knowledge - use knowledge-locator. Consult this skill for session-scoped temporary knowledge structures.

Create distributable Python packages with proper structure and publishing. Triggers: Python packaging, pyproject.toml, uv, pip, PyPI, distribution, CLI tools, entry points, package structure, publishing Use when: creating Python packages, configuring pyproject.toml, setting up entry points, publishing to PyPI, CI/CD for packages DO NOT use when: testing packages - use python-testing instead. DO NOT use when: optimizing package performance - use python-performance. Consult this skill for Python package creation and distribution.

Spatial indexing and retrieval system for finding information within memory palaces using multi-modal search. Triggers: knowledge search, find information, locate concept, recall, spatial query, cross-reference, discovery, memory retrieval, pr review search, past decisions, review patterns Use when: searching for stored knowledge, cross-referencing concepts, discovering connections, retrieving from palaces, finding past PR decisions DO NOT use when: creating new palace structures - use memory-palace-architect. DO NOT use when: processing new external resources - use knowledge-intake. Consult this skill when searching or navigating stored knowledge.

Shared infrastructure and patterns for imbue analysis skills. Triggers: imbue patterns, todowrite patterns, evidence formats, analysis workflows, shared templates, imbue infrastructure Use when: other imbue skills need common patterns, creating new analysis skills, ensuring consistency across imbue plugin DO NOT use directly: this skill is infrastructure for other imbue skills. This skill provides shared patterns consumed by other imbue skills.

Generic weighted scoring and threshold-based decision framework for evaluating artifacts against configurable criteria. Triggers: evaluation, scoring, quality gates, decision framework, rubrics, weighted criteria, threshold decisions, artifact evaluation Use when: implementing evaluation systems, creating quality gates, designing scoring rubrics, building decision frameworks DO NOT use when: simple pass/fail without scoring needs. Consult this skill when building evaluation or scoring systems.

Complete guide for writing Claude Code and SDK hooks with security-first design. Triggers: hook creation, hook writing, PreToolUse, PostToolUse, UserPromptSubmit, tool validation, logging hooks, context injection, workflow automation Use when: creating new hooks for tool validation, logging operations for audit, injecting context before prompts, enforcing project-specific workflows, preventing dangerous operations in production DO NOT use when: logic belongs in core skill - use Skills instead. DO NOT use when: complex multi-step workflows needed - use Agents instead. DO NOT use when: behavior better suited for custom tool. Use this skill BEFORE writing any hook. Check even if unsure.

Code design patterns: pure functions, immutability, composition, and async. Use when designing code or functions.

Configure GitHub Actions workflows for CI/CD (test, lint, typecheck, publish)

Structured file enumeration and content analysis for understanding codebase structure before reviews or refactoring. Triggers: file analysis, codebase structure, directory mapping, hotspot detection, code exploration, file enumeration, structure mapping, module boundaries Use when: before architecture reviews to understand file organization, exploring unfamiliar codebases to map structure, estimating scope for refactoring or migration DO NOT use when: general code exploration - use the Explore agent. DO NOT use when: searching for specific patterns - use Grep directly. Provides structural context for downstream review and refactoring workflows.

Update and maintain tests following TDD/BDD principles with detailed quality assurance. Triggers: test updates, test maintenance, test generation, TDD workflow, BDD patterns, test coverage, pytest, test enhancement, quality assurance Use when: updating existing tests, generating new tests for features, enhancing test quality, ensuring detailed coverage, pre-commit validation DO NOT use when: auditing test suites - use pensive:test-review. DO NOT use when: writing production code - focus on implementation first. Run git-workspace-review first to understand which tests need updates.

Reduce context usage with MECW principles (keep under 50% of total window). Triggers: context pressure, token usage, MECW, context window, optimization, decomposition, workflow splitting, context management, token optimization Use when: context usage approaches 50% of window, tasks need decomposition, complex multi-step operations planned, context pressure is high DO NOT use when: simple single-step tasks with low context usage. DO NOT use when: already using mcp-code-execution for tool chains. Use this skill BEFORE starting complex tasks. Check context levels proactively.

Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Triggers: asyncio, async/await, coroutines, concurrent programming, async API, I/O-bound, websockets, background tasks, semaphores, async context managers Use when: building async APIs, concurrent systems, I/O-bound applications, implementing rate limiting, async context managers DO NOT use when: CPU-bound optimization - use python-performance instead. DO NOT use when: testing async code - use python-testing async module. Consult this skill for async Python patterns and concurrency.

Shared infrastructure and patterns for sanctum git/workspace skills. Triggers: sanctum patterns, todowrite patterns, git commands, output templates, sanctum infrastructure, shared patterns, git conventions Use when: developing new sanctum skills, refactoring existing skills, ensuring consistency across sanctum workflows, referencing standard patterns DO NOT use directly: this skill is infrastructure for other sanctum skills. Provides reusable patterns consumed by all sanctum git and workspace skills.

Intensive mathematical analysis for numerical stability, algorithm correctness, and alignment with authoritative standards. Triggers: math review, numerical stability, algorithm correctness, mathematical verification, scientific computing, numerical analysis, derivation check Use when: reviewing math-heavy code, verifying algorithm correctness, checking numerical stability, aligning with mathematical standards DO NOT use when: general algorithm review - use architecture-review. DO NOT use when: performance optimization - use parseltongue:python-performance. Use this skill for mathematical code verification.

Workflow for capturing evidence and citations to create reproducible analyses and audit trails. Triggers: evidence capture, citations, reproducible analysis, audit trail, documentation, evidence logging, findings documentation Use when: conducting any review that needs evidence trails, creating audit documentation, ensuring reproducibility of analyses DO NOT use when: quick informal checks without documentation needs. DO NOT use when: structured output is the focus - use structured-output. Use this skill as foundation for all evidence-based review workflows.

Development tooling standards including Deno runtime, JSR package registry, and configuration files. Use when setting up projects, managing dependencies, or configuring build tools.

Transform tool-heavy workflows into MCP code execution patterns for token savings and optimized processing. Triggers: MCP, code execution, tool chain, data pipeline, tool transformation, batch processing, workflow optimization Use when: >3 tools chained sequentially, large datasets (>10k rows), large files (>50KB), context usage >25% DO NOT use when: simple tool calls that don't chain. DO NOT use when: context pressure is low and tools are fast. Use this skill BEFORE building complex tool chains. Optimize proactively.

Use a Layered (N-Tier) architecture to separate presentation, domain logic, and data access responsibilities within a system. Triggers: layered architecture, n-tier, separation of concerns, presentation layer, data access layer, service layer, traditional architecture, monolith structure, layer enforcement, dependency direction Use when: building traditional applications with clear boundaries, working with moderate-sized teams, needing familiar and well-understood patterns, compliance requirements demand clear separation DO NOT use when: selecting from multiple paradigms - use architecture-paradigms first. DO NOT use when: high scalability needs independent component scaling. DO NOT use when: teams need independent deployment cycles - use microservices. Consult this skill when implementing layered patterns or enforcing layer boundaries.

Decompose systems into a suite of small, independently deployable services aligned to specific business capabilities. Triggers: microservices, service decomposition, independent deployment, team autonomy, distributed system, API gateway, service mesh, bounded contexts, polyglot persistence Use when: teams need high autonomy and independent releases, different capabilities have distinct scaling needs, strong DevOps/SRE maturity exists, polyglot tech stacks needed DO NOT use when: selecting from multiple paradigms - use architecture-paradigms first. DO NOT use when: small team with low organizational complexity. DO NOT use when: lack of DevOps maturity or limited platform engineering resources. DO NOT use when: strong transactional consistency required across operations. Consult this skill when designing or evolving microservices architectures.