CommunityCoding & Developmentgithub.com

fswp-maintainer

Change stage for existing WordPress code in Full-Stack WP Developer. Updates, fixes, refactors, and upgrades existing plugins and themes without breaking them, and builds add-ons for products you do not own (WooCommerce extensions, page-builder elements, extensions of other plugins) using hooks instead of edits to third-party files. Covers reading before changing, parity lists, deprecation, host compatibility, upgrade paths, and patch delivery. Invoked by fswp-developer after an approved change brief; consult directly for safe-change or add-on questions.

What is fswp-maintainer?

fswp-maintainer is a Claude Code agent skill that change stage for existing WordPress code in Full-Stack WP Developer. Updates, fixes, refactors, and upgrades existing plugins and themes without breaking them, and builds add-ons for products you do not own (WooCommerce extensions, page-builder elements, extensions of other plugins) using hooks instead of edits to third-party files. Covers reading before changing, parity lists, deprecation, host compatibility, upgrade paths, and patch delivery. Invoked by fswp-developer after an approved change brief; consult directly for safe-change or add-on questions.

Works with~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/syncwin/fswp-developer/tree/main/skills/fswp-maintainer

Installed? Explore more Coding & Development skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

FSWP Maintainer

Foundational (always applied): fswp-developer/references/lean-coding.md (write less, reuse first), fswp-developer/references/coding-standards.md (coding standards, docs, i18n, accessibility), and fswp-security-engineer (input, output, authorization).

The existing code is the specification. Executes an approved change brief from fswp-architect (which already ran detect_wp_project.py). Follow the project's own conventions unless they are unsafe; house templates are for new projects, not for rewriting someone else's style.

Mode A: Update an existing plugin or theme

  1. Read first. Read the files the change touches, their callers, and their tests. Note the prefix, naming, error-handling style, and how settings and data are stored.
  2. Reproduce. For a bug, write down steps and the observed result; confirm the failure before changing anything. For a feature, state the acceptance check.
  3. Smallest change that works. Fix the cause in shared code, not one call site. Do not reformat untouched code; noisy diffs hide real changes and break blame.
  4. Protect the public surface. Hook names, function and class names, option keys, meta keys, REST routes and shapes, shortcode attributes, and template overrides are contracts. To change one, deprecate first: keep the old one working, call _deprecated_function() / _deprecated_hook() (or _deprecated_argument()), document the replacement, and remove no sooner than a later major version.
  5. Upgrade path. If data or schema changes: bump a stored version option, run a migration on load (not only on activation), make it idempotent, and test upgrading from the previous version's data without reactivating.
  6. Compatibility. Respect the declared Requires at least and Requires PHP; guard newer functions with function_exists()/version checks or raise the minimum deliberately and say so.
  7. Security pass on the touched code (fswp-security-engineer): a bug fix must not add a new entry point without authorization, nonce, sanitization, and escaping.
  8. Version and changelog. Fix = patch, feature = minor, breaking = major. Move the plugin/theme version, the constant, readme.txt Stable tag, and the changelog together.
  9. Deliver as a patch or diff for the repo the user works in, or a zip when they deploy files. Include the parity checklist result.

Themes: prefer a child theme or theme.json/style-variation changes over editing a parent theme that receives updates. Direct edits to a parent, and edits to third-party plugin files, are lost at the next update.

Mode B: Add-on for a product you do not own

