AddQuicktag is dead on WordPress 6+: migrate to Custom Quicktag Editor (complete 2026 guide)

You open a post to insert your “Shipping notice” box — the button is gone. The Quicktags bar still shows b, i, link… but not your custom HTML. AddQuicktag is still “active”, yet nothing loads since the WordPress 6.2 update. Your editor retypes the same <div class="alert"> block for the fortieth time this month.

You are not alone. 100,000+ sites relied on AddQuicktag — a popular plugin abandoned on modern WordPress. The QTags load order changed, the UI never caught up with Gutenberg, and there are no {{year}} placeholders, no clean migration path, and no block sidebar.

This guide exists because we see two extremes: retyping HTML by hand (errors, fatigue, inconsistency), or stacking TinyMCE plugins that break on the next conflict. The right answer is in the middle: maintained Quicktag buttons, 22 presets, one-click AddQuicktag migration, dynamic placeholders — 100% local, no usage-based API fees.

Why read this? You will understand why AddQuicktag is no longer enough, how to deploy Custom Quicktag Editor by Volade (CQE) in 7 phases, which presets to pick (alerts, columns, code, TOC…), how to migrate from the database or a .wpaq file, and where CQE works (Classic, Gutenberg, ACF — not Elementor).

What you will learn: the AddQuicktag problem · 22 presets by category · 9 placeholders · 4-step builder · Gutenberg sidebar · Front CSS · wp cqe · AddQuicktag / TinyMCE Extended comparison · agency checklist · synergy with Plugin Usage Detector to audit legacy editor plugins.

Who this is for — and who can skip it

CQE is for you if your editorial team still lives in the Classic Text tab, you reuse HTML blocks (alerts, CTAs, FAQ, columns), or AddQuicktag stopped loading buttons after WordPress 6.x. Press sites, B2B blogs, and institutional sites with 3–15 writers are our typical users — not full Elementor WooCommerce stores.

You can skip it if all content is built with native Gutenberg patterns, or if Elementor/Divi owns 100% of pages. CQE does not inject buttons into the Elementor canvas. Invest in Gutenberg patterns or builder widgets instead.

Classic scenario: a writer copies a “legal disclaimer” box from a 2021 post. CSS classes changed, HTML is malformed, mobile layout breaks. CQE centralizes the HTML once, with {{year}} placeholders — everyone clicks the same button.

Why AddQuicktag is not enough in 2026

AddQuicktag was the reference tool for WordPress editorial teams for years: HTML buttons in the Text tab, sometimes TinyMCE. Then WordPress 6.0 changed the QTags lifecycle, Gutenberg became the default, and the plugin never received structural fixes.

Symptoms you will recognize

What your editors lose

• Consistency — every author reinvents alert HTML
• Speed — 30 seconds × 200 posts/year = billable hours
• Safety — HTML pasted from old posts with obsolete classes
• Onboarding — “Ask Marie, she has the template in a Google Doc”

What are Quicktags? — a primer for US developers

If you came to WordPress from another CMS or framework, "Quicktags" may be unfamiliar. Quicktags are JavaScript toolbar buttons in the WordPress Classic Editor's Text tab. They insert HTML at the cursor position or wrap selected text. WordPress ships with ~12 built-in Quicktags registered via the QTags.addButton() API — bold, italic, link, blockquote, and so on.

How Quicktags work under the hood:

Each Quicktag is a plain JavaScript object:

QTags.addButton('my_alert', 'Alert', '<div class="alert">', '</div>');

When clicked, the editor inserts start + highlighted text (if any) + end into the textarea. No AJAX, no page reload — instant DOM manipulation.

Where Quicktags appear:

• Classic Editor (Text tab) — the toolbar above the textarea
• Classic block in Gutenberg — identical toolbar inside the block
• ACF WYSIWYG fields — when Quicktags are enabled in field settings

