Skills Directory
Reusable, audited skills for BoxLang & the Ortus ecosystem.
Use this skill when implementing TestBox run listeners (callbacks): onBundleStart, onBundleEnd, onSuiteStart, onSuiteEnd, onSpecStart, onSpecEnd; building progress indicators, custom loggers, or live dashboards that react to test lifecycle events; or passing listener callbacks to TestBox's run(), runRaw(), or the standalone runner.
coldbox
Use this skill when simulating HTTP requests in ColdBox tests using the get(), post(), put(), patch(), delete(), or request() methods, setting request headers (Authorization, Accept, Content-Type), sending JSON request bodies, asserting response status with toHaveStatus(), checking validation errors with toHaveInvalidData(), or understanding the difference between execute() (event-based) and the HTTP method helpers (route/URL-based).
coldbox
Use this skill when configuring DocBox to generate API documentation, choosing output strategies (HTML, JSON, UML, CommandBox), setting up single or multiple source directories, running DocBox from BoxLang CLI or CommandBox CLI, customizing HTML themes, excluding files/folders from output, or building custom output strategies.
Use this skill when implementing API key authentication in ColdBox REST APIs, generating and validating API keys, caching API key lookups with CacheBox, implementing bearer token middleware, managing API key scopes and revocation, or adding an API key interceptor to protect REST endpoints.
Use this skill when reviewing ColdBox application code for correctness, security, performance, testability, and adherence to ColdBox conventions. Covers handlers, services, models, interceptors, modules, routing, ORM/OBM usage, REST APIs, dependency injection patterns, and common anti-patterns to flag during pull request reviews.
coldbox
Use this skill when extending or overriding ColdBox framework internals via the Decorator pattern -- specifically creating a ControllerDecorator to wrap the main ColdBox controller, or a RequestContextDecorator to wrap and augment the request context (event) object with custom methods or overridden behavior.
coldbox
Use this skill when implementing headless ContentBox APIs, including REST endpoint design, JWT authentication flows, content CRUD, custom API handlers, and integration patterns for decoupled frontends.
Use this skill when extending the ContentBox admin UI with custom menus, views, interception points, editor integrations, workflows, and secure admin-only module behaviors.
coldbox
Use this skill when building ColdBox Proxy objects to expose ColdBox event handlers to remote callers such as ColdFusion web services, Flex/AIR, event gateways, or CFC data binding -- enabling non-HTTP protocols to participate in the ColdBox event model.
coldbox
Use this skill when building async pipelines, working with ColdBox Futures, running parallel computations with all()/allApply()/anyOf(), registering and managing thread-pool executors, or accessing the AsyncManager via the async() helper.
coldbox
Use this skill when creating ColdBox handlers (controllers), implementing CRUD actions, adding dependency injection to handlers, working with preHandler/postHandler advices, secured actions, REST handlers, or the EventHandler base class.
coldbox
Use when writing integration tests that require real infrastructure dependencies such as databases, message brokers, caches, cloud service emulators, or any Dockerized service. Invoke for container lifecycle management, reusable containers, network configuration, wait strategies, custom images, and Testcontainers modules for PostgreSQL, MySQL, Kafka, Redis, LocalStack, and more.
ortus-solutions
Use when mocking, stubbing, spying, or verifying collaborator behavior in Java unit tests. Invoke for mock creation, argument matchers, stubbing strategies, verification, argument captors, answer implementations, strict stubbing, spy objects, and Mockito extensions with JUnit 5.
ortus-solutions
Use when writing, reviewing, or structuring JUnit 5 tests for Java applications. Invoke for test lifecycle, parameterized tests, test extensions, assertions, test organization, parallel execution, test suites, dynamic tests, and integration with build tools.
ortus-solutions
Use when building or scaling Vue applications with maintainable component architecture, robust state management, and performance-aware rendering. Invoke for Composition API patterns, routing, forms, testing, and SSR-aware component design.
ortus-solutions
Use when implementing or reviewing Java services, libraries, and backend systems with modern language features and JVM best practices. Invoke for API design, concurrency, performance profiling, dependency management, testing strategy, and production hardening.
ortus-solutions
Use when designing or refactoring TypeScript code for strong type safety, API clarity, and scalable project architecture. Invoke for strict mode adoption, generics design, inference improvements, declaration patterns, and safe migration from JavaScript.
ortus-solutions
Use when building or maintaining Vite-based frontend applications that need fast local development, reliable production builds, optimized asset pipelines, or plugin-level customization. Invoke for HMR issues, build performance, code splitting, environment handling, Vitest integration, and Vite config refactors.
ortus-solutions
Use when building or modernizing Bootstrap-based interfaces that need consistent layout systems, reusable components, and accessible behavior. Invoke for grid architecture, utility usage, theme customization, migration planning, and Bootstrap JavaScript integration.
ortus-solutions
Use when producing or improving developer-facing documentation for codebases, APIs, modules, and architecture decisions. Invoke for inline comments, docstrings, API references, onboarding guides, runbooks, and consistency audits across documentation assets.
ortus-solutions
Use when implementing or reviewing Alpine.js behavior in server-rendered or progressively enhanced UIs. Invoke for component state design, directives, event handling, transition behavior, reusable stores, and maintainable lightweight interactivity.
ortus-solutions
Use when implementing or reviewing modern JavaScript for correctness, readability, performance, and runtime safety across browser and Node environments. Invoke for async flows, module design, data transformation, error handling, and architectural refactors.
ortus-solutions
Use when performing high-signal code reviews focused on correctness, security, maintainability, performance, and test coverage risk. Invoke for pull request review, architecture drift detection, bug risk assessment, and actionable feedback with severity-ranked findings.
ortus-solutions
Use when designing, implementing, or refactoring Tailwind CSS systems for consistency, scale, and performance. Invoke for utility composition, design tokens, theme extension, responsive strategy, accessibility styling, and class management patterns.
ortus-solutions