AI Agent Skills Marketplace
Showing 24 of 24 results
local-jev
Make Laya trustworthy. Fit its confidence to your own labeled data, keep the decisions it gets right local and free on Apple Silicon, and send only the ones it does not know to hosted Jev (TypeSafe System One) or any OpenAI-compatible LLM. Includes a Jev-compatible local server (laya-mlx), per-type temperature calibration with before/after ECE and accuracy, confidence thresholds for a target accuracy, an escalation-rate and cost report, a fail-open TypeScript decide() client, and a playbook to find LLM calls that are really classifications. Use for ticket routing, yes/no gates, rubric scores, replacing prompt-and-parse LLM classification, cutting Jev or LLM spend, and private offline typed decisions.
Project Sentinel - Multi-Project Development Progress Tracker
ENHE Project Sentinel is a local-first, read-only Skill for tracking multiple development projects. It reads authorized Git repositories, project documents, reports, quality signals, and available Codex usage data to generate bilingual project portfolio reports. Reports include progress, elapsed development time, ETA ranges, risks, quality signals, Codex context, token usage, next actions, and agent-ready prompts. It is designed for indie developers, AI product builders, product owners, and small R&D teams. Supports Windows 10/11. By default, it does not modify project code or upload source code, and it clearly marks insufficient evidence instead of inventing precise ETAs.
mesh flow
What it does Mesh Flow replaces fragile, implicit prompt-chaining with a robust, artifact-driven DAG (Directed Acyclic Graph) orchestration system. By defining your agent workflows in a structured project.yaml, you move logic out of the prompt and into a compile-time validated system. It enforces hard gates—such as human approval or dependency verification—that the AI cannot bypass or hallucinate past. Why use this skill Standard agentic workflows often fail because the LLM decides to skip steps or "forgets" requirements. Mesh Flow treats your agentic workflow like a CI/CD pipeline. It features a Compile-then-Run architecture that validates your topology for cycles and missing artifacts before single token is generated. This ensures 100% predictable execution paths, explicit failure states (failed, blocked, rejected), and absolute control over recovery paths. Supported tools YAML-based workflow configurations Standardized Adapter Interfaces for cross-skill communication Mermaid DAG visualization for debugging Zod-backed schema validation CLI tools for compilation and execution (mesh compile, mesh run) Output structure The skill produces a normalized execution plan and a detailed execution trace. Every node execution returns a standardized status, a list of produced artifacts, and comprehensive metadata including tool calls and verification reasoning. Use Cases Build multi-step agent pipelines with hard verification gates Enforce human-in-the-loop approval before sensitive code deployments Visualize complex agent task dependencies using Mermaid DAGs Standardize artifact sharing between disparate AI skills and agents
harness-engineering
The Harness Engineering skill implements a structured methodology for agent orchestration. It allows you to build sophisticated control loops using a multi-role architecture: Planner: Defines contracts and stop rules. Executor: Performs bounded actions. Verifier: Validates results against evidence. Critic/Recovery: Identifies regressions and manages error state.
prompt-engineer-pro
Prompt Engineer Pro is a production-grade system for teams shipping AI workflows into business-critical environments. Unlike basic prompting assistants, this skill treats prompts as software assets that require governance, audit trails, and regression testing. It helps you build, audit, and harden prompt stacks for complex tasks involving multiple models, tool-use agents, and structured data extraction.
SEO & AEO Auditor
Deep SEO + AEO auditor that transforms any codebase into a search and AI visibility powerhouse. Runs 102 checks across 8 categories: technical SEO, content SEO, structured data, AEO readiness, AI crawler strategy, llms.txt, performance (Lighthouse + PageSpeed Insights), and content gap analysis. Generates schema markup, llms.txt, robots.txt AI directives, and FAQ patterns. Scores your site 0-100, then fixes what you approve. Built for developers using Claude Code.
Git Commit Assistant
Writes structured, conventional commit messages from git diff output. Supports Conventional Commits, semantic versioning, and project-specific commit styles.
Code Review Agent
Comprehensive code review with security, performance, and style analysis for Python, TypeScript, and Go. Detects OWASP Top 10 vulnerabilities, N+1 queries, race conditions, and logic errors before they reach production.
prompt-engineer-lite
Building high-performance LLM applications requires more than just basic instructions. This skill equips your AI agent with a sophisticated framework for designing, debugging, and optimizing prompts across any major model provider. It solves the common problems of model drift, parsing failures, and hallucination by implementing industry-standard engineering patterns.
PR Description Generator
Generates comprehensive, structured PR descriptions from git diff or branch comparison. Includes summary, changelog, testing notes, and deployment considerations.
flutter-add-integration-test
# Implementing Flutter Integration Tests ## Contents - [Project Setup and Dependencies](#project-setup-and-dependencies) - [Interactive Exploration via MCP](#interactive-exploration-via-mcp) - [Test Authoring Guidelines](#test-authoring-guidelines) - [Execution and Profiling](#execution-and-profiling) - [Workflow: End-to-End Integration Testing](#workflow-end-to-end-integration-testing) - [Examples](#examples) ## Project Setup and Dependencies Configure the project to support integration testing and Flutter
unit-test-bean-validation
# Unit Testing Jakarta Bean Validation ## Overview This skill provides executable patterns for unit testing Jakarta Bean Validation annotations and custom validators using JUnit 5. Covers built-in constraints (`@NotNull`, `@Email`, `@Min`, `@Max`, `@Size`), custom `@Constraint` implementations, cross-field validation, and validation groups. Tests run in isolation without Spring context. ## When to Use - Writing unit tests for Jakarta Bean Validation or JSR-380 constraints - Testing custom `@Constraint` vali
spring-boot-test-patterns
# Spring Boot Testing Patterns ## Overview Comprehensive guidance for writing robust test suites for Spring Boot applications using JUnit 5, Mockito, Testcontainers, and performance-optimized slice testing patterns. ## When to Use - Writing unit tests for services or repositories with mocked dependencies - Implementing integration tests with real databases via Testcontainers - Testing REST APIs with `@WebMvcTest` or MockMvc - Configuring `@ServiceConnection` for container management in Spring Boot 3.5+ ## Q
unit-test-service-layer
# Unit Testing Service Layer with Mockito ## Overview Provides patterns for unit testing `@Service` classes using Mockito. Mocks repository calls, verifies method invocations, tests exception scenarios, and stubs external API responses. Enables fast, isolated tests without Spring container or database. ## When to Use - Testing business logic in `@Service` classes - Mocking repository and external client dependencies - Verifying service interactions with mocked collaborators - Testing error handling and edge
unit-test-wiremock-rest-api
# Unit Testing REST APIs with WireMock ## Overview Patterns for testing external REST API integrations with WireMock: stubbing responses, verifying requests, error scenarios, and fast tests without network dependencies. ## When to Use - Testing services calling external REST APIs - Stubbing HTTP responses for predictable test behavior - Testing error scenarios (timeouts, 5xx errors, malformed responses) - Verifying request details (headers, query params, request body) ## Instructions 1. **Add dependency**:
unit-test-controller-layer
# Unit Testing REST Controllers with MockMvc ## Overview Provides patterns for unit testing `@RestController` and `@Controller` classes using MockMvc. Covers request/response handling, HTTP status codes, request parameter binding, validation, content negotiation, response headers, and exception handling with mocked service dependencies. ## When to Use Use for: controller tests, API endpoint testing, Spring MVC tests, mock HTTP requests, unit testing web layer endpoints, verifying REST controllers in isolati
unit-test-parameterized
# Parameterized Unit Tests with JUnit 5 ## Overview Provides patterns for parameterized unit tests in Java using JUnit 5. Covers `@ValueSource`, `@CsvSource`, `@MethodSource`, `@EnumSource`, `@ArgumentsSource`, and custom display names. Reduces test duplication by running the same test logic with multiple input values. ## When to Use - Writing JUnit tests with multiple input combinations - Implementing data-driven tests in Java - Running same test with different values (boundary analysis) - Testing multiple
unit-test-utility-methods
# Unit Testing Utility Classes and Static Methods ## Overview This skill generates tests for utility classes with static helper methods and pure functions. It provides patterns for testing null handling, edge cases, boundary conditions, and common utilities like string manipulation, calculations, data validation, and collections. Pure functions require no mocking. ## When to Use Use this skill when: - Writing tests for utility/helper classes with static methods - Testing pure functions with no state or side
unit-test-exception-handler
# Unit Testing ExceptionHandler and ControllerAdvice ## Overview This skill provides patterns for writing unit tests for Spring Boot exception handlers. It covers testing `@ExceptionHandler` methods in `@ControllerAdvice` classes using MockMvc, including HTTP status assertions, JSON response validation, field-level validation error testing, and mocking handler dependencies. ## When to Use - Writing unit tests for `@ExceptionHandler` methods - Testing `@ControllerAdvice` global exception handling - Validatin
unit-test-mapper-converter
# Unit Testing Mappers and Converters ## Overview Provides patterns for unit testing MapStruct mappers and custom converter classes. Covers field mapping accuracy, null handling, type conversions, nested object transformations, bidirectional mapping, enum mapping, and partial updates. ## When to Use - Writing mapping tests for MapStruct mapper implementations - Testing custom entity-to-DTO converters and bean mappings - Validating nested object mapping and collection transformations ## Instructions ### 1. V
unit-test-caching
# Unit Testing Spring Caching ## Overview This skill provides patterns for unit testing Spring caching annotations (`@Cacheable`, `@CacheEvict`, `@CachePut`) without full Spring context. It covers cache hits/misses, invalidation, key generation, and conditional caching using in-memory `ConcurrentMapCacheManager`. ## When to Use - Writing unit tests for `@Cacheable` method behavior - Verifying `@CacheEvict` cache invalidation works correctly - Testing `@CachePut` cache updates - Validating cache key generati
unit-test-application-events
# Unit Testing Application Events ## Overview Provides actionable patterns for testing Spring `ApplicationEvent` publishers and `@EventListener` consumers using JUnit 5 and Mockito — without booting the full Spring context. ## When to Use - Writing unit tests for event publishers or listeners - Verifying that an event was published with correct payload - Testing `@EventListener` method invocation and side effects - Testing event propagation through multiple listeners - Validating async event handling (`@Asy
provider-test-patterns
# Provider Acceptance Test Patterns Patterns for writing acceptance tests using [terraform-plugin-testing](https://github.com/hashicorp/terraform-plugin-testing) with the [Plugin Framework](https://github.com/hashicorp/terraform-plugin-framework). Source: [HashiCorp Testing Patterns](https://developer.hashicorp.com/terraform/plugin/testing/testing-patterns) **References** (load when needed): - `references/checks.md` — statecheck, plancheck, knownvalue types, tfjsonpath, comparers - `references/sweepers.md`
k6-perf-test-website
# `k6-perf-test-website` An end-to-end, opinionated workflow for performance-testing any public website with k6. The skill produces: - A scaffolded project with one folder per user-described workflow. - Functional protocol + browser tests (must pass before load testing). - Hybrid load tests (protocol scenario + 1 browser VU) per test type (smoke / average / stress / spike / soak / breakpoint). - SLO-backed thresholds with per-endpoint tagging and Web Vitals. - A cross-platform load-generator monitor sidecar