Claude Skills by paulpas

Example SKILL.md showing the format the router expects

Implements Google's Agent-to-Agent (A2A) protocol for cross-framework agent communication using HTTP-based JSON-RPC 2.0 with agent card discovery, SSE streaming, and secure multi-agent interoperability patterns.

Implements intelligent acceptance orchestrator with multi-factor skill

Implements intelligent address github comments with multi-factor skill

Implements structural design patterns for AI agent systems including

Implements inter-agent communication patterns (message passing, event-driven

Implements context window management, sliding window strategies, and

Implements context window management and memory architectures for LLM agents including token budgeting, sliding window strategies, summarization fallbacks, cross-turn state persistence, and external vector store integration.

Implements systematic debugging workflows for LLM agent failures including hallucination detection, infinite loop recovery, context window exhaustion, tool call errors, and cascading failure diagnosis using distributed tracing patterns.

Applies traditional software engineering rigor to AI agents through checkpoint/rollback state management, modular architecture, structured observability logging, and least-privilege permissions for production-grade reliability.

Implements intelligent agent evaluation with multi-factor skill selection,

Constructs agent-centric knowledge graphs representing tools, capabilities, and their relationships for intelligent tool discovery during planning.

Implements intelligent agent manager skill with multi-factor skill selection,

Provides a four-level maturity model (Core Reasoning → Connected Solver → Strategic Problem-Solver → Collaborative Multi-Agent) for assessing and planning agent architecture investments based on capability requirements.

Implements intelligent agent memory systems with multi-factor skill selection,

Implements tracing, cost tracking, and latency monitoring patterns for AI agent systems to debug failures, control token spend, and optimize response times across multi-agent workflows.

Implements fault-tolerance mechanisms for AI agent systems including

Defines and structures functional, non-functional, and safety requirements for AI agent systems including capability matrices, hallucination thresholds, data quality standards, and evaluation criteria.

Implements prompt injection detection, input validation, tool access control, and output sanitization to secure LLM agents against adversarial attacks.

Applies subtle contextual hints instead of explicit step-by-step instructions

Encodes HTML special characters (< > & " ') into safe

Implements HubSpot API integration (CRM, Contacts, Companies, Deals,

Integrates Hugging Face APIs (Inference Client, Inference Endpoints,

Implements advanced IaC engineering patterns including modular Terraform architecture, policy-as-code with OPA, GitOps with ArgoCD, Terratest-driven testing, and cross-cloud multi-account resource management for production infrastructure.

Integrates IBM Cloud services (Watson AI, Cloud Foundry, Kubernetes Service, Cloud Object Storage) using IBM Cloud SDK for Python with IAM authentication and service patterns.

Implements idempotency patterns for distributed microservice systems

Comprehensive guide to AWS Identity and Access Management (IAM) covering users, roles, policies, STS, and Identity Center.

Implements immutable data patterns (value objects, pure functions, structural updates, copy-on-write collections, domain events) to eliminate mutation bugs and enable safe concurrent data processing.

Orchestrates production incident response including severity classification,

Normalizes and standardizes inconsistent inbound data into uniform internal

Builds composable data processing pipelines that validate, transform,

Implements production input validation and sanitization patterns including Pydantic v2 schemas, recursive nested validation, custom validators with error accumulation, allowlist enforcement, and type coercion for secure API endpoints.

Validates and normalizes input/output data using schema validation, type coercion, and sanitization patterns to prevent injection attacks and ensure data integrity.

Implements service-to-service integration patterns (adapter, API gateway,

Implements integration testing strategies (database, HTTP API, event-driven, message queue) with test isolation, fixture management, and real infrastructure validation for production-quality software systems.

Detects fat interfaces that force implementors to provide unused methods

Implements best practices for Java/Kotlin applications using Spring Boot,

Implements modern Java concurrency with virtual threads (JDK 21+), structured

Implements monorepo architecture, build toolchain selection, module federation,

Automates JavaScript/TypeScript package publishing with semantic-release,

Integrates with the Jenkins REST API via python-jenkins and JenkinsAPI

'"''OWASP Juice Shop guide: Web application security testing with intentionally"

Implements the Just task runner as a modern alternative to GNU Make with named arguments, subcommands, runsets, environment file support, and cross-platform portability for developer workflow automation.

Diagnoses JVM production incidents including OutOfMemoryError root causes, thread deadlock detection, heap leak analysis via MAT, and crash log triage for Java 17+ applications.

Diagnoses and optimizes JVM performance through garbage collector tuning,

Optimizes JVM runtime performance through garbage collector selection and tuning, memory layout configuration, JIT compilation flags, and allocation-aware coding patterns for Java 17+ applications.

Applies Karpathy's pre-implementation discipline — state assumptions explicitly, surface tradeoffs instead of hiding them, push back on unnecessary complexity, and write minimum code that solves the problem with no speculative features or premature abstractions.

Drives implementation through verifiable success criteria — transform vague tasks into testable goals, write reproduction tests before fixes, loop until criteria pass, checkpoint after every significant step, and declare uncertainty explicitly rather than silently proceeding.

Enforces surgical code modification discipline — touch only what the request requires, read full context before editing, match existing codebase conventions, clean up only your own orphans, and never refactor adjacent code that isn't broken.

Detects and prevents over-engineering by enforcing the KISS principle (Keep It Simple, Stupid) through code simplification, abstraction reduction, and preference for straightforward solutions.