Quicktags predate Gutenberg by over a decade. They were introduced in WordPress 2.0 as the original editing toolbar. When TinyMCE arrived, Quicktags became the Text tab companion. In 2026, they remain the fastest path from thought to structured HTML — no mouse needed if you know the access keys.

CQE builds on this same QTags.addButton() API but removes the need to write JavaScript. Every button you create in CQE becomes a real QTags.addButton() registration behind the scenes. This is not a hack — it is the documented WordPress API.

What Custom Quicktag Editor does — in one sentence

CQE adds buttons to the Quicktags bar (Text tab) and the TinyMCE Tags menu (Visual tab), with an admin UI to create, reorder, filter and export buttons — plus 22 one-click presets.

Settings → Custom Quicktags  →  Alert preset  →  edit post  →  click Alert  →  HTML inserted

Five preset categories

Full list of 22 slugs: alert, cta, badge, quote, columns, flex, spoiler, accordion, responsive, headings, semantic, table, code, embed, figure, faq, toc, social, disclaimer, highlight, btn_primary, lazy_img.

Built-in Quicktags vs custom Quicktags

WordPress core ships roughly 12 built-in Quicktags covering basic formatting:

These cover inline formatting and basic lists — but they fall short for modern editorial workflows.

Where built-in Quicktags fall short:

• No way to insert <div> wrappers with CSS classes
• No dynamic data (year, post title, permalink)
• No structured blocks (FAQ accordions, column layouts)
• No visibility rules — all buttons visible to all users
• No bulk management — cannot export, import, or reorder them

What custom Quicktags (CQE) add:

Bottom line: Built-in Quicktags handle paragraph-level formatting in the Text tab. CQE custom Quicktags handle document-level structuring — alerts, CTAs, disclaimers, columns, and any other recurring HTML pattern an editorial team needs. They coexist in the same toolbar; CQE additions are not replacing built-ins, they extend them.

Where it works — and where it does not

CQE targets native WordPress editors. Not proprietary page builders.

If your client is 100% Elementor, point them to Elementor templates — CQE is not the right tool. If editorial uses Gutenberg + Classic blocks for body content, CQE is built for that.

Dynamic placeholders — the edge vs AddQuicktag

In a button’s start or end HTML, insert tokens resolved on click:

Use case: Share preset social with ?url={{permalink}} — no more copy-paste URLs. Disclaimer “© {{year}} {{site_name}}” auto-updated.

AddQuicktag migration — 7-phase agency workflow

Phase 0 — Inventory (30 min)

• List AddQuicktag buttons (screenshots or .wpaq export)
• Note post types and allowed roles
• Confirm Classic Editor or Gutenberg + Classic block
• Archive AddQuicktag export in /client-editor/

Phase 1 — Install CQE (15 min)

1. Plugins → Add New → Upload Volade ZIP
2. Activate — auto-redirect to settings
3. Do not uninstall AddQuicktag yet

Phase 2 — Import (15 min)

Option A — DB: if AddQuicktag is still installed, CQE detects rmnlQuicktagSettings → Import from AddQuicktag.

Option B — File: Backup tab → upload .wpaq.

CLI:

wp cqe import-addquicktag
wp cqe status

Phase 3 — Button review (45 min)

• Check each button: start, end, order, HTML/Visual tabs
• Merge with presets if needed (Replace unchecked)
• Apply editorial pack: alert, quote, cta, faq

wp cqe preset alert
wp cqe preset quote

Phase 4 — Placeholders & Front CSS (30 min)

• Enable Front CSS if cqe-alert, cqe-columns classes must render on the public site
• Test {{year}} and {{permalink}} on a draft
• Tune child theme CSS if needed

Phase 5 — Gutenberg & team (1 h)

• Train 2 pilot editors (15 min each)
• Test Gutenberg sidebar + Classic block
• Document “which button for which use” (1-page PDF/Notion)

Phase 6 — Staging → prod (30 min)

