Skip to main content
Back to Blog
WordPress Command Palette Workflow Automation
WordPress Automation

WordPress Has a Command Palette. Nobody Uses It Right.

Turn the WordPress Command Palette into a workflow automation layer. Custom commands, batch operations, and keyboard-driven admin productivity with code.

S
Summix
· 7 min read
WordPress Command Palette Workflow Automation Keyboard Shortcuts WordPress 6.9 Custom Commands Admin Productivity

WordPress Has a Command Palette. Nobody Uses It Right.

Every draft you publish follows the same ritual: navigate to Posts, filter by status, select drafts, open each one, click Publish, confirm. Six clicks per post. Multiply that across a content calendar and you are burning hours on mechanical work the WordPress Command Palette was designed to eliminate. Since WordPress 6.9 expanded it admin-wide, the palette is no longer a navigation shortcut. It is a workflow automation layer sitting behind Cmd+K (Ctrl+K on Windows), and most teams treat it like a fancy search bar.

Here is how to change that.

What Changed in WordPress 6.9

Before December 2025, the Command Palette lived only inside the Site Editor and, from WordPress 6.6, the block editor. WordPress 6.9 broke it out across the entire admin dashboard. Three changes matter for workflow automation:

  1. Admin-wide availability. The palette responds to Cmd+K on every admin screen, not just editing contexts.
  2. The useCommands hook. Documented in the @wordpress/commands package, it registers multiple commands in a single call, which makes batch command registration practical for plugins with dozens of actions.
  3. The @wordpress/core-commands package. Extracted from the monolithic commands package, it gives developers a clean dependency boundary for navigation-level commands.

If you have been waiting for the right time to build custom commands, the platform is ready. The WordPress 7.0 beta continues refining these APIs without breaking changes, so what you build now will carry forward.

Built-In Commands That Already Automate Your Workflow

WordPress 6.9 ships with 50+ built-in commands. Most tutorials list them and stop there. The productivity gain comes from recognizing which ones replace multi-click admin paths:

  • “Add new post” skips the Posts menu entirely. One keystroke, one action.
  • “Toggle Distraction Free mode” removes chrome from the editor without hunting through Preferences.
  • “Navigate to Templates” jumps directly to the Site Editor template list from any admin screen.
  • Block operations (duplicate, transform, delete) work contextually when a block is selected, eliminating right-click menus.

Before you reach for an automation audit checklist to evaluate your workflows, start here. Map which admin tasks you repeat daily and check whether a built-in command already handles them. If it does not, you can build one.

Creating Custom Commands for Workflow Automation

This is where the Command Palette shifts from convenience feature to workflow automation tool. The @wordpress/commands API lets you register commands that execute arbitrary logic, including REST API calls, data store dispatches, and multi-step workflows.

Example 1: Batch Publish All Drafts

This command fetches every draft post via the REST API and publishes them in sequence. One keystroke replaces the six-click-per-post ritual described in the introduction.

import { useCommand } from '@wordpress/commands';
import { __ } from '@wordpress/i18n';
import { post } from '@wordpress/icons';

const BatchPublishCommand = () => {
    useCommand( {
        name: 'summix/batch-publish-drafts',
        label: __( 'Publish all draft posts', 'summix' ),
        icon: post,
        callback: async ( { close } ) => {
            const drafts = await wp.apiFetch( {
                path: '/wp/v2/posts?status=draft&per_page=100',
            } );
            for ( const draft of drafts ) {
                await wp.apiFetch( {
                    path: `/wp/v2/posts/${ draft.id }`,
                    method: 'POST',
                    data: { status: 'publish' },
                } );
            }
            close();
        },
    } );
    return null;
};

Note: Always back up your site before running bulk operations. This command publishes every draft, so scope it to a specific category or author if you need finer control.

Example 2: Dynamic Content Search with useCommandLoader

Static commands work for known actions. For search-driven workflows — finding and jumping to a specific custom post type — useCommandLoader generates commands dynamically based on what the user types.

import { useCommandLoader } from '@wordpress/commands';
import { useCallback } from '@wordpress/element';
import { useEntityRecords } from '@wordpress/core-data';
import { page } from '@wordpress/icons';

const PortfolioSearchLoader = () => {
    useCommandLoader( {
        name: 'summix/search-portfolio',
        hook: useCallback( ( { search } ) => {
            const { records, isResolving } = useEntityRecords(
                'postType',
                'portfolio',
                { search }
            );
            return {
                commands: ( records || [] ).map( ( record ) => ( {
                    name: `summix/edit-portfolio-${ record.id }`,
                    label: record.title.rendered,
                    icon: page,
                    callback: ( { close } ) => {
                        document.location.href =
                            `post.php?post=${ record.id }&action=edit`;
                        close();
                    },
                } ) ),
                isLoading: isResolving,
            };
        }, [] ),
    } );
    return null;
};

This pattern works for any registered post type. Swap 'portfolio' for 'product', 'case_study', or whatever your project uses.

Both components need to be rendered inside a WordPress admin React root. Enqueue your built script via enqueue_block_editor_assets for editor contexts, or mount a custom React root in admin_footer for admin-wide availability in WordPress 6.9+.

Workflow Patterns: Chaining Commands into Automation

A single command automates a single task. Real productivity comes from chaining commands into multi-step workflow automation patterns.

The callback inside useCommand is plain JavaScript. That means your command can fire WordPress hooks via the data store, call REST endpoints (including your own custom ones), and trigger native webhooks for downstream automation.

Here is the pattern: your command calls a custom REST endpoint that runs server-side logic. That server-side logic can dispatch do_action() hooks, schedule background tasks with Action Scheduler, or fire outbound webhooks. The Command Palette becomes the keyboard-driven trigger layer; the server handles orchestration.

This approach keeps the frontend lightweight and lets you reuse existing automation infrastructure. If you are already comparing self-hosted automation costs, custom commands add a zero-cost trigger mechanism to whatever backend you have built.

Native vs. Plugin Command Palettes

The core Command Palette covers navigation, content operations, and custom commands through the @wordpress/commands API. For many teams, that is enough.

Two plugins extend it further. Commandify (free/Pro, ~4,000 downloads) adds admin menu items as searchable commands. CommandUI ($79-$249/year) replaces the palette entirely with a commercial alternative that includes theming and analytics.

Evaluate what you need. If your workflow automation requires custom commands with REST API callbacks, the native API handles that without a plugin dependency. If you want a broader searchable surface without writing code, a plugin may save time.

What Is Coming Next

The Command Palette’s trajectory points toward becoming WordPress’s primary automation interface. Gutenberg issue #66648 tracks proposals for command grouping, WP-CLI command ports, and media management actions.

WordPress 6.9 also introduced the Abilities API, which registers machine-readable capabilities that commands can query at runtime. As this API matures alongside the Phase 3 collaboration features landing in WordPress 7.0, expect the palette to surface context-aware workflow commands based on user roles and site capabilities.

The foundation is stable today. What you build now will only get more useful.

Start Building

The WordPress Command Palette is a native workflow automation layer with a production-ready API, admin-wide keyboard shortcut access, and a clear development roadmap. You do not need a plugin or an external service to start eliminating repetitive admin work.

Pick one workflow you repeat daily. Write a custom command for it. Register it, test it, and measure how many clicks it eliminates. That first command will change how you think about every admin task that follows.

Sources & References

This article draws from authoritative sources including:

Official Documentation:

Development Sources:

Plugin References: