← all publishers

ColdBox

@coldbox source repo

Report this profile Claim this profile

• 118 skills
• 0 followers
• 9 hours ago last updated

1. ▌
   Coldbox Layout Development · coldbox

   Use this skill when creating ColdBox layouts (master page templates), building admin layouts, creating reusable view partials, implementing nested content rendering with renderView(), switching layouts dynamically per handler, or organizing HTML structure around content views.
   0
   installs
2. ▌
   Coldbox Module Development · coldbox

   Use this skill when creating reusable ColdBox modules, writing ModuleConfig.cfc, defining module-specific routes, models, settings, and interceptors, packaging modules for ForgeBox, or building internal application sub-systems as modules.
   0
   installs
3. ▌
   Contentbox Cfml Multi Site · coldbox

   Use this skill when implementing or maintaining ContentBox multi-site setups, including domain/site resolution, site-specific content and themes, settings isolation, menu behavior, and operational best practices.
   0
   installs
4. ▌
   Commandbox Boxlang · coldbox

   Use this skill when configuring CommandBox to run BoxLang server instances, using the BoxLang REPL, running BoxLang task runners, and managing BoxLang modules via CommandBox. Covers server.json BoxLang configuration, CLI commands, module installation, and the BoxLang-specific CommandBox workflow.
   0
   installs
5. ▌
   Database Migrations · coldbox

   Use this skill when managing database schema changes in ColdBox/BoxLang using cfmigrations and commandbox-migrations. Covers migration file structure, Schema Builder API, seeding, and CLI workflows for creating, running, and rolling back migrations safely.
   0
   installs
6. ▌
   Coldbox Handler Development · 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.
   0
   installs
7. ▌
   Coldbox Routing Development · coldbox

   Use this skill when configuring ColdBox routes, setting up RESTful resource routes, creating route groups, implementing URL pattern matching with constraints, defining named routes, or working with Router.cfc in a ColdBox application.
   0
   installs
8. ▌
   Coldbox Testing Integration · coldbox

   Use this skill when writing integration tests for ColdBox that use real dependencies (database, WireBox, ColdBox context), testing full request/response cycles with execute(), setting up and tearing down test databases, testing services with real data, or using BaseTestCase for end-to-end handler tests with actual WireBox injections.
   0
   installs
9. ▌
   Coldbox Testing Interceptor · coldbox

   Use this skill when unit testing ColdBox interceptors in isolation using BaseInterceptorTest, accessing the pre-wired interceptor variable, leveraging mock helpers (mockController, mockRequestService, mockLogger, mockLogBox, mockFlash), configuring interceptor properties with configProperties, calling interceptor announce points directly, or scaffolding interceptor tests with CommandBox.
   0
   installs
10. ▌
    Contentbox Boxlang Overview · coldbox

    Use this skill when understanding ContentBox architecture, core modules, service layer, multi-site behavior, security foundations, and the recommended extension points for building or maintaining ContentBox solutions.
    0
    installs
11. ▌
    Cbsecurity Passkeys · coldbox

    Use this skill when implementing WebAuthn/Passkeys authentication in ColdBox/BoxLang using the cbsecurity-passkeys module. Covers the credential repository interface, registration ceremony, authentication ceremony, JavaScript integration, and production hardening for passwordless login.
    0
    installs
12. ▌
    Coldbox Security API Authentication · coldbox

    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.
    0
    installs
13. ▌
    Coldbox REST API Development · coldbox

    Use this skill when building RESTful APIs in ColdBox using RestHandler, creating CRUD API endpoints, implementing API versioning, handling JWT/bearer token authentication, building structured error responses, or creating resource representations with mementos.
    0
    installs
14. ▌
    Coldbox Testing Base Classes · coldbox

    Use this skill to understand which ColdBox testing base class to extend for a given test type, configure test bundle annotations (appMapping, configMapping, unloadColdBox, loadColdBox, coldboxAppKey), set up the tests/ harness (Application.cfc, folder structure), or choose between integration testing (BaseTestCase), isolated handler testing (BaseHandlerTest), model unit testing (BaseModelTest), and interceptor unit testing (BaseInterceptorTest).
    0
    installs