wp cqe export --file=cqe-backup-$(date +%Y%m%d).json

• Deploy identical config to prod
• Deactivate then delete AddQuicktag
• Client email (see downloadable runbook)

Phase 7 — 7-day watch

• Editorial support: missing buttons = post type or role misconfiguration
• Plugin Usage Detector if other legacy editor plugins linger

The 4-step builder

Create a custom button without code:

1. Name & label — toolbar text (e.g. “Shipping alert”)
2. HTML — start and end tags (e.g. <div class="cqe-alert"> / </div>)
3. Editors — HTML only, Visual only, or both
4. Visibility — post types, roles (V+ for advanced rules), categories

Each field has contextual help below the form — built for editors, not only developers.

WP-CLI — useful commands

Multisite: network presets via cqe_apply_preset_network.

Honest comparison — CQE vs alternatives

Option 1 — Retype HTML manually

Option 2 — AddQuicktag (legacy)

Option 3 — TinyMCE Advanced / Extended

Option 4 — Custom Gutenberg blocks (ACF / theme)

Option 5 — Custom Quicktag Editor by Volade (recommended)

Comparison table

Plugin comparison — deep dive

Beyond the five options in the comparison table, US agencies and developers should know about these alternatives:

Code Snippets (plugin) — Stores PHP/JS snippets but has no Quicktags GUI. You can write QTags.addButton() calls in PHP and store them here, but there is no button management UI, no presets, no placeholders, and no AddQuicktag migration. Good for developers; not a replacement for editorial Quicktags.

Shortcoder (plugin) — Creates shortcodes that output custom HTML. Requires [shortcode] syntax in the editor, does not use the Quicktags API, and adds a PHP parsing layer. Useful for non-editorial content but CQE avoids the shortcode overhead entirely — raw HTML on click, no parsing.

Custom Gutenberg blocks (ACF / create-block) — Powerful but expensive. A custom block costs $200–500 in dev time with ACF Pro. A Quicktag is free and instant. Rule of thumb: if the pattern appears 10+ times per month and is under 5 HTML lines, a Quicktag beats a custom block on speed and cost.

What makes CQE unique: CQE is the only maintained plugin in 2026 offering a GUI + 22 presets + AddQuicktag migration + Gutenberg sidebar + WP-CLI + dynamic placeholders — all with zero recurring API costs.

Code tutorial — real-world examples for US developers

Each example shows the start and end values for the CQE 4-step builder. These are production patterns from US agency deployments.

Example 1: CTA button with auto-permalink

Start: <p class="cqe-cta"><a href="{{permalink}}#signup" class="button button-primary">
End: </a></p>

One click inserts a complete CTA paragraph linking to the current post. {{permalink}} resolves at insertion time.

Example 2: Legal disclaimer with auto-updating date

Start: <div class="cqe-disclaimer"><p><strong>Disclaimer:</strong> Information as of {{date}}. © {{year}} {{site_name}}. This is for informational purposes only.
End: </p></div>

Eliminates manual year updates. Used by law firms and financial publishers.

Example 3: FAQ accordion wrapper

Start: <details class="cqe-faq"><summary>
End: </summary></details>

Wraps each Q&A in semantic <details> / <summary> — accessible, no JavaScript needed.

Example 4: Social share bar with permalink + title

Start: <div class="cqe-share"><p><strong>Share:</strong> <a href="https://twitter.com/intent/tweet?url={{permalink}}&text={{post_title}}" target="_blank">X (Twitter)</a> · <a href="https://www.linkedin.com/sharing/share-offsite/?url={{permalink}}" target="_blank">LinkedIn</a>
End: </p></div>

Auto-fills share links with the current post URL and title. No copy-paste.

Example 5: Code block with language class

Start: <pre class="cqe-code language-php"><code>
End: </code></pre>

Highlight code in the editor, click the button to wrap it. Pair with Prism.js or Highlight.js on the front end.

Example 6: Two-column responsive layout

