DevOps

Structured file enumeration and content analysis for understanding codebasestructure before reviews or refactoring.Triggers: file analysis, codebase structure, directory mapping, hotspot detection,code exploration, file enumeration, structure mapping, module boundariesUse when: before architecture reviews to understand file organization, exploringunfamiliar codebases to map structure, estimating scope for refactoring or migrationDO 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 detailedquality assurance.Triggers: test updates, test maintenance, test generation, TDD workflow,BDD patterns, test coverage, pytest, test enhancement, quality assuranceUse when: updating existing tests, generating new tests for features,enhancing test quality, ensuring detailed coverage, pre-commit validationDO 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.

Process external resources into actionable knowledge with evaluation, storage, and application decisions.Triggers: knowledge intake, article evaluation, paper review, external resourceUse when: user shares links to articles, papers, or external resourcesDO NOT use when: searching existing knowledge - use knowledge-locator.

Transform specifications into structured implementation plans with architecture design and task breakdown

Analyze and enhance Makefiles for complete user functionality coverage.Triggers: Makefile analysis, Makefile gaps, missing targets, plugin release,Makefile coverage, build targets, make dogfood, plugin qualityUse when: analyzing Makefile completeness before releasing plugins, identifyinggaps during plugin maintenance, scoring Makefiles against best practices,verifying Makefiles support standard developer workflowsDO NOT use when: writing initial Makefiles from scratch.DO NOT use when: debugging specific build target failures.DO NOT use when: creating custom non-standard build systems.Use this skill BEFORE releasing any plugin to verify Makefile coverage.

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 optimizationUse when: context usage approaches 50% of window, tasks need decomposition,complex multi-step operations planned, context pressure is highDO 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 patternsfor high-performance applications.Triggers: asyncio, async/await, coroutines, concurrent programming, async API,I/O-bound, websockets, background tasks, semaphores, async context managersUse when: building async APIs, concurrent systems, I/O-bound applications,implementing rate limiting, async context managersDO 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 conventionsUse when: developing new sanctum skills, refactoring existing skills,ensuring consistency across sanctum workflows, referencing standard patternsDO NOT use directly: this skill is infrastructure for other sanctum skills.Provides reusable patterns consumed by all sanctum git and workspace skills.

Use a Layered (N-Tier) architecture to separate presentation, domain logic, anddata 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 directionUse when: building traditional applications with clear boundaries, working withmoderate-sized teams, needing familiar and well-understood patterns, compliancerequirements demand clear separationDO 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 alignedto specific business capabilities.Triggers: microservices, service decomposition, independent deployment, team autonomy,distributed system, API gateway, service mesh, bounded contexts, polyglot persistenceUse when: teams need high autonomy and independent releases, different capabilitieshave distinct scaling needs, strong DevOps/SRE maturity exists, polyglot tech stacks neededDO 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.

Evaluate and improve Claude skill quality through auditing.Triggers: skill audit, quality review, compliance check, improvement suggestions,token usage analysis, skill evaluation, skill assessment, skill optimization,skill standards, skill metrics, skill performanceUse when: reviewing skill quality, preparing skills for production, auditingexisting skills, generating improvement recommendations, checking compliancewith standards, analyzing token efficiency, benchmarking skill performanceDO NOT use when: creating new skills from scratch - use modular-skills instead.DO NOT use when: writing prose for humans - use writing-clearly-and-concisely.DO NOT use when: need architectural design patterns - use modular-skills.Use this skill BEFORE shipping any skill to production. Check even if unsure.

Enforces "prove before claim" discipline - validation, testing, and evidencerequirements before declaring work complete.Triggers: completion, finished, done, working, should work, configured,ready to use, implemented, fixedUse when: claiming ANY work is complete, recommending solutions, statingsomething will work, finishing implementationsDO NOT use when: explicitly asking questions or requesting clarificationDO NOT use when: work is clearly in-progress and not claiming completionCRITICAL: This skill is MANDATORY before any completion claim. Violationsresult in wasted time and eroded trust.

Guide to effective Claude Code skill authoring using TDD methodology andpersuasion principles.Triggers: skill authoring, skill writing, new skill, TDD skills, skill creation,skill best practices, skill validation, skill deployment, skill complianceUse when: creating new skills from scratch, improving existing skills withlow compliance rates, learning skill authoring best practices, validatingskill quality before deployment, understanding what makes skills effectiveDO NOT use when: evaluating existing skills - use skills-eval instead.DO NOT use when: analyzing skill architecture - use modular-skills instead.DO NOT use when: writing general documentation for humans.YOU MUST write a failing test before writing any skill. This is the Iron Law.

Interactive selector and router for architecture paradigms. Triggers: architecture selection, pattern comparison, system design, ADR creation, architecture decision, paradigm evaluation, new system architecture, architecture planning, which architecture, compare architectures Use when: selecting architecture patterns for new systems, comparing paradigm trade-offs, creating architecture decision records, evaluating architecture fit for team size and domain complexity, planning implementation roadmaps DO NOT use when: implementing a specific known paradigm - use the specific architecture-paradigm-* skill (hexagonal, layered, microservices, etc.) instead. DO NOT use when: reviewing existing architecture - use architecture-review instead. Use this skill BEFORE making architecture decisions. Check even if unsure about needs.

Intensive mathematical analysis for numerical stability, algorithm correctness,and alignment with authoritative standards.Triggers: math review, numerical stability, algorithm correctness, mathematicalverification, scientific computing, numerical analysis, derivation checkUse when: reviewing math-heavy code, verifying algorithm correctness, checkingnumerical stability, aligning with mathematical standardsDO 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 analysesand audit trails.Triggers: evidence capture, citations, reproducible analysis, audit trail,documentation, evidence logging, findings documentationUse when: conducting any review that needs evidence trails, creating auditdocumentation, ensuring reproducibility of analysesDO 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 optimizationUse 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.

Ability to develop both front-end and back-end systems, integrating user interfaces with server logic and databases.

Skill in automating software deployment pipelines and managing cloud infrastructure for scalable, reliable systems.