15. ▌
    Coldbox Testing HTTP Methods · 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).
    0
    installs
16. ▌
    Contentbox Cfml API Headless · 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.
    0
    installs
17. ▌
    Contentbox Boxlang Multi Site · coldbox

    Use this skill when implementing or maintaining ContentBox multi-site setups, including domain/site resolution, site-specific content and themes, settings isolation, menu behavior, and operational best practices.
    0
    installs
18. ▌
    Contentbox Cfml Content Types · coldbox

    Use this skill when implementing ContentBox content models and rendering flows, including entries/pages/content stores, custom fields, entity relationships, lifecycle callbacks, and content-type specific behaviors.
    0
    installs
19. ▌
    Commandbox Migrations · coldbox

    Use this skill when running database migrations from the CommandBox CLI using commandbox-migrations, including migrate up/down/reset/refresh, creating migration files, running seeders, and checking migration status. Covers CI/CD usage, configuration, and all CLI commands for cfmigrations.
    0
    installs
20. ▌
    Coldbox Security Passkeys · coldbox

    Use this skill when implementing passkeys (WebAuthn/FIDO2) passwordless authentication in ColdBox with cbsecurity-passkeys, configuring relying party settings, building passkey registration and authentication flows, managing passkey device storage, or adding biometric and hardware security key login support.
    0
    installs
21. ▌
    Coldbox Interceptor Development · coldbox

    Use this skill when creating ColdBox interceptors for cross-cutting concerns, listening to framework lifecycle events, implementing security checks, logging, CORS, rate limiting, request/response transformation, or firing and listening to custom interception points.
    0
    installs
22. ▌
    Contentbox Boxlang API Headless · 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.
    0
    installs
23. ▌
    Contentbox Cfml Admin Extension · coldbox

    Use this skill when extending the ContentBox admin UI with custom menus, views, interception points, editor integrations, workflows, and secure admin-only module behaviors.
    0
    installs
24. ▌
    Contentbox Boxlang Content Types · coldbox

    Use this skill when implementing ContentBox content models and rendering flows, including entries/pages/content stores, custom fields, entity relationships, lifecycle callbacks, and content-type specific behaviors.
    0
    installs
25. ▌
    Contentbox Cfml Media Management · coldbox

    Use this skill when implementing ContentBox media workflows, including uploads, storage abstraction with cbfs, image handling/resizing, media delivery patterns, and governance/security controls for assets.
    0
    installs
26. ▌
    Coldbox Security Implementation · coldbox

    Use this skill when setting up the full CBSecurity framework in ColdBox, configuring the security firewall, creating authentication services, implementing security event handlers, configuring security rules and validators, or building a complete security layer for a ColdBox application.
    0
    installs
27. ▌
    Contentbox Cfml Theme Development · coldbox

    Use this skill when creating or customizing ContentBox themes, including theme structure, metadata/settings, layout and view composition, collection templates, widget overrides, and theme lifecycle callbacks.
    0
    installs
28. ▌
    Contentbox Boxlang Admin Extension · coldbox

    Use this skill when extending the ContentBox admin UI with custom menus, views, interception points, editor integrations, workflows, and secure admin-only module behaviors.
    0
    installs
29. ▌
    Contentbox Cfml Module Development · coldbox

    Use this skill when building ContentBox modules, including ModuleConfig conventions, admin integration, interceptors, routes, migrations, ORM entities, dependency registration, and module lifecycle hooks.
    0
    installs
30. ▌
    Contentbox Cfml Widget Development · coldbox

    Use this skill when building ContentBox widgets, including BaseWidget patterns, render logic, dependency injection, editor metadata annotations, caching choices, and safe output/rendering practices.
    0
    installs
31. ▌
    Contentbox Boxlang Media Management · coldbox

    Use this skill when implementing ContentBox media workflows, including uploads, storage abstraction with cbfs, image handling/resizing, media delivery patterns, and governance/security controls for assets.
    0
    installs
32. ▌
    Contentbox Boxlang Theme Development · coldbox

    Use this skill when creating or customizing ContentBox themes, including theme structure, metadata/settings, layout and view composition, collection templates, widget overrides, and theme lifecycle callbacks.
    0
    installs
33. ▌
    Contentbox Cfml Security Permissions · coldbox

    Use this skill when implementing ContentBox security and permissions, including roles, permission modeling, cbSecurity integration, authorization checks, CSRF/rate-limiting protections, and hardening patterns.
    0
    installs
34. ▌
    Contentbox Boxlang Module Development · coldbox

    Use this skill when building ContentBox modules, including ModuleConfig conventions, admin integration, interceptors, routes, migrations, ORM entities, dependency registration, and module lifecycle hooks.
    0
    installs
35. ▌
    Contentbox Boxlang Widget Development · coldbox

    Use this skill when building ContentBox widgets, including BaseWidget patterns, render logic, dependency injection, editor metadata annotations, caching choices, and safe output/rendering practices.
    0
    installs
36. ▌
    Contentbox Boxlang Security Permissions · coldbox

    Use this skill when implementing ContentBox security and permissions, including roles, permission modeling, cbSecurity integration, authorization checks, CSRF/rate-limiting protections, and hardening patterns.
    0
    installs
37. ▌
    Contentbox Cfml Two Factor Authentication · coldbox

    Use this skill when implementing or customizing ContentBox two-factor authentication providers, trusted device flows, enrollment/verification UX, enforcement policies, and provider lifecycle handling.
    0
    installs
38. ▌
    Contentbox Boxlang Two Factor Authentication · coldbox

    Use this skill when implementing or customizing ContentBox two-factor authentication providers, trusted device flows, enrollment/verification UX, enforcement policies, and provider lifecycle handling.
    0
    installs
39. ▌
    Logbox · coldbox

    Use this skill whenever working with LogBox -- standalone or inside a ColdBox application. Covers installation, configuration DSL (appenders, root logger, categories), all built-in appender types with their properties, logger injection via WireBox DSL, category inheritance, structured logging with extraInfo, performance patterns (can{} methods, closure messages), custom appenders, custom layouts, async logging, environment-specific config, and production best practices.
    0
    installs
40. ▌
    Wirebox Di · coldbox

    Use this skill when working with WireBox dependency injection -- bootstrapping the injector, configuring binders, creating object mappings, using the injection DSL, setting persistence scopes, applying providers to avoid scope-widening, lazy properties, property observers, object delegation, virtual inheritance, child injectors, the object populator, or WireBox event listeners. Applies to both standalone and ColdBox-integrated usage.
    0
    installs
41. ▌
    Cachebox Standalone · coldbox

    Use this skill when working with CacheBox as a standalone caching framework (outside ColdBox) -- installing, creating and bootstrapping the CacheFactory, configuring the DSL, choosing object stores and eviction policies, selecting cache providers (CacheBoxProvider, CF, Lucee), implementing cache-aside/stampede-protection patterns, registering standalone listeners, named caches, disk/JDBC stores, reaping, shutdown, or monitoring cache performance.
    0
    installs
42. ▌
    Qb · coldbox

    Use this skill when building database queries with qb (Query Builder) in ColdBox/BoxLang. Covers QueryBuilder injection, select/from/where/join/group/order/limit clauses, aggregates, inserts, updates, deletes, raw expressions, sub-queries, chunking, and grammar configuration for MySQL, Postgres, MSSQL, and SQLite.
    0
    installs
43. ▌
    Cbq · coldbox

    Use this skill when implementing asynchronous background job processing in ColdBox/BoxLang with cbq. Covers job class creation, queue configuration (database, Redis, SQS), dispatching jobs, delayed dispatch, queue routing, retry handling, worker pool management, and monitoring patterns.
    0
    installs
