DEVELOPER MODULE — TOOLS
WordPress Module Builder — Create Custom Plugins With AI-Powered Code Generation
Build production-ready LuperIQ modules from inside the WordPress admin using a step-by-step wizard and the Qwen3 AI model. Describe what you want in plain English, preview every generated file, build with one click, and activate or download the result as a ZIP. DevKit turns module development from a multi-day coding project into a guided conversation.
Writing WordPress Modules by Hand Is Slow and Error-Prone
Creating a new LuperIQ module requires a specific directory structure, a module.json manifest, properly namespaced PHP classes, admin page registrations, AJAX handlers, asset enqueues, and activation hooks. Getting the boilerplate right takes hours before you write a single line of business logic. A missing hook priority, a typo in the namespace, or a malformed manifest means the module silently fails to load.
DevKit eliminates that friction. It provides a visual builder wizard inside the WordPress admin that walks you through every decision — module name, description, version, admin pages, features, and dependencies. When you finish the wizard, DevKit sends your specification to the Qwen3 AI model, which generates every file in the module: PHP classes, JavaScript, CSS, manifest, and directory tree. You preview the result, click Build, and the module is installed and ready to activate.
Every Feature in the DevKit Module
Step-by-Step Module Builder
Guided 5-Step Wizard
The builder walks you through module configuration in five sequential steps: basic information (name, slug, version, description), admin page definitions, feature selection, AI generation prompt, and file preview. Each step validates input before advancing to the next.
AI-Powered Code Generation
Qwen3 Language Model
DevKit sends your module specification to the Qwen3 AI model as a structured prompt. The AI generates complete PHP classes with proper namespacing, admin page controllers, AJAX endpoint handlers, JavaScript files, CSS stylesheets, and a fully populated module.json manifest. Generation runs asynchronously over AJAX so the browser stays responsive.
AI Wizard Assistant
Contextual Help at Every Step
Each step of the builder includes an AI assistant panel. Ask questions about LuperIQ module architecture, get suggestions for admin page layouts, or request explanations of specific hooks and filters. The assistant uses the same Qwen3 model and is aware of your current builder context, so answers are specific to the module you are building.
File Preview Before Build
Inspect Every Generated File
After AI generation completes, a full file tree is displayed with syntax-highlighted previews. You can review every PHP class, JavaScript file, CSS stylesheet, and the module.json manifest before committing to the build. If something needs adjustment, return to earlier wizard steps, modify your specification, and regenerate.
One-Click Build and Activate
Instant Module Installation
When you are satisfied with the preview, click Build. DevKit writes the generated files to the LuperIQ modules directory, registers the module with the framework, and offers immediate activation. The entire process from prompt to running module takes minutes, not days.
ZIP Export and Download
Portable Module Packaging
Every generated module can be downloaded as a ZIP archive directly from the builder or the My Modules gallery. The ZIP contains the complete directory structure ready to be uploaded to another LuperIQ installation or shared with a development team.
My Modules Gallery
Manage All Created Modules
The My Modules page lists every module you have built with DevKit. Each entry shows the module name, version, status (active or inactive), and creation date. From this page you can toggle activation, reload a module into the builder for editing, download the ZIP, or delete the module entirely.
Marketplace Submission
Publish to the LuperIQ Marketplace
Submit your generated module to the LuperIQ marketplace directly from the admin. DevKit handles packaging, metadata extraction from module.json, and the submission API call. Once approved, your module becomes available to every LuperIQ user.
Release Tracking
Version History for Every Module
DevKit tracks each build as a versioned release. When you modify a module and rebuild, the previous version is preserved. The release history shows timestamps, version numbers, and change notes so you can track how a module evolved over time.
Credits System
Token-Based AI Usage
AI generation consumes credits from your LuperIQ account. The credits balance is displayed in the builder before you generate, and each generation deducts based on the complexity of the request. Credits can be purchased or earned through marketplace activity.
AJAX-Powered Async Workflows
Non-Blocking Background Processing
Every long-running operation in DevKit — AI generation, module building, ZIP packaging, and marketplace submission — runs asynchronously over AJAX. Progress indicators keep you informed while the browser remains interactive. Failed operations surface clear error messages with retry options.
Module Management Tools
Load, Toggle, and Organize
Beyond the builder, DevKit provides administrative tools for managing any module in the LuperIQ ecosystem. List all installed modules, toggle activation state, inspect module.json metadata, and check dependency graphs from a single admin interface.
Who This Module Is Built For
Anyone who needs to create, customize, or extend LuperIQ functionality — whether you write PHP daily or have never opened a code editor.
WordPress Developers and Agencies
- Skip the boilerplate and generate the scaffolding for new modules in minutes instead of hours. Focus your time on business logic, not directory structures and hook registrations.
- Use the AI assistant to explore LuperIQ APIs and get code suggestions specific to the module you are building, directly inside the builder interface.
- Download generated modules as ZIPs and integrate them into your agency's version control and deployment pipelines.
Site Owners and Non-Technical Users
- Describe the functionality you need in plain English and let the Qwen3 AI model generate the code. No PHP knowledge required to create a working module.
- Preview every file before building so you can verify the output matches your intent. If it does not, adjust your description and regenerate.
- Activate your custom module with one click and start using it immediately without SSH access, FTP uploads, or command-line tools.
Marketplace Contributors and Module Authors
- Generate module scaffolding, customize the code, and submit directly to the LuperIQ marketplace from the same admin interface.
- Release tracking preserves every version you build, giving you a complete history of changes for marketplace listings.
- The credits system and marketplace integration create a path from idea to published module without leaving WordPress.
How the AI-Powered Builder Works
The builder wizard collects your module specification across five steps. In the first step, you define the module identity: name, slug, version number, and a description of what the module does. The second step lets you define admin pages — their titles, slugs, menu positions, and capabilities. The third step covers feature selection, where you check boxes for common patterns like AJAX handlers, cron jobs, REST API endpoints, or WooCommerce integration hooks.
Step four is the AI generation prompt, where you can add natural-language instructions that refine the output beyond what the structured fields capture. You might write something like "add a settings page that stores an API key and validates it on save" and the AI incorporates that into the generated code.
Step five is the file preview. DevKit displays the complete directory tree and lets you open any file in a syntax-highlighted viewer. You see every PHP class, every JavaScript file, the CSS, and the module.json manifest. If anything looks wrong, you go back to earlier steps, adjust your inputs, and regenerate. When everything looks correct, you click Build. DevKit writes the files to the modules directory, registers the module with the LuperIQ framework, and gives you the option to activate immediately.
The AI Wizard Assistant: Contextual Help While You Build
At every step of the builder, the AI Wizard Assistant is available in a side panel. It uses the same Qwen3 AI model as the code generator but is tuned for conversational help. Ask it questions like "What capability should I use for this admin page?" or "How do I register a WooCommerce hook in a LuperIQ module?" and it responds with specific, context-aware answers. The assistant knows which step you are on and what you have already configured, so its suggestions reflect your actual module specification.
The assistant is particularly useful for non-developers who need guidance on WordPress concepts like capabilities, hook priorities, or namespace conventions. Instead of searching documentation in another tab, you get answers inline while you work. For experienced developers, the assistant accelerates decisions about module architecture by surfacing LuperIQ-specific patterns and best practices without leaving the builder.
Module Management and the My Modules Gallery
The My Modules page serves as a gallery and management console for every module you have created with DevKit. Each module is displayed as a card showing its name, version, active or inactive status, and the date it was last built. Clicking a module opens its detail view where you can toggle activation, download the ZIP, reload it into the builder for modifications, view its release history, or submit it to the marketplace.
Module management also extends to the broader LuperIQ ecosystem. DevKit can list all installed modules (not just ones it created), inspect their module.json manifests, check dependency trees, and toggle activation states. This makes DevKit a convenient administrative tool even when you are not building new modules. The gallery updates in real time via AJAX, so changes like activation toggles take effect immediately without a full page reload.
Frequently Asked Questions
Do I need to know PHP to use DevKit?
No. The builder wizard and AI generation handle all code creation. You describe your module in plain English, and the Qwen3 AI model generates properly structured PHP classes, JavaScript files, CSS, and the module manifest. The preview step lets you verify the output before building. That said, PHP knowledge is helpful if you want to customize the generated code after building.
What AI model does DevKit use for code generation?
DevKit uses the Qwen3 language model. It receives a structured prompt based on your wizard inputs and generates complete LuperIQ module files including namespaced PHP classes, admin page controllers, AJAX handlers, front-end assets, and the module.json manifest.
How does the credits system work?
Each AI generation consumes credits from your LuperIQ account. The number of credits deducted depends on the complexity of the generation request — a simple single-page module costs fewer credits than a multi-page module with WooCommerce integration and REST endpoints. Your current balance is shown in the builder before you generate. Credits can be purchased through the LuperIQ pricing page.
Can I edit the generated code after building?
Yes. Generated modules are standard LuperIQ modules written to the modules directory as plain PHP, JavaScript, and CSS files. You can edit them with any code editor, commit them to version control, or reload them into DevKit's builder for AI-assisted modifications.
What happens if the AI generates incorrect code?
The preview step exists specifically for this reason. Review every file before clicking Build. If something is wrong, go back to earlier wizard steps, adjust your description or settings, and regenerate. You can also modify the natural-language prompt in step five to give the AI more specific instructions. Generation is iterative — you can regenerate as many times as needed (each regeneration consumes credits).
Can I submit generated modules to the LuperIQ marketplace?
Yes. DevKit includes a marketplace submission feature accessible from the My Modules gallery. It packages your module, extracts metadata from module.json, and sends the submission to the LuperIQ marketplace API. Once reviewed and approved, your module becomes available to all LuperIQ users.
Is there a limit to the complexity of modules I can generate?
DevKit can generate modules with multiple admin pages, AJAX handlers, cron jobs, REST API endpoints, WooCommerce hooks, and dependencies on other LuperIQ modules. The practical limit is the context window of the Qwen3 AI model. Very large modules with dozens of files may need to be generated in stages or have their more complex components hand-coded after the initial scaffold is built.
Does DevKit work on shared hosting?
Yes. DevKit runs entirely within the WordPress admin and requires no command-line access, no additional server software, and no special PHP extensions. The AI generation happens via API calls to the Qwen3 service, so your hosting environment only needs standard WordPress requirements and outbound HTTPS connectivity.
Build Custom WordPress Modules in Minutes, Not Days
DevKit combines a guided builder wizard with AI-powered code generation so you can go from idea to working LuperIQ module without writing boilerplate. Describe it, preview it, build it, ship it.
