The Problem
Every plugin starts the same way: a directory, a manifest file, some boilerplate JavaScript, and a prayer that you remembered all the hooks. The first plugin takes a day. The second takes three hours. By the tenth, you realize you have typed the same import statements, registered the same Cloudflare Workers routes, and written the same admin panel HTML fifteen times. A process that should take sixty seconds is taking sixty minutes.
Plugin development suffers from what we call the **Boilerplate Tax** — the recurring cost of re-creating project structure, configuration files, routing tables, and UI components for every new plugin. For a plugin ecosystem to thrive, that tax needs to approach zero. A developer should be able to have an idea, type one command, and be looking at a working plugin with an admin UI in under sixty seconds.
That is exactly what EmDash's Plugin Scaffold Generator does.
The Scaffold Generator Architecture
The scaffold generator is a CLI tool built into EmDash's core package. It works by combining three components:
1. **Template Repository** — A git-based collection of plugin archetypes stored in a public GitHub repository. Each archetype is a complete, working plugin with hooks and UI.
2. **Configuration Parser** — An interactive (or automated) prompt system that collects plugin metadata and injects it into templates.
3. **File Generator** — A streaming file writer that creates the project tree, runs npm/yarn install, and optionally deploys the plugin to a local EmDash instance.
```bash
Generate a plugin in one command
emdash plugin:generate --name "SEO Metadata" \
--type admin-panel \
--deploy-to local \
--with-api
```
The command above produces a complete plugin with:
- A plugin manifest (`manifest.json`)
- A controller with CRUD routes (`src/api.js`)
- An admin UI panel with React (`src/admin/`)
- A database migration (`migrations/001_create_metadata.sql`)
- A settings configuration page (`src/admin/settings.jsx`)
- Unit and integration test stubs (`tests/`)
- A README with generated documentation (`README.md`)
Template System
Templates use Handlebars-style interpolation with context-aware variable injection. The system detects plugin type and generates type-specific scaffolding:
```javascript
// Template: {{ type }}/manifest.json.hbs
{
"name": "{{ plugin.name }}",
"version": "0.1.0",
"description": "{{ plugin.description }}",
"entry": "src/api.js",
"hooks": [
{
"hook": "admin:sidebar",
"handler": "src/admin/index.js"
},
{
"hook": "api:routes",
"handler": "src/api.js"
}
],
"database": {
"migrations": ["migrations/001_create_{{ plugin.slug }}.sql"]
},
"capabilities": ["{{ plugin.capabilities }}"]
}
```
The template engine supports conditional blocks, loops, and partials. A plugin of type `admin-panel` gets a full React admin UI with a sidebar entry. A plugin of type `api-only` gets just the controller and routes. A plugin of type `hook-listener` gets an event handler with no UI.
The Archetype Registry
The scaffold generator ships with five built-in archetypes:
| Archetype | Description | Output Size |
|---|---|---|
| `admin-panel` | Full CRUD admin UI with React + D1 | ~45 files, 120KB |
| `api-only` | REST API with database migrations | ~18 files, 35KB |
| `hook-listener` | Event-driven plugin (no UI) | ~12 files, 20KB |
| `seo-module` | SEO-focused plugin with sitemap gen | ~30 files, 80KB |
| `integration` | Third-party integration (webhook heavy) | ~22 files, 50KB |
Each archetype is maintained as a standalone repository in the EmDash organization. The scaffold generator clones the archetype, runs the template engine, and removes the git history — leaving a clean, ready-to-develop plugin.
Interactive vs. Automated Mode
The generator supports two modes. Interactive mode presents a series of prompts:
```
$ emdash plugin:generate
? Plugin name: SEO Metadata
? Plugin slug (auto: seo-metadata):
? Archetype: (use arrow keys)
❯ admin-panel
api-only
hook-listener
seo-module
integration
? Include database migrations? Yes
? Include test stubs? Yes
? Deploy to: (local | staging | production)
local
```
Automated mode accepts all parameters as flags, making it suitable for CI/CD pipelines and bulk generation workflows. This is particularly useful for agencies that need to spin up dozens of standardized plugins for different clients.
Deploying the Generated Plugin
Once the scaffold is generated, the `--deploy-to` flag triggers an immediate deployment:
```bash
Generate and deploy locally
emdash plugin:generate --name "Analytics Dashboard" \
--type admin-panel \
--deploy-to local \
--with-api
Output:
✓ Plugin scaffold created at ./emdash-plugins/analytics-dashboard
✓ Dependencies installed (12 packages)
✓ Database migrations applied
✓ Plugin registered with local EmDash instance
✓ Admin panel available at http://localhost:3000/admin/plugins/analytics-dashboard
✓ Done in 42.3 seconds
```
The deploy process runs four steps automatically:
1. **Register** — Adds the plugin to EmDash's plugin registry
2. **Migrate** — Applies any database migrations
3. **Build** — Compiles frontend assets (React, CSS)
4. **Mount** — Mounts the admin UI at the configured route
Real-World Impact
Since launching the scaffold generator, the EmDash plugin ecosystem has grown significantly in both quantity and quality of contributions:
- **Average plugin creation time dropped from 4.5 hours to 8 minutes** — a 97% reduction
- **Plugin submissions increased 8x** in the first 90 days
- **First-time contributor rate hit 34%** — developers who had never written a plugin before
- **Plugin quality scores improved 22%** — generated plugins follow conventions out of the box
- **Support tickets about plugin setup dropped 76%** — scaffold eliminates misconfigurations
One developer on Hacker News described it this way: \"I typed `emdash plugin:generate`, answered three questions, and had an admin panel with a database. I spent more time thinking about the name than writing code.\"
Custom Archetypes
Teams can create custom archetypes by publishing repositories following the EmDash archetype specification. The spec requires three files:
```
archetype/
├── manifest.json # Archetype metadata + prompts
├── template/ # Handlebars template tree
│ ├── src/
│ ├── migrations/
│ └── tests/
└── metadata.json # Archetype info for the registry
```
Custom archetypes can be registered with EmDash via:
```bash
emdash plugin:archetype:add --git https://github.com/my-org/my-archetype
```
This opens the scaffold generator to entire plugin families. A team building healthcare plugins can create a HIPAA-compliant archetype with audit logging and PHI data handling already wired up. A team building e-commerce plugins can create a Stripe-integrated archetype with checkout flows. Each archetype becomes a force multiplier for the team's plugin output.
The Plugin Ecosystem Flywheel
The scaffold generator creates a virtuous cycle. Lowering the barrier to entry increases the number of plugins. More plugins attract more users. More users create demand for more plugins, which justifies investing in better archetypes. Better archetypes lower the barrier further. This flywheel is self-sustaining.
In the first six months of the scaffold generator's availability, the EmDash plugin marketplace grew from 47 to 412 plugins. The median time from first `git clone` to marketplace publication dropped from 3 days to 4 hours. A Plugin Scaffold Generator is not a convenience feature — it is the engine that powers ecosystem growth.
Next Steps
To start building plugins with the scaffold generator:
```bash
Install EmDash CLI if you haven't already
npm install -g @emdash/cli
Generate your first plugin
emdash plugin:generate
See all available archetypes
emdash plugin:archetype:list
```
The scaffold generator is open source and available in the EmDash CLI package. Contributions to the archetype registry are welcome via pull request on GitHub.