An add-on is a separate plugin (or a small theme layer) that extends a host. Structure it with fswp-plugin-developer (steps 1-3 and 8), then apply these rules:

  1. Extend through the host's public API. Use documented actions, filters, registries, and REST routes. Never edit host files and avoid calling internals marked private or undocumented; if you must, isolate the call in one adapter class and guard it.
  2. Declare the dependency. Add Requires Plugins: host-slug to the header when the host is on WordPress.org (WordPress 6.5 and later enforces it). Also detect at runtime: check for a class, function, or constant, or a version constant, not the plugin file path.
  3. Load at the right time. Initialize on plugins_loaded (or the host's own ready hook) after confirming the host exists; register on the host's registry hooks, not earlier.
  4. Fail quietly and clearly. Host missing or too old: do nothing else, show one admin notice explaining what is needed, and never fatal.
  5. Version range. State the supported host versions in the readme and the plan. Test the lowest and the newest supported.
  6. Compatibility declarations. Some hosts require you to declare feature support. Example: WooCommerce expects extensions to declare compatibility with High-Performance Order Storage and the block-based cart and checkout. Read the host's developer docs for the current declaration calls.
  7. Data ownership. Store your data under your own prefix; do not write into the host's tables or options. Uninstall removes only your data.
  8. Licensing and naming. Follow the host's brand and trademark rules for names; use a descriptive "for X" style rather than implying it is official.

Verify

Hand to fswp-qa-engineer with the change brief's parity list and compatibility table as the scenario source. references/safe-change-checklist.md is the quick pre-delivery list.

Individual skills in this repo

This repo contains 9 individual skills — each has its own dedicated page.

fswp-api-developer

Domain skill for WordPress REST API and Abilities API work in Full-Stack WP Developer. Covers registering routes with schemas, argument validation and sanitization, permission callbacks, controller classes, exposing post types and meta, authentication (cookie nonce, application passwords), pagination and errors, and registering abilities with input and output schemas and safety annotations. Use for any custom endpoint or machine-readable capability in a plugin or theme.

fswp-architect

Planning stage of Full-Stack WP Developer. Classifies the work (new plugin, new theme, update to an existing plugin or theme, add-on for another product, or WordPress Core patch), triages existing code with a bundled detection script, asks one round of essential questions, does competitive research, and produces one reviewable PRD or change brief with a single approval gate. Also covers Migration mode and multi-session handoff docs. Invoked by fswp-developer before any code is written; consult directly for PRD, change-brief, or handoff-doc questions.

fswp-block-developer

Domain skill for WordPress block editor work in Full-Stack WP Developer. Covers building custom Gutenberg blocks (block.json, static and dynamic rendering, attributes, supports, InnerBlocks, variations, deprecations, block bindings), block patterns, and the Interactivity API (data-wp directives, stores, server-side state), with the @wordpress/scripts build workflow. Use for any custom block, pattern, or front-end interactivity in a plugin or theme.

fswp-core-contributor

WordPress Core contribution stage of Full-Stack WP Developer. Guides a contributor through finding or filing a Trac ticket, setting up the wordpress-develop checkout and test environment, writing a patch or GitHub pull request that follows Core coding standards, inline documentation, backward compatibility and tests, and preparing the ticket comment; also routes block-editor changes to the Gutenberg repository and security reports to the private process. Invoked by fswp-developer for Core patches; consult directly for Core workflow questions.

fswp-devops-engineer

Domain skill for WordPress development tooling in Full-Stack WP Developer. Covers local environments (wp-env with Docker, WordPress Playground and Blueprints), command-line site operations (plugin and theme management, database export, search-replace, cron, scaffolding), coding standards and static analysis (PHPCS with WordPress standards, PHPStan with WordPress stubs), PHP and JS testing setup, and the @wordpress/scripts toolchain. Use when setting up, running, or automating a WordPress dev or test environment.

fswp-qa-engineer

Verification stage of Full-Stack WP Developer. Runs the mechanical gate for plugins and themes (house-rule scripts, PHP lint, PHPCS with WordPress standards, PHP compatibility, PHPStan with WordPress stubs), the manual checklist, PRD or change-brief scenario tests, and the pre-release check. Reports PASS, FAIL, or NOT RUN and never implies a skipped check passed. Invoked by fswp-developer after a build and again before delivery; consult directly to audit any plugin or theme folder.

fswp-reviewer

Independent review stage of Full-Stack WP Developer. Reviews a finished WordPress plugin, theme, add-on, or Core patch through a security lens (WordPress-specific vulnerabilities, REST and AJAX authorization with an API risk map, AI-generated-code risks), a quality lens (error handling, data and upgrade safety, performance, i18n, accessibility, comment accuracy, test gaps, class and type design, scope), and an optional lean lens for trimming over-engineering, reporting only high-confidence findings in a fixed format. Invoked by fswp-developer after the verify gate, normally through the fswp-code-reviewer agent; consult directly to review or optimize any WordPress code.

fswp-theme-developer

Theme build stage of Full-Stack WP Developer. Builds custom WordPress themes - block themes (theme.json, templates, template parts, patterns, style variations), classic themes (template hierarchy, functions.php, theme supports), hybrids, and child themes - with accessibility, escaping, and directory readiness built in, plus a scaffold script. Invoked by fswp-developer after an approved PRD for a new theme; consult directly for a specific theme pattern. For changes to an existing theme use fswp-maintainer.

syncwin/fswp-plugin-developer

Plugin build stage of Full-Stack WP Developer. House standards and code templates for real WordPress plugins (not shortcode snippets) - folder anatomy, activation/uninstall lifecycle, custom post types and tables, admin UI tiers, front-end output on the Atomic Framework, REST and cron, i18n, distribution, and the Tier 3 React admin stack - plus a scaffold script. Also the base structure for add-ons. Invoked by fswp-developer after an approved PRD; consult directly for a specific plugin build pattern.

Related Skills