44. ▌
    Testbox Bdd · coldbox

    Use this skill when writing BDD-style tests with TestBox using describe/it blocks, feature/story/scenario/given/when/then Gherkin-style suites, lifecycle hooks (beforeAll/afterAll/beforeEach/afterEach/aroundEach), focused specs (fit/fdescribe), skipping specs (xit/xdescribe/skip()), spec data binding, asyncAll parallel specs, nested suite trees, labels, or organizing tests around behavior descriptions.
    0
    installs
45. ▌
    Cbfs · coldbox

    Use this skill when working with the cbfs file system abstraction module in ColdBox/BoxLang applications. Covers installation, disk configuration (local, S3, RAM, FTP), CRUD file operations, streaming, URL generation, file uploads, directory listing, and multi-provider patterns for different environments.
    0
    installs
46. ▌
    Cors · coldbox

    Use this skill when configuring Cross-Origin Resource Sharing (CORS) for ColdBox/BoxLang REST APIs using the cors module. Covers allowed origins, methods, headers, credentials, preflight OPTIONS handling, dynamic origin functions, and production hardening.
    0
    installs
47. ▌
    Testbox Unit Xunit · coldbox

    Use this skill when writing xUnit-style tests in TestBox using test functions (testXxx()), setup/teardown lifecycle (beforeTests/afterTests/setup/teardown), $assert assertion object, or the Arrange-Act-Assert (AAA) pattern for unit testing services, models, and utilities in isolation.
    0
    installs
48. ▌
    Cborm · coldbox

    Use this skill when working with Hibernate ORM in ColdBox/BoxLang using the cborm module. Covers BaseORMService, VirtualEntityService, the Criteria Builder (restrictions, projections, joins, sub-queries, pagination), transaction management, event interceptions, and production patterns for data access layers.
    0
    installs
49. ▌
    Cbsso · coldbox

    Use this skill when implementing Single Sign-On (SSO) in ColdBox/BoxLang using the cbsso module. Covers SAML2 and OAuth2/OIDC configuration, the SSOService API, redirect-to-provider flow, callback processing, token validation, user provisioning on first login, and session management.
    0
    installs
50. ▌
    Hyper · coldbox

    Use this skill when making HTTP requests from ColdBox/BoxLang applications using the Hyper HTTP client. Covers HyperBuilder injection, fluent request construction, GET/POST/PUT/DELETE shortcuts, headers, authentication, timeout configuration, response handling, error handling, and production patterns for REST API integrations.
    0
    installs
51. ▌
    Quick · coldbox

    Use this skill when building Active Record-style database entities with Quick ORM in ColdBox, CFML, or BoxLang applications. Covers entity metadata, safe persistence, relationships, query scopes, eager loading, serialization, soft deletes, lifecycle events, and service boundaries.
    0
    installs
52. ▌
    Relax · coldbox

    Use this skill when modeling REST APIs with the Relax DSL, defining routes with parameters and response schemas, generating API documentation, and producing JSON/XML specification output for ColdBox-based REST services.
    0
    installs
53. ▌
    S3sdk · coldbox

    Use this skill when working with Amazon S3 (or S3-compatible storage) in ColdBox/BoxLang using the s3sdk module. Covers injection, bucket operations, object upload/download/delete, presigned URLs, metadata, ACLs, multipart uploads, and integration with cbfs or direct usage.
    0
    installs
54. ▌
    Bcrypt · coldbox

    Use this skill when working with BCrypt password hashing in ColdBox/BoxLang applications. Covers installation, work-factor configuration, hashing passwords, verifying credentials, generating salts, mixin helpers in handlers/interceptors, user registration, authentication, password change/reset, and security best practices for credential handling.
    0
    installs