Start: <div class="cqe-columns"><div class="cqe-col">
End: </div><div class="cqe-col">

Insert, type column 1 content, close with </div></div>. Styled by Front CSS.

Example 7: Author bio with dynamic name

Start: <div class="cqe-author-box"><div class="cqe-author-avatar">{{author}}</div><div class="cqe-author-bio"><strong>{{author}}</strong><br><em>
End: </em></div></div>

Inserts a pre-filled author bio box. Editors add the bio text between <em> and </em>.

Example 8: Lazy-loaded figure

Start: <figure class="cqe-figure"><img src="" alt="" loading="lazy" class="cqe-lazy">
End: </figure>

Editors fill in src and alt. loading="lazy" built in — no separate performance plugin needed.

Use cases — US agency and enterprise

Law firm editorial compliance

Problem: 50-attorney firm publishing 30+ articles/month. Each post must carry a standardized legal disclaimer. Editors were copying from old posts, introducing typos and stale dates.

Solution: One CQE "Disclaimer" button inserting the full notice with {{year}} and {{date}}. Restricted to Editor/Admin roles.

Result: Zero compliance edits in 6 months.

SaaS content marketing

Problem: B2B SaaS team of 5 writers produces 200 posts/year. Each post needs a "Try it now" CTA. Every writer built CTAs differently — different classes, link text, placement.

Solution: CQE cta preset with {{permalink}}. All writers use the same button.

Result: Consistent CTAs across 200 posts. ~6 h/month saved on CTA review. At $45/h editorial + $150/h agency oversight = ~$11,700/year saved.

News media standardization

Problem: Regional newspaper group with 12 writers. Pull quotes varied wildly — <blockquote>, <div class="pq">, italicized text. No consistency.

Solution: quote and highlight presets. New journalists onboard in 5 minutes.

Result: Consistent markup across 500+ articles/month. 80% fewer style guide violations.

Agency multi-client deployment

Problem: Agency managing 15 WordPress sites for different clients. Each needs editorial Quicktags but markup standards vary.

Solution: Baseline presets (alert, quote, cta) deployed to all 15 sites via wp cqe preset. Client-specific buttons added per site. JSON export goes into client delivery folders.

Result: Onboarding dropped from 2 hours to 20 minutes per client.

E-commerce product pages

Problem: Online retailer with 1,000+ product pages. Shipping, return, and size-guide notices needed consistent HTML. Editors kept mangling <div class="shipping-notice"> variations.

Solution: Three CQE buttons — "Shipping", "Returns", "Size guide" — with pre-validated HTML and {{site_url}} policy links.

Result: Zero broken policy links in 3 months.

Gutenberg compatibility — the full picture

CQE was built for the hybrid editorial world where Gutenberg is the default but structured HTML inserts still need a home.

Path 1: Classic block inside Gutenberg

Insert a Classic block — the full Quicktags toolbar (including all CQE buttons) appears inside it. This is the most common integration. Mix native Gutenberg blocks with one or two Classic blocks for custom HTML sections.

Ideal for: Posts that are 80% native blocks + 20% custom HTML (disclaimers, CTAs, pull quotes).

Path 2: CQE Gutenberg sidebar panel

CQE registers its own panel in the editor sidebar (right-hand panel). Editors click CQE buttons there without inserting a Classic block. Buttons are grouped by preset category.

Behavior: Inserts HTML at the cursor position of the active block. Best results with Classic block, custom HTML block, or paragraph block. Varies with native heading/image blocks.

Ideal for: Editors who prefer sidebar workflow and minimize Classic block usage.

Path 3: Hybrid with reusable blocks

Gutenberg reusable blocks handle large, static sections (author bios, fixed disclaimers). CQE handles inline inserts that vary per post (CTA with permalink, share bar, FAQ items).

Typical 2026 US editorial workflow: 80% native Gutenberg, 15% Classic block + CQE, 5% reusable blocks.

