Bootstraps a complete plugin project structure with manifest files, entry points, configuration schemas, and baseline tests so new Codex or editor extensions follow a consistent, reviewable template from day one. This eliminates the setup tax for creating new plugins and ensures every plugin in a codebase shares the same conventions for configuration, logging, and error handling.
Use cases
- Starting a new Codex plugin or editor extension for a project that has not used them before
- Creating a template plugin to be forked and customized by multiple team members
- Onboarding a new engineer who needs a standardized starting point for plugin development
- Evaluating a third-party plugin and wanting a clean reference implementation to compare against
- Spinning up a proof-of-concept plugin before deciding whether it warrants a full implementation
Key features
- Define the plugin scope: which surfaces (files, commands, UI panels) it will extend and which APIs it will consume
- Generate the manifest and entry point files following the platform's documented structure and version requirements
- Populate supporting files: configuration schema, logging setup, error boundaries, and basic test harness
- Add smoke tests that verify the plugin loads, the entry point is registered, and a simple command can be invoked
- Document how to extend the scaffold for future features and how to run the full test suite locally
When to Use This Skill
- When creating a new plugin from scratch and wanting to avoid repetitive boilerplate setup
- When establishing a shared plugin template across a team or multiple projects
- When evaluating whether a plugin approach fits a use case before committing to a full implementation
Expected Output
A complete, runnable plugin scaffold with manifest, entry point, configuration schema, and basic tests that pass out of the box.
Frequently Asked Questions
- How opinionated should the scaffold be?
- Include conventions for things that are hard to change later (configuration schema, error handling, logging format). Leave room for the implementer to make architectural choices in the business logic layer.
- Should the scaffold include a full test suite?
- Include a minimal test harness that proves the plugin loads correctly. Engineers should extend it for their specific features rather than starting from a fully populated test suite they then delete from.
- Can the scaffold handle multiple plugin platforms at once?
- If targeting multiple editors, generate a platform-specific subdirectory for each while sharing the core business logic. Avoid embedding platform assumptions in the shared layer.
Related
Related
3 Indexed items
Dispatching parallel agents
Distributes embarrassingly parallel work across multiple AI agents with clear briefs and crisp handoff protocols, then aggregates their results through a single integrator. This technique maximizes throughput when tasks are independent and the coordination overhead is low, making it ideal for research chunks, file batches, or parallel data processing.
Multi-agent orchestration
Coordinates multiple AI agents on shared tasks with explicit handoff protocols, shared state management, and conflict resolution so parallel work stays coherent. Multi-agent orchestration is more structured than simple parallel dispatch because agents take on distinct roles with explicit dependencies rather than running identical briefs on independent data.
Subagent-driven development
Coordinates multiple AI subagents on slices of a larger plan where each subagent handles a defined scope while a single parent agent retains accountability for integration, quality, and final delivery. This approach is valuable when a single agent working sequentially would be too slow, but you still need coherent end-to-end quality rather than fragmented outputs.