55. ▌
    Cbauth · coldbox

    Use this skill when implementing user authentication with the cbauth module in ColdBox/BoxLang applications. Covers installation, IUserService and IAuthUser interfaces, session-based login/logout, manual login, authentication checks, CBStorages integration, Flash RAM messaging, and security patterns for credential handling.
    0
    installs
56. ▌
    Cbcsrf · coldbox

    Use this skill when adding CSRF protection to ColdBox/BoxLang applications with the cbcsrf module. Covers token generation, form helpers, AJAX/meta-tag patterns, manual handler validation, route exemptions, SPA integration, token rotation, and configuration best practices for preventing cross-site request forgery.
    0
    installs
57. ▌
    Cbi18n · coldbox

    Use this skill when adding internationalization (i18n) and localization (l10n) to a ColdBox/BoxLang application with the cbi18n module. Covers installation, resource bundle formats (.properties and JSON), locale management, translation helpers ($r / getResource), positional and named substitutions, multiple bundles, locale switching, and date/number formatting.
    0
    installs
58. ▌
    Cbwire · coldbox

    Use this skill when building reactive UI components in ColdBox/BoxLang with cbwire, a Livewire-inspired library. Covers wire components and templates, wire:model and wire:click directives, lifecycle hooks, computed properties, events, validation, file uploads, lazy loading, JavaScript integration, and the behavior traps that are hard to diagnose.
    0
    installs
59. ▌
    Coldbox Logging · coldbox

    Use this skill for all ColdBox-specific logging concerns: configuring LogBox inside a ColdBox application (config/LogBox.cfc, inline DSL, configFile pointer), per-environment log levels, injecting loggers into handlers/interceptors/services via the WireBox logbox DSL, accessing logbox from the ColdBox proxy, and logging best practices specific to the ColdBox lifecycle.
    0
    installs
60. ▌
    Cbfeeds · coldbox

    Use this skill when reading or generating RSS/Atom feeds in ColdBox/BoxLang using cbfeeds. Covers FeedReader for consuming external feeds, FeedGenerator for producing RSS 2.0 and Atom feeds, caching parsed feeds, and rendering feed XML from ColdBox handlers.
    0
    installs
61. ▌
    Rulebox · coldbox

    Use this skill when implementing a business rules engine in ColdBox/BoxLang using rulebox. Covers RuleEngine injection, defining rules with when/then/otherwise closures, named rule sets, chaining rules, running a rule set against a context, and production patterns for policy evaluation and workflow branching.
    0
    installs
62. ▌
    Testbox Mockbox · coldbox

    Use this skill when creating mocks, stubs, and spies in TestBox using MockBox: createMock(), createEmptyMock(), prepareMock(), stubbing methods with $(), chaining $args()/$results()/$throws(), verifying call counts with $once()/$never()/$times()/$atLeast()/$atMost(), reading call logs with $callLog(), injecting mock properties with $property(), simulating queries with querySim(), or spying on real methods with $spy().
    0
    installs
63. ▌
    Testbox Runners · coldbox

    Use this skill when running TestBox tests: CommandBox CLI (testbox run), BoxLang CLI (./testbox/run), HTML web runner, programmatic TestBox instantiation (run/runRaw/runRemote), configuring test directories or bundles, using the streaming runner (--stream flag / StreamingRunner), watcher mode, all CLI flags (--show-failed-only, --dry-run, --slow-threshold-ms, --stacktrace, --max-failures), or setting up box.json testbox configuration.
    0
    installs
64. ▌
    Cbproxies · coldbox

    Use this skill when creating dynamic Java-compatible proxies of ColdBox/BoxLang components using cbproxies. Covers ProxyFactory injection, creating proxies for Java interfaces, lazy-loading components, method interception, and integration with Java frameworks that require interface implementations (JDBC, Hibernate, Java threading, etc.).
    0
    installs
65. ▌
    Cbswagger · coldbox

    Use this skill when generating OpenAPI 3.x (Swagger) documentation for ColdBox/BoxLang REST APIs using cbswagger. Covers installation, module configuration, handler/action JSDoc annotations, request/response schemas, security definitions, parameter documentation, and accessing the generated spec.
    0
    installs
