Joomla Packaging Engine Skills guides agents from an application request to a complete, stable, runnable Joomla extension ready for deployment on the agreed target. The workflow covers requirements, reusable entities, custom PHP behaviour, compilation, installed validation and final delivery, with maintainable JCB source throughout. Start with the request-to-extension workflow; use the model routes below for a focused change.
Build in JCB from the start. Author native records and Powers, compile and validate in Playground. Do not manufacture an external component or scaffold to feed to Extrusion; that route is for genuinely pre-existing migration inputs. See the native authoring boundary for supported definition-repository and MCP routes.
New to JCB? The short native concept map explains how Fields and backend Admin Views define data, Dynamic Gets retrieve it, and frontend Site Views or backend Custom Admin Views present it through Templates and Layouts. Start there before selecting from the task routes.
Use the latest JCB for new work, resolving the current production release when the build begins. Development tasks can use the latest alpha/beta channel. Historical source hashes document inspected behavior; they do not lock the skills to that release. Follow the version policy.
Real component builds drive improvement. If following the skills fails to produce the requested outcome or requires an undocumented workaround, report the problem in the Skills repository. Maintainers use those reports to improve the instructions, examples and tools.
The official JoomEngine skills repository provides operational guidance for agents working across the Joomla Component Builder (JCB) ecosystem. Use SKILL.md as the concise task router, then load only the relevant module, reference and workflow. This repository explains how to locate authoritative sources, make consistent changes and verify the result; it complements JCB source code and its architecture publication.
Start with SKILL.md and AGENTS.md, then follow the relevant task below. Focused skill entry points cover Super Powers, Field Types, Snippets, Packages and shared Playground integration. Consult the skill registry for entry points and the module registry for scope and verification status. Follow the loading guide to supply a complete portable distribution to an agent.
A starting prompt can be as simple as: “Use https://github.com/joomengine/skills to build my Joomla component in Playground. It must manage equipment, borrowers and loans, prevent overlapping loans, and give me the extension installer and a complete site I can import.” Add an existing Joomla MCP connection when that is the intended environment. The agent discovers available capabilities, asks only for consequential missing requirements, and follows the application workflow through delivery. No local JCB server is required for the browser Playground path.
| Task | Read next |
|---|---|
| Build an extension from a user's application requirements | Request-to-extension workflow |
| Reuse an existing entity or create an independent adaptation | Entity reuse and dependency acquisition |
| Design portable application keys and modal relationships | Application identities, modal relationships |
| Store subform children in their own tables and Admin Views | Normalized subforms |
| Load page data and related collections through JCB | Dynamic Get recipe |
| Reuse a complete file uploader, image cropping and display feature | Files and images |
| Locate reusable features in Demo, Service Directory and JCB | Reference pattern catalogue |
| Trace generated code to its GUI field and maintain readable source | Compiler tracing, authored code standard |
| Select the correct import mechanism | Import router |
| Understand repository operations and limit Push destinations | Operations overview, publication preflight |
| Add algorithms, integrations and clean PHP classes to an extension | PHP customization and class placement |
| Reference supported Joomla classes through JPK | Joomla Powers skill |
| Author on the user's Joomla/JCB installation through MCP | MCP setup, discovery and execution |
| Hand over a compiled extension, blueprint or complete site | Delivery and verified restoration |
| Try a small, intermediate or e-commerce application request | Worked scenarios and outcomes |
| Check what an independent agent has actually demonstrated | Scenario acceptance and execution ledger |
| Discover official repository families across the code distributed network | Ecosystem catalogue |
| Understand, create, extend, maintain, or debug a Super Power repository | Super Powers skill |
| Create or maintain Field Types, research Joomla properties/defaults, or override a core definition | Field Types skill |
| Create or maintain reusable view snippets and their classifications | Snippets skill |
| Create or maintain component, module or plugin blueprint repositories | Packages skill |
| Find a package sub-model or exact serialized field | Model router, contract inventory |
| Build a package in JCB's GUI and Push its source to an authorized branch | Playground authoring and export |
| Test an implementation in browser-hosted JCB, compile it and inspect its output | Playground integration workflow |
| Choose Joomla/PHP versions, deployment and initial URL path | Playground configuration |
| Report a build outcome or missing/incorrect skill guidance | Skills feedback and issue reporting |
| Select current JCB releases and interpret historical source references | Latest-version policy |
| Find the right JCB architecture context | Architecture map |
| Add another operational module to this repository | Module authoring standard |
| Discover monitored core mirrors, reduce GitHub reads or recover source access | Repository network workflow |
| Check registered Power repositories and their roles | Power repository registry |
| Find the official Field Types baseline and additional catalogue rules | Field Type repository registry |
| Find the official Snippets baseline and additional catalogue rules | Snippet repository registry |
| Determine documented scope and validation status | Module registry |
| Run the repository checks | Validation tools |
JCB performs the heavy lifting through reusable authoring records and its compiler. Pull a suitable Field, Admin View, presentation feature or whole blueprint with its dependencies, then adapt the necessary parts. The reference catalogue connects focused Demo patterns and advanced Service Directory composition to practical recipes. These components demonstrate techniques; their business models are not universal application requirements.
JCB deliberately offers advanced authors freedom without restrictive architectural guardrails. The skills teach sound choices within that freedom: use generated retrieval and persistence where they fit, compose Templates and Layouts, and write readable custom behaviour for the application's remaining needs.
- Research Joomla core/framework solutions for the supported versions first.
- Search joomengine/super-powers, the central shared foundation and reference standard for JCB-owned reusable classes.
- Search relevant specialist Power repositories.
- Implement new code when the existing capabilities do not adequately satisfy the requirement; record the concrete reason.
Reuse is a design decision, not a requirement to inherit from an unsuitable class. Preserve cohesive responsibilities, dependency injection, established public contracts, and portable Power metadata. Shared foundational changes require review of their consumers.
Prefer immutable GUIDs for relationships between new application entities. Keep Joomla numeric primary keys and distinguish application identities from JCB definition GUIDs and business keys such as SKU. Stable keys make data exchange and multi-database integration easier; database replication, conflict resolution and synchronization still need their own implementation. Preserve deliberate existing ID-based contracts unless a migration is requested. See application identities.
joomengine/joomla-fieldtypes is the official core Field Types repository. joomengine/snippets is the official core Snippets repository. Additional repositories can extend those catalogues or intentionally override the same existing items.
Every repository must account for its domain's current core catalogue when allocating a new GUID, as well as additional configured catalogues and local unpublished records. Preserve the original GUID when improving or overriding the same item; generate a fresh collision-checked identity for a distinct new item. Retain source provenance and effective repository order so intentional overrides are visible rather than silently replacing unrelated definitions.
These are different entity formats. A Field Type describes the foundation and configurable properties of concrete fields; a Snippet supplies reusable source content. Use the relevant module's contract instead of copying Super Power file layouts or settings into them.
Use the maintained repository network for core-source discovery and alternative read transports. Its live target list expands over time; preserve canonical identity and record the actual mirror and revision. joomengine/packages is the default Package repository.
The Playground agent guide in this repository is the canonical guide for using Playground to build Joomla extensions. Playground's runtime Agent link points here. Documentation for developing Playground itself stays in the Playground repository; link to the relevant technical reference when needed instead of maintaining a second agent workflow there.
JoomEngine Playground is the default integration route for agents with browser access working on executable JCB changes. It runs Joomla, PHP and MariaDB in the browser and supplies a JCB deployment, so an agent can configure a repository's target and read branch, import candidate definitions, inspect their local records, compile a real consumer and exercise the generated extension. Respect user opt-outs and declared target versions. Static checks still run; an unavailable browser or unsupported target must be recorded as an unrun integration stage.
Start with the Playground skill, then the relevant module's acceptance procedure. Powers require a real class reference and caller; Field Types require concrete Fields and generated form/storage checks; Snippets require copied view content, assets and rendered behaviour; Packages require the root's actual component/module/plugin graph and generated consumers. The shared receipt and each module's verification record distinguish completed stages from remaining checks. The configuration reference documents current version choices, URL parameters and platform limits; future Joomla or development releases become test targets only when the actual Playground supports them.
These operational modules document parts of JCB's blueprint and compilation lifecycle. Import success proves one part of that lifecycle. The intended end-to-end test follows the maintained definition through compilation into an installed, exercised extension, with a separate result for each stage.
Read the module entry point, the contract sections relevant to the change, and its workflow. Follow source links when a claim depends on version-specific behaviour or when evidence has changed. Use examples to understand the format; do not copy their identities into distinct new records.
The documentation distinguishes project policy, implementation behaviour verified at a recorded revision, observed examples, and known gaps. Static validation, JCB import/compilation, and application runtime checks are separate levels of evidence. A check at one level never silently certifies the others.
For an agent working in another repository, follow the loading and distribution guide. Keep shared tools and references with the model entry points; register the complete distribution when the client supports skills, or supply its path/URL explicitly. An agent will not necessarily discover these instructions automatically. The repository name change does not install capabilities or grant publication access.
This repository's original CC0 license is retained. Source examples retain their original attribution and licensing; the repository license does not relicense third-party material.