Feature comparison

When NOT to use CQE

• Elementor / Divi / Bricks — CQE does not inject into builder canvases
• FSE templates — CQE targets post editor, not site editor
• WooCommerce product tabs — Works with Classic block; overkill if using native product tabs

Developer hooks — extending CQE programmatically

For US agencies and developers, CQE exposes PHP filters and actions for custom integration:

Filters

// Override preset HTML per client CSS framework
add_filter('cqe_preset_html', function($html, $preset_slug) {
    if ($preset_slug === 'alert') {
        $html['start'] = '<div class="client-alert client-alert--warning">';
    }
    return $html;
}, 10, 2);

// Register custom placeholders
add_filter('cqe_placeholders', function($tokens) {
    $tokens['client_id'] = get_post_meta(get_the_ID(), 'client_id', true);
    $tokens['campaign']  = get_post_meta(get_the_ID(), 'campaign_name', true);
    return $tokens;
});

// Control button visibility by role programmatically
add_filter('cqe_button_visible', function($visible, $button_id, $post_type) {
    if ($button_id === 'legal_disclaimer' && !current_user_can('edit_published_posts')) {
        return false;
    }
    return $visible;
}, 10, 3);

Actions

// Log preset application for audit trails
add_action('cqe_after_preset_applied', function($preset_slug, $button_ids) {
    error_log(sprintf('[CQE] Preset %s applied — buttons: %s', $preset_slug, implode(', ', $button_ids)));
}, 10, 2);

// Attach agency metadata to exports
add_action('cqe_before_export', function($export_data) {
    $export_data['_agency'] = [
        'client'      => 'Acme Corp',
        'engagement'  => 'WP-2024-0381',
        'exported_by' => wp_get_current_user()->user_login,
    ];
});

WP-CLI deployment script example

# Deploy CQE config across environments
wp @staging cqe preset alert
wp @staging cqe preset disclaimer
wp @staging cqe export --file=baseline.json
# After sign-off:
wp @prod cqe import --file=baseline.json

These hooks matter most in US agency workflows where each client has a unique CSS framework, compliance requirements, and editorial hierarchy. A single mu-plugin with filters handles the variation, and the WP-CLI export becomes a deployable artifact.

Common mistakes and how to avoid them

“My buttons do not show”

Why: post type unchecked, role excluded, or HTML tab disabled on button.

Fix: edit button → Post types = post + page → test Text tab.

“AddQuicktag import = 0 buttons”

Why: plugin already removed, DB option wiped.

Fix: restore client .wpaq backup → manual upload on Migrate tab.

“HTML looks ugly on the public site”

Why: Front CSS disabled — cqe-* classes unstylized.

Fix: CQE settings → enable Front CSS or copy styles to child theme.

“10 button limit reached”

Why: guest tier — large AQ import.

Fix: connect a free Volade account → unlimited buttons.

“Empty Gutenberg sidebar”

Why: editing in Elementor or non-Classic block.

Fix: open a Classic block or post in native editor.

Your plan this week

Custom Quicktag Editor checklist

• AddQuicktag inventory + .wpaq export
• CQE installed on staging
• AddQuicktag or .wpaq import successful
• Alert + Quote presets applied (merge)
• Front CSS enabled if needed
• {{year}} / {{permalink}} placeholders tested
• 2 pilot editors trained
• JSON export wp cqe export archived
• AddQuicktag removed in prod after UAT
• Volade account if > 10 buttons

Recommended tools

• Custom Quicktag Editor by Volade
• Plugin Usage Detector by Volade — audit legacy editor plugins
• Volade V+ pricing — role rules, groups, button usage log

Downloadable resources

Printable checklist, editorial preset JSON pack, 48 h agency runbook and preset decision tree — in this article’s resource panel. Members unlock the 12-page complete guide with preset matrices and client email scripts.

FAQ — questions US developers and agencies ask most