66. ▌
    Socketbox · coldbox

    Use this skill when building WebSocket features with SocketBox in ColdBox/CFML/BoxLang. Covers the real SocketBox APIs for core WebSocket handling and STOMP broker usage, including correct base classes, method signatures, server-side sends, and client examples.
    0
    installs
67. ▌
    Testbox Listeners · coldbox

    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.
    0
    installs
68. ▌
    Testbox Reporters · coldbox

    Use this skill when selecting or configuring TestBox reporters: ANTJunit, Console, Doc, JSON, JUnit, Min, MinText, Simple, Text, XML, Streaming; setting reporter options (hideSkipped, editor links for Simple reporter); or creating a custom reporter by implementing the IReporter interface.
    0
    installs
69. ▌
    Coldbox Decorators · 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.
    0
    installs
70. ▌
    Coldbox Di · coldbox

    Use this skill when working with dependency injection inside a ColdBox application -- the ColdBox injection DSL namespaces (coldbox:, logbox:, cachebox:, wirebox:, model:), module settings injection, injecting ColdBox services (interceptors, flash, router, scheduler), configuring the WireBox binder in ColdBox context, the enhanced ColdBox binder helpers, or wiring handlers/interceptors/models via ColdBox-aware WireBox.
    0
    installs
71. ▌
    Cbantisamy · coldbox

    Use this skill when sanitizing HTML/XML user input to prevent XSS attacks using the OWASP AntiSamy library via the cbantisamy module. Covers installation, policy selection (strict/relaxed/slashdot/ebay/myspace), custom XML policy files, fluent sanitization API, ColdBox validation integration, and safe rendering of rich user-generated HTML.
    0
    installs
72. ▌
    Cbdebugger · coldbox

    Use this skill when installing, configuring, or using the CBDebugger visual debugging panel in a ColdBox application. Covers enabling the panel in development, performance profiling, SQL query tracking, cache monitoring, request inspection, and ensuring the debugger is disabled in production.
    0
    installs
73. ▌
    Cbmarkdown · coldbox

    Use this skill when converting Markdown to HTML in a ColdBox/BoxLang application using the cbmarkdown module. Covers installation, injecting the Processor, converting Markdown strings to HTML, using in views, supported syntax (GFM, tables, code blocks), and security considerations for user-generated Markdown.
    0
    installs
74. ▌
    Cbmockdata · coldbox

    Use this skill when generating realistic fake seed/test data in ColdBox/BoxLang using the cbmockdata module. Covers installation, the mock() API, built-in data types, entity population, testing integration, and bulk generation patterns for prototyping and test suites.
    0
    installs
75. ▌
    Cbsecurity · coldbox

    Use this skill when securing ColdBox/BoxLang applications with cbsecurity. Covers firewall rule configuration, annotation-based security on handlers/actions, JWT authentication, role and permission checks, security context helpers, custom validators, interceptor events, and production hardening patterns.
    0
    installs
76. ▌
    Cbstorages · coldbox

    Use this skill when persisting data across requests in ColdBox/BoxLang using cbstorages. Covers Session, Cookie, Cache, Request, and Application storage adapters; configuration; get/set/exists/ delete/clear operations; encryption; TTLs; and patterns for shopping carts, user preferences, and API token caching.
    0
    installs
77. ▌
    Unleashsdk · coldbox

    Use this skill when implementing feature flags and gradual rollouts in ColdBox/BoxLang using the unleashsdk module. Covers UnleashClient configuration, isEnabled() checks, getVariant() for A/B testing, custom context, gradual rollout strategies, and production patterns for safe feature releases.
    0
    installs
78. ▌
    Testbox Assertions · coldbox

    Use this skill when using the TestBox $assert object for xUnit-style assertions: isTrue, isEqual, includes, isEmpty, key, instanceOf, throws, between, closeTo, lengthOf, match, null, typeOf, and others; registering custom assertion functions with addAssertions(); or using BoxLang dynamic assertion methods (assertIsTrue, assertBetween, etc.).
    0
    installs
79. ▌
    Testbox Cbmockdata · coldbox

    Use this skill when generating realistic fake/mock data in tests using cbMockData (WireBox ID: MockData@cbMockData): age, boolean, date, datetime, email, fname, lname, name, num, sentence, ssn, string, tel, uuid, url, words, lorem, baconlorem, imageurl, ipaddress, autoincrement, oneof, rnd/rand; generating arrays of objects, nested objects, arrays of values, or using custom supplier closures.
    0
    installs
80. ▌
    Coldbox App Layouts · coldbox

    Use this skill when choosing a ColdBox application layout (flat, boxlang, or modern), scaffolding a new ColdBox project, understanding project directory structure, deciding between app structure options, or migrating from one layout to another. Use when asked about flat layout, boxlang template, modern template, app structure, project skeleton, or web root separation.
    0
    installs
81. ▌
    Coldbox CLI · coldbox

    Use this skill when using the ColdBox CLI (CommandBox module) to scaffold applications, generate handlers, models, services, views, layouts, interceptors, modules, ORM artifacts, tests, or manage AI integration. Covers all `coldbox create` commands, language flags (BoxLang vs CFML), app skeleton selection, feature flags (--docker, --vite, --rest, --migrations, --ai), template token patterns, layout detection, and AI integration sub-commands.
    0
    installs
82. ▌
    Coldbox Event Model · coldbox

    Use this skill when working with the ColdBox event object (prc/rc), managing request collections, rendering views and data responses, handling redirects with relocate(), controlling HTTP status codes, or implementing event caching in ColdBox handlers.
    0
    installs
83. ▌
    Wirebox Aop · coldbox

    Use this skill when working with WireBox Aspect-Oriented Programming (AOP) -- activating the AOP engine (Mixer listener), creating method interceptor aspects, registering aspects via mapAspect(), binding aspects to classes and methods via bindAspect(), using the Matcher DSL (any, regex, mappings, instanceOf, annotatedWith, methods, returns), auto-aspect binding via classMatcher/methodMatcher annotations, the MethodInvocation API (proceed, getArgs, getTarget, getMethod), using built-in aspects (CFTransaction, HibernateTransaction, MethodLogger), and AOP in both standalone WireBox and ColdBox applications.
    0
    installs
84. ▌
    Cbpaginator · coldbox

    Use this skill when implementing server-side pagination in ColdBox/BoxLang using cbpaginator. Covers installation, Paginator service configuration, generating pagination metadata for APIs and views, integrating with QB QueryBuilder, rendering Bootstrap pagination controls, and building pageable collection responses.
    0
    installs
85. ▌
    Mementifier · coldbox

    Use this skill when serializing ColdBox/BoxLang ORM entities or model objects to structs/JSON using mementifier. Covers this.memento configuration, getMemento() usage, defaultIncludes/ defaultExcludes/neverInclude, computed properties via mappers, relationship serialization, named profiles, and production API response patterns.
    0
    installs
86. ▌
    Cbjavaloader · coldbox

    Use this skill when dynamically loading Java JAR libraries at runtime in a ColdBox application using cbjavaloader. Covers installation, classpath configuration, creating Java objects from JARs, reloading in development, and common use cases (PDF processing, Apache POI, image manipulation).
    0
    installs
87. ▌
    Cbmessagebox · coldbox

    Use this skill when displaying flash-scope messages (info, success, warning, error) in ColdBox/BoxLang views using the cbmessagebox module. Covers installation, setting messages in handlers, rendering in views/layouts, checking for messages, clearing messages, and Bootstrap-compatible output patterns.
    0
    installs
88. ▌
    Cbplaywright · coldbox

    Use this skill when writing end-to-end browser tests in ColdBox/BoxLang using the cbplaywright module (a Playwright wrapper). Covers test bundle setup, browser/page lifecycle, navigation, selectors, assertions, form interactions, screenshots, network interception, the Page Object pattern, and CI pipeline integration.
    0
    installs