Can I use CQE alongside Gutenberg without conflicts?

Yes. CQE adds a sidebar panel in the Gutenberg editor and works inside Classic blocks. Neither conflicts with native Gutenberg blocks. You can build 80% of a post with native blocks and use CQE Quicktags for the remaining custom HTML (alerts, disclaimers, CTAs) inside a Classic block or via the sidebar.

Is AddQuicktag migration safe? Can I roll back?

Yes — if you export before deleting. CQE reads AddQuicktag settings from the database (rmnlQuicktagSettings) or a .wpaq file. Keep AddQuicktag active for 7 days while you test CQE on staging. Use wp cqe export to create a portable JSON backup. Migration is non-destructive — CQE copies, it does not delete AddQuicktag data.

Does CQE expose developer hooks for custom integrations?

Yes. CQE provides PHP filters (cqe_preset_html, cqe_placeholders, cqe_button_visible) and actions (cqe_after_preset_applied, cqe_before_export). US agencies use these to standardize markup across clients — a single mu-plugin filter rewrites presets to match each client's CSS framework. See the "Developer hooks" section for code examples.

How does CQE handle multisite networks?

Network-wide presets via cqe_apply_preset_network. Each subsite retains its own buttons, but a super admin can push standard presets (alert, disclaimer, cta) to all sites in one WP-CLI command. JSON export is compatible across single-site and multisite — useful for agencies deploying the same config to 20+ client sites.

What happens to my buttons if I deactivate CQE?

Quicktags stop appearing in the editor, but previously inserted HTML remains in your posts — it is standard HTML, not plugin-dependent. Button configurations stay in the database as WordPress options. Reactivate CQE and everything is restored. The JSON export is an additional safety layer.

Can I use CQE in ACF WYSIWYG fields?

Yes, with one setting. The ACF field must have "Show Quicktags" checked. Once enabled, all CQE buttons appear in the field's Text tab. Test per field group — some ACF configurations suppress the Text tab entirely, in which case CQE buttons will not display.

Can I transfer buttons between sites?

Yes — built-in import/export. CQE Settings → Backup tab, or CLI: wp cqe export --file=export.json. Transfer the file to the target site and import. Works for staging → prod, client onboarding, and multisite subsite cloning.

Conclusion — your buttons deserve better than a dead plugin

AddQuicktag served a generation of WordPress editorial teams well. In 2026, keeping it is betting on nostalgia — not the next update.

Simple timeline: install CQE → import AddQuicktag → apply 2–3 presets → train team → export JSON → remove legacy. Half a day on staging, one client email, and editors get the click instead of copy-paste.

The ROI case for US agencies

Consider a content team of 5 writers, each producing 60 posts per year. If each post needs 3 custom HTML inserts (disclaimer, CTA, pull quote) and manual typing takes 30 seconds per insert:

• Manual: 5 × 60 × 3 × 30s = 7.5 hours/year typing HTML
• With CQE: 5 × 60 × 3 × 2s = 0.5 hours/year (one click each)
• Net savings: 7 hours/year per content team
• At a blended US editorial rate of $45/h: $315 saved per team per year
• Plus: zero HTML errors, zero broken classes, zero onboarding time

CQE is free. The time savings pay for the five minutes it takes to install it.

Our final recommendation

This week on a pilot site, import AddQuicktag, apply Alert preset, draft a test post with {{year}} in a disclaimer. Then show the Quicktags bar to your most skeptical editor.

If you support 5+ WordPress sites, use the WP-CLI workflow (wp cqe preset alert, wp cqe export --file=client-config.json) to standardize your editorial stack across clients. The 7-phase agency workflow becomes a repeatable runbook — attach the JSON export to your client delivery folder.

Happy writing. Your buttons will thank you. And your editors will too.

---

Article updated July 2, 2026. Sources: CQE 1.0 code, AddQuicktag migration tests, WordPress Quicktags API documentation, internal agency deployment data.