89. ▌
    Cbvalidation · coldbox

    Use this skill when validating user input in ColdBox/BoxLang using cbvalidation. Covers constraint definitions, validate()/validateOrFail() calls, built-in validators, custom validators, shared constraint files, error handling in handlers, and integrating validation results with views and REST APIs.
    0
    installs
90. ▌
    Cfmigrations · coldbox

    Use this skill when managing database schema changes in ColdBox/BoxLang using cfmigrations and its Schema Builder. Covers migration file structure, the Schema Builder API (create/alter/drop tables, column types, indexes, foreign keys), seed files, and running migrations via CommandBox CLI.
    0
    installs
91. ▌
    Testbox Expectations · coldbox

    Use this skill when writing fluent expectations in TestBox using expect(), expectAll(), all built-in matchers (toBe, toBeTrue, toBeArray, toHaveKey, toThrow, toMatch, toBeBetween, toBeCloseTo, toInclude, etc.), the not operator (notToBe, notToBeEmpty, etc.), chaining multiple matchers on one expect(), creating custom matchers with addMatchers(), or using expectAll() over collections.
    0
    installs
92. ▌
    Coldbox Proxy · 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.
    0
    installs
93. ▌
    Coldbox Configuration · coldbox

    Use this skill when configuring a ColdBox application in ColdBox.cfc, setting up environments, managing module settings, defining datasources, configuring logging with LogBox, setting up caching with CacheBox, or wiring dependencies with WireBox settings.
    0
    installs
94. ▌
    Coldbox Testing Model · coldbox

    Use this skill when unit testing ColdBox model objects (services, repositories, entities, or utility classes) in isolation using BaseModelTest, accessing the pre-wired model variable, leveraging the built-in mock helpers (mockLogger, mockLogBox, mockCacheBox, mockWireBox), calling model.init() to initialize the component, mocking injected properties with prepareMock(), or scaffolding model tests with CommandBox.
    0
    installs
95. ▌
    Coldbox AI Integration · coldbox

    Use this skill when integrating AI capabilities into a ColdBox application using the BoxLang AI library (bx-ai module) -- including simple chat, streaming, pipelines, agents, RAG with vector memory, document loading, tool calling, and injecting the AI service into handlers or models.
    0
    installs
96. ▌
    Coldbox View Rendering · coldbox

    Use this skill when rendering views and partials in ColdBox, creating reusable view components, caching view output, passing data to views, rendering views from services, using renderView() inline, or dynamically selecting views based on context.
    0
    installs
97. ▌
    Cbmailservices · coldbox

    Use this skill when sending email from a ColdBox/BoxLang application using cbmailservices. Covers installation, SMTP/Postmark/SendGrid protocol configuration, fluent mail builder API, body templates, token replacement, attachments, CC/BCC/replyTo, async sending, and production best practices.
    0
    installs
98. ▌
    Coldbox Security Authorization · coldbox

    Use this skill when implementing authorization in ColdBox with CBSecurity, defining security rules for events and URLs, checking user roles with cbsecurity.has(), checking permissions with cbsecurity.can(), implementing role-based route protection, using @secured annotations on handler actions, or blocking unauthorized access.
    0
    installs
99. ▌
    Coldbox Security Rbac · coldbox

    Use this skill when implementing Role-Based Access Control (RBAC) in ColdBox, creating role and permission management services, building hierarchical role structures, assigning roles and permissions to users, checking permissions in handlers with cbsecurity, or when designing a group-based access control system.
    0
    installs
100. ▌
     Coldbox Flash Messaging · coldbox

     Use this skill when implementing flash RAM messaging in ColdBox, using cbMessageBox for styled notifications, building POST-REDIRECT-GET patterns, persisting messages across redirects, showing success/error/warning/info alerts, or integrating flash with form validation.